mirror of
https://github.com/MariaDB/server.git
synced 2025-01-22 06:44:16 +01:00
a10ae35328
Essentially, the problem is that safemalloc is excruciatingly slow as it checks all allocated blocks for overrun at each memory management primitive, yielding a almost exponential slowdown for the memory management functions (malloc, realloc, free). The overrun check basically consists of verifying some bytes of a block for certain magic keys, which catches some simple forms of overrun. Another minor problem is violation of aliasing rules and that its own internal list of blocks is prone to corruption. Another issue with safemalloc is rather the maintenance cost as the tool has a significant impact on the server code. Given the magnitude of memory debuggers available nowadays, especially those that are provided with the platform malloc implementation, maintenance of a in-house and largely obsolete memory debugger becomes a burden that is not worth the effort due to its slowness and lack of support for detecting more common forms of heap corruption. Since there are third-party tools that can provide the same functionality at a lower or comparable performance cost, the solution is to simply remove safemalloc. Third-party tools can provide the same functionality at a lower or comparable performance cost. The removal of safemalloc also allows a simplification of the malloc wrappers, removing quite a bit of kludge: redefinition of my_malloc, my_free and the removal of the unused second argument of my_free. Since free() always check whether the supplied pointer is null, redudant checks are also removed. Also, this patch adds unit testing for my_malloc and moves my_realloc implementation into the same file as the other memory allocation primitives.
268 lines
9 KiB
C
268 lines
9 KiB
C
/* Copyright (C) 2007-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
|
|
|
#ifndef _lf_h
|
|
#define _lf_h
|
|
|
|
#include <my_atomic.h>
|
|
|
|
C_MODE_START
|
|
|
|
/*
|
|
Helpers to define both func() and _func(), where
|
|
func() is a _func() protected by my_atomic_rwlock_wrlock()
|
|
*/
|
|
|
|
#define lock_wrap(f, t, proto_args, args, lock) \
|
|
t _ ## f proto_args; \
|
|
static inline t f proto_args \
|
|
{ \
|
|
t ret; \
|
|
my_atomic_rwlock_wrlock(lock); \
|
|
ret= _ ## f args; \
|
|
my_atomic_rwlock_wrunlock(lock); \
|
|
return ret; \
|
|
}
|
|
|
|
#define lock_wrap_void(f, proto_args, args, lock) \
|
|
void _ ## f proto_args; \
|
|
static inline void f proto_args \
|
|
{ \
|
|
my_atomic_rwlock_wrlock(lock); \
|
|
_ ## f args; \
|
|
my_atomic_rwlock_wrunlock(lock); \
|
|
}
|
|
|
|
#define nolock_wrap(f, t, proto_args, args) \
|
|
t _ ## f proto_args; \
|
|
static inline t f proto_args \
|
|
{ \
|
|
return _ ## f args; \
|
|
}
|
|
|
|
#define nolock_wrap_void(f, proto_args, args) \
|
|
void _ ## f proto_args; \
|
|
static inline void f proto_args \
|
|
{ \
|
|
_ ## f args; \
|
|
}
|
|
|
|
/*
|
|
wait-free dynamic array, see lf_dynarray.c
|
|
|
|
4 levels of 256 elements each mean 4311810304 elements in an array - it
|
|
should be enough for a while
|
|
*/
|
|
#define LF_DYNARRAY_LEVEL_LENGTH 256
|
|
#define LF_DYNARRAY_LEVELS 4
|
|
|
|
typedef struct {
|
|
void * volatile level[LF_DYNARRAY_LEVELS];
|
|
uint size_of_element;
|
|
my_atomic_rwlock_t lock;
|
|
} LF_DYNARRAY;
|
|
|
|
typedef int (*lf_dynarray_func)(void *, void *);
|
|
|
|
void lf_dynarray_init(LF_DYNARRAY *array, uint element_size);
|
|
void lf_dynarray_destroy(LF_DYNARRAY *array);
|
|
|
|
nolock_wrap(lf_dynarray_value, void *,
|
|
(LF_DYNARRAY *array, uint idx),
|
|
(array, idx))
|
|
lock_wrap(lf_dynarray_lvalue, void *,
|
|
(LF_DYNARRAY *array, uint idx),
|
|
(array, idx),
|
|
&array->lock)
|
|
nolock_wrap(lf_dynarray_iterate, int,
|
|
(LF_DYNARRAY *array, lf_dynarray_func func, void *arg),
|
|
(array, func, arg))
|
|
|
|
/*
|
|
pin manager for memory allocator, lf_alloc-pin.c
|
|
*/
|
|
|
|
#define LF_PINBOX_PINS 4
|
|
#define LF_PURGATORY_SIZE 10
|
|
|
|
typedef void lf_pinbox_free_func(void *, void *, void*);
|
|
|
|
typedef struct {
|
|
LF_DYNARRAY pinarray;
|
|
lf_pinbox_free_func *free_func;
|
|
void *free_func_arg;
|
|
uint free_ptr_offset;
|
|
uint32 volatile pinstack_top_ver; /* this is a versioned pointer */
|
|
uint32 volatile pins_in_array; /* number of elements in array */
|
|
} LF_PINBOX;
|
|
|
|
typedef struct {
|
|
void * volatile pin[LF_PINBOX_PINS];
|
|
LF_PINBOX *pinbox;
|
|
void **stack_ends_here;
|
|
void *purgatory;
|
|
uint32 purgatory_count;
|
|
uint32 volatile link;
|
|
/* we want sizeof(LF_PINS) to be 64 to avoid false sharing */
|
|
#if SIZEOF_INT*2+SIZEOF_CHARP*(LF_PINBOX_PINS+3) != 64
|
|
char pad[64-sizeof(uint32)*2-sizeof(void*)*(LF_PINBOX_PINS+3)];
|
|
#endif
|
|
} LF_PINS;
|
|
|
|
/*
|
|
shortcut macros to do an atomic_wrlock on a structure that uses pins
|
|
(e.g. lf_hash).
|
|
*/
|
|
#define lf_rwlock_by_pins(PINS) \
|
|
my_atomic_rwlock_wrlock(&(PINS)->pinbox->pinarray.lock)
|
|
#define lf_rwunlock_by_pins(PINS) \
|
|
my_atomic_rwlock_wrunlock(&(PINS)->pinbox->pinarray.lock)
|
|
|
|
/*
|
|
compile-time assert, to require "no less than N" pins
|
|
it's enough if it'll fail on at least one compiler, so
|
|
we'll enable it on GCC only, which supports zero-length arrays.
|
|
*/
|
|
#if defined(__GNUC__) && defined(MY_LF_EXTRA_DEBUG)
|
|
#define LF_REQUIRE_PINS(N) \
|
|
static const char require_pins[LF_PINBOX_PINS-N] \
|
|
__attribute__ ((unused)); \
|
|
static const int LF_NUM_PINS_IN_THIS_FILE= N;
|
|
#define _lf_pin(PINS, PIN, ADDR) \
|
|
( \
|
|
assert(PIN < LF_NUM_PINS_IN_THIS_FILE), \
|
|
my_atomic_storeptr(&(PINS)->pin[PIN], (ADDR)) \
|
|
)
|
|
#else
|
|
#define LF_REQUIRE_PINS(N)
|
|
#define _lf_pin(PINS, PIN, ADDR) my_atomic_storeptr(&(PINS)->pin[PIN], (ADDR))
|
|
#endif
|
|
|
|
#define _lf_unpin(PINS, PIN) _lf_pin(PINS, PIN, NULL)
|
|
#define lf_pin(PINS, PIN, ADDR) \
|
|
do { \
|
|
lf_rwlock_by_pins(PINS); \
|
|
_lf_pin(PINS, PIN, ADDR); \
|
|
lf_rwunlock_by_pins(PINS); \
|
|
} while (0)
|
|
#define lf_unpin(PINS, PIN) lf_pin(PINS, PIN, NULL)
|
|
#define _lf_assert_pin(PINS, PIN) assert((PINS)->pin[PIN] != 0)
|
|
#define _lf_assert_unpin(PINS, PIN) assert((PINS)->pin[PIN] == 0)
|
|
|
|
void lf_pinbox_init(LF_PINBOX *pinbox, uint free_ptr_offset,
|
|
lf_pinbox_free_func *free_func, void * free_func_arg);
|
|
void lf_pinbox_destroy(LF_PINBOX *pinbox);
|
|
|
|
lock_wrap(lf_pinbox_get_pins, LF_PINS *,
|
|
(LF_PINBOX *pinbox),
|
|
(pinbox),
|
|
&pinbox->pinarray.lock)
|
|
lock_wrap_void(lf_pinbox_put_pins,
|
|
(LF_PINS *pins),
|
|
(pins),
|
|
&pins->pinbox->pinarray.lock)
|
|
lock_wrap_void(lf_pinbox_free,
|
|
(LF_PINS *pins, void *addr),
|
|
(pins, addr),
|
|
&pins->pinbox->pinarray.lock)
|
|
|
|
/*
|
|
memory allocator, lf_alloc-pin.c
|
|
*/
|
|
|
|
typedef struct st_lf_allocator {
|
|
LF_PINBOX pinbox;
|
|
uchar * volatile top;
|
|
uint element_size;
|
|
uint32 volatile mallocs;
|
|
void (*constructor)(uchar *); /* called, when an object is malloc()'ed */
|
|
void (*destructor)(uchar *); /* called, when an object is free()'d */
|
|
} LF_ALLOCATOR;
|
|
|
|
void lf_alloc_init(LF_ALLOCATOR *allocator, uint size, uint free_ptr_offset);
|
|
void lf_alloc_destroy(LF_ALLOCATOR *allocator);
|
|
uint lf_alloc_pool_count(LF_ALLOCATOR *allocator);
|
|
/*
|
|
shortcut macros to access underlying pinbox functions from an LF_ALLOCATOR
|
|
see _lf_pinbox_get_pins() and _lf_pinbox_put_pins()
|
|
*/
|
|
#define _lf_alloc_free(PINS, PTR) _lf_pinbox_free((PINS), (PTR))
|
|
#define lf_alloc_free(PINS, PTR) lf_pinbox_free((PINS), (PTR))
|
|
#define _lf_alloc_get_pins(A) _lf_pinbox_get_pins(&(A)->pinbox)
|
|
#define lf_alloc_get_pins(A) lf_pinbox_get_pins(&(A)->pinbox)
|
|
#define _lf_alloc_put_pins(PINS) _lf_pinbox_put_pins(PINS)
|
|
#define lf_alloc_put_pins(PINS) lf_pinbox_put_pins(PINS)
|
|
#define lf_alloc_direct_free(ALLOC, ADDR) my_free((ADDR))
|
|
|
|
lock_wrap(lf_alloc_new, void *,
|
|
(LF_PINS *pins),
|
|
(pins),
|
|
&pins->pinbox->pinarray.lock)
|
|
|
|
C_MODE_END
|
|
|
|
/*
|
|
extendible hash, lf_hash.c
|
|
*/
|
|
#include <hash.h>
|
|
|
|
C_MODE_START
|
|
|
|
#define LF_HASH_UNIQUE 1
|
|
|
|
/* lf_hash overhead per element (that is, sizeof(LF_SLIST) */
|
|
extern const int LF_HASH_OVERHEAD;
|
|
|
|
typedef struct {
|
|
LF_DYNARRAY array; /* hash itself */
|
|
LF_ALLOCATOR alloc; /* allocator for elements */
|
|
my_hash_get_key get_key; /* see HASH */
|
|
CHARSET_INFO *charset; /* see HASH */
|
|
uint key_offset, key_length; /* see HASH */
|
|
uint element_size; /* size of memcpy'ed area on insert */
|
|
uint flags; /* LF_HASH_UNIQUE, etc */
|
|
int32 volatile size; /* size of array */
|
|
int32 volatile count; /* number of elements in the hash */
|
|
} LF_HASH;
|
|
|
|
void lf_hash_init(LF_HASH *hash, uint element_size, uint flags,
|
|
uint key_offset, uint key_length, my_hash_get_key get_key,
|
|
CHARSET_INFO *charset);
|
|
void lf_hash_destroy(LF_HASH *hash);
|
|
int lf_hash_insert(LF_HASH *hash, LF_PINS *pins, const void *data);
|
|
void *lf_hash_search(LF_HASH *hash, LF_PINS *pins, const void *key, uint keylen);
|
|
int lf_hash_delete(LF_HASH *hash, LF_PINS *pins, const void *key, uint keylen);
|
|
/*
|
|
shortcut macros to access underlying pinbox functions from an LF_HASH
|
|
see _lf_pinbox_get_pins() and _lf_pinbox_put_pins()
|
|
*/
|
|
#define _lf_hash_get_pins(HASH) _lf_alloc_get_pins(&(HASH)->alloc)
|
|
#define lf_hash_get_pins(HASH) lf_alloc_get_pins(&(HASH)->alloc)
|
|
#define _lf_hash_put_pins(PINS) _lf_pinbox_put_pins(PINS)
|
|
#define lf_hash_put_pins(PINS) lf_pinbox_put_pins(PINS)
|
|
#define lf_hash_search_unpin(PINS) lf_unpin((PINS), 2)
|
|
/*
|
|
cleanup
|
|
*/
|
|
|
|
#undef lock_wrap_void
|
|
#undef lock_wrap
|
|
#undef nolock_wrap_void
|
|
#undef nolock_wrap
|
|
|
|
C_MODE_END
|
|
|
|
#endif
|
|
|