tsd.h

Go to the documentation of this file.

/******************************************************************************/
#ifdef JEMALLOC_H_TYPES

/* Maximum number of malloc_tsd users with cleanup functions. */
#define MALLOC_TSD_CLEANUPS_MAX 8

typedef bool (*malloc_tsd_cleanup_t)(void);

#if (!defined(JEMALLOC_MALLOC_THREAD_CLEANUP) && !defined(JEMALLOC_TLS) && \
 !defined(_WIN32))
typedef struct tsd_init_block_s tsd_init_block_t;
typedef struct tsd_init_head_s tsd_init_head_t;
#endif

/*
 * TLS/TSD-agnostic macro-based implementation of thread-specific data. There
 * are four macros that support (at least) three use cases: file-private,
 * library-private, and library-private inlined. Following is an example
 * library-private tsd variable:
 *
 * In example.h:
 * typedef struct {
 * int x;
 * int y;
 * } example_t;
 * #define EX_INITIALIZER JEMALLOC_CONCAT({0, 0})
 * malloc_tsd_protos(, example, example_t *)
 * malloc_tsd_externs(example, example_t *)
 * In example.c:
 * malloc_tsd_data(, example, example_t *, EX_INITIALIZER)
 * malloc_tsd_funcs(, example, example_t *, EX_INITIALIZER,
 * example_tsd_cleanup)
 *
 * The result is a set of generated functions, e.g.:
 *
 * bool example_tsd_boot(void) {...}
 * example_t **example_tsd_get() {...}
 * void example_tsd_set(example_t **val) {...}
 *
 * Note that all of the functions deal in terms of (a_type *) rather than
 * (a_type) so that it is possible to support non-pointer types (unlike
 * pthreads TSD). example_tsd_cleanup() is passed an (a_type *) pointer that is
 * cast to (void *). This means that the cleanup function needs to cast *and*
 * dereference the function argument, e.g.:
 *
 * void
 * example_tsd_cleanup(void *arg)
 * {
 * example_t *example = *(example_t **)arg;
 *
 * [...]
 * if ([want the cleanup function to be called again]) {
 * example_tsd_set(&example);
 * }
 * }
 *
 * If example_tsd_set() is called within example_tsd_cleanup(), it will be
 * called again. This is similar to how pthreads TSD destruction works, except
 * that pthreads only calls the cleanup function again if the value was set to
 * non-NULL.
 */

/* malloc_tsd_protos(). */
#define malloc_tsd_protos(a_attr, a_name, a_type) \
a_attr bool \
a_name##_tsd_boot(void); \
a_attr a_type * \
a_name##_tsd_get(void); \
a_attr void \
a_name##_tsd_set(a_type *val);

/* malloc_tsd_externs(). */
#ifdef JEMALLOC_MALLOC_THREAD_CLEANUP
#define malloc_tsd_externs(a_name, a_type) \
extern __thread a_type a_name##_tls; \
extern __thread bool a_name##_initialized; \
extern bool a_name##_booted;
#elif (defined(JEMALLOC_TLS))
#define malloc_tsd_externs(a_name, a_type) \
extern __thread a_type a_name##_tls; \
extern pthread_key_t a_name##_tsd; \
extern bool a_name##_booted;
#elif (defined(_WIN32))
#define malloc_tsd_externs(a_name, a_type) \
extern DWORD a_name##_tsd; \
extern bool a_name##_booted;
#else
#define malloc_tsd_externs(a_name, a_type) \
extern pthread_key_t a_name##_tsd; \
extern tsd_init_head_t a_name##_tsd_init_head; \
extern bool a_name##_booted;
#endif

/* malloc_tsd_data(). */
#ifdef JEMALLOC_MALLOC_THREAD_CLEANUP
#define malloc_tsd_data(a_attr, a_name, a_type, a_initializer) \
a_attr __thread a_type JEMALLOC_TLS_MODEL \
 a_name##_tls = a_initializer; \
a_attr __thread bool JEMALLOC_TLS_MODEL \
 a_name##_initialized = false; \
a_attr bool a_name##_booted = false;
#elif (defined(JEMALLOC_TLS))
#define malloc_tsd_data(a_attr, a_name, a_type, a_initializer) \
a_attr __thread a_type JEMALLOC_TLS_MODEL \
 a_name##_tls = a_initializer; \
a_attr pthread_key_t a_name##_tsd; \
a_attr bool a_name##_booted = false;
#elif (defined(_WIN32))
#define malloc_tsd_data(a_attr, a_name, a_type, a_initializer) \
a_attr DWORD a_name##_tsd; \
a_attr bool a_name##_booted = false;
#else
#define malloc_tsd_data(a_attr, a_name, a_type, a_initializer) \
a_attr pthread_key_t a_name##_tsd; \
a_attr tsd_init_head_t a_name##_tsd_init_head = { \
 ql_head_initializer(blocks), \
 MALLOC_MUTEX_INITIALIZER \
}; \
a_attr bool a_name##_booted = false;
#endif

/* malloc_tsd_funcs(). */
#ifdef JEMALLOC_MALLOC_THREAD_CLEANUP
#define malloc_tsd_funcs(a_attr, a_name, a_type, a_initializer, \
 a_cleanup) \
/* Initialization/cleanup. */ \
a_attr bool \
a_name##_tsd_cleanup_wrapper(void) \
{ \
 \
 if (a_name##_initialized) { \
 a_name##_initialized = false; \
 a_cleanup(&a_name##_tls); \
 } \
 return (a_name##_initialized); \
} \
a_attr bool \
a_name##_tsd_boot(void) \
{ \
 \
 if (a_cleanup != malloc_tsd_no_cleanup) { \
 malloc_tsd_cleanup_register( \
 &a_name##_tsd_cleanup_wrapper); \
 } \
 a_name##_booted = true; \
 return (false); \
} \
/* Get/set. */ \
a_attr a_type * \
a_name##_tsd_get(void) \
{ \
 \
 assert(a_name##_booted); \
 return (&a_name##_tls); \
} \
a_attr void \
a_name##_tsd_set(a_type *val) \
{ \
 \
 assert(a_name##_booted); \
 a_name##_tls = (*val); \
 if (a_cleanup != malloc_tsd_no_cleanup) \
 a_name##_initialized = true; \
}
#elif (defined(JEMALLOC_TLS))
#define malloc_tsd_funcs(a_attr, a_name, a_type, a_initializer, \
 a_cleanup) \
/* Initialization/cleanup. */ \
a_attr bool \
a_name##_tsd_boot(void) \
{ \
 \
 if (a_cleanup != malloc_tsd_no_cleanup) { \
 if (pthread_key_create(&a_name##_tsd, a_cleanup) != 0) \
 return (true); \
 } \
 a_name##_booted = true; \
 return (false); \
} \
/* Get/set. */ \
a_attr a_type * \
a_name##_tsd_get(void) \
{ \
 \
 assert(a_name##_booted); \
 return (&a_name##_tls); \
} \
a_attr void \
a_name##_tsd_set(a_type *val) \
{ \
 \
 assert(a_name##_booted); \
 a_name##_tls = (*val); \
 if (a_cleanup != malloc_tsd_no_cleanup) { \
 if (pthread_setspecific(a_name##_tsd, \
 (void *)(&a_name##_tls))) { \
 malloc_write("<jemalloc>: Error" \
 " setting TSD for "#a_name"\n"); \
 if (opt_abort) \
 abort(); \
 } \
 } \
}
#elif (defined(_WIN32))
#define malloc_tsd_funcs(a_attr, a_name, a_type, a_initializer, \
 a_cleanup) \
/* Data structure. */ \
typedef struct { \
 bool initialized; \
 a_type val; \
} a_name##_tsd_wrapper_t; \
/* Initialization/cleanup. */ \
a_attr bool \
a_name##_tsd_cleanup_wrapper(void) \
{ \
 a_name##_tsd_wrapper_t *wrapper; \
 \
 wrapper = (a_name##_tsd_wrapper_t *) TlsGetValue(a_name##_tsd); \
 if (wrapper == NULL) \
 return (false); \
 if (a_cleanup != malloc_tsd_no_cleanup && \
 wrapper->initialized) { \
 a_type val = wrapper->val; \
 a_type tsd_static_data = a_initializer; \
 wrapper->initialized = false; \
 wrapper->val = tsd_static_data; \
 a_cleanup(&val); \
 if (wrapper->initialized) { \
 /* Trigger another cleanup round. */ \
 return (true); \
 } \
 } \
 malloc_tsd_dalloc(wrapper); \
 return (false); \
} \
a_attr bool \
a_name##_tsd_boot(void) \
{ \
 \
 a_name##_tsd = TlsAlloc(); \
 if (a_name##_tsd == TLS_OUT_OF_INDEXES) \
 return (true); \
 if (a_cleanup != malloc_tsd_no_cleanup) { \
 malloc_tsd_cleanup_register( \
 &a_name##_tsd_cleanup_wrapper); \
 } \
 a_name##_booted = true; \
 return (false); \
} \
/* Get/set. */ \
a_attr a_name##_tsd_wrapper_t * \
a_name##_tsd_get_wrapper(void) \
{ \
 a_name##_tsd_wrapper_t *wrapper = (a_name##_tsd_wrapper_t *) \
 TlsGetValue(a_name##_tsd); \
 \
 if (wrapper == NULL) { \
 wrapper = (a_name##_tsd_wrapper_t *) \
 malloc_tsd_malloc(sizeof(a_name##_tsd_wrapper_t)); \
 if (wrapper == NULL) { \
 malloc_write("<jemalloc>: Error allocating" \
 " TSD for "#a_name"\n"); \
 abort(); \
 } else { \
 static a_type tsd_static_data = a_initializer; \
 wrapper->initialized = false; \
 wrapper->val = tsd_static_data; \
 } \
 if (!TlsSetValue(a_name##_tsd, (void *)wrapper)) { \
 malloc_write("<jemalloc>: Error setting" \
 " TSD for "#a_name"\n"); \
 abort(); \
 } \
 } \
 return (wrapper); \
} \
a_attr a_type * \
a_name##_tsd_get(void) \
{ \
 a_name##_tsd_wrapper_t *wrapper; \
 \
 assert(a_name##_booted); \
 wrapper = a_name##_tsd_get_wrapper(); \
 return (&wrapper->val); \
} \
a_attr void \
a_name##_tsd_set(a_type *val) \
{ \
 a_name##_tsd_wrapper_t *wrapper; \
 \
 assert(a_name##_booted); \
 wrapper = a_name##_tsd_get_wrapper(); \
 wrapper->val = *(val); \
 if (a_cleanup != malloc_tsd_no_cleanup) \
 wrapper->initialized = true; \
}
#else
#define malloc_tsd_funcs(a_attr, a_name, a_type, a_initializer, \
 a_cleanup) \
/* Data structure. */ \
typedef struct { \
 bool initialized; \
 a_type val; \
} a_name##_tsd_wrapper_t; \
/* Initialization/cleanup. */ \
a_attr void \
a_name##_tsd_cleanup_wrapper(void *arg) \
{ \
 a_name##_tsd_wrapper_t *wrapper = (a_name##_tsd_wrapper_t *)arg;\
 \
 if (a_cleanup != malloc_tsd_no_cleanup && \
 wrapper->initialized) { \
 wrapper->initialized = false; \
 a_cleanup(&wrapper->val); \
 if (wrapper->initialized) { \
 /* Trigger another cleanup round. */ \
 if (pthread_setspecific(a_name##_tsd, \
 (void *)wrapper)) { \
 malloc_write("<jemalloc>: Error" \
 " setting TSD for "#a_name"\n"); \
 if (opt_abort) \
 abort(); \
 } \
 return; \
 } \
 } \
 malloc_tsd_dalloc(wrapper); \
} \
a_attr bool \
a_name##_tsd_boot(void) \
{ \
 \
 if (pthread_key_create(&a_name##_tsd, \
 a_name##_tsd_cleanup_wrapper) != 0) \
 return (true); \
 a_name##_booted = true; \
 return (false); \
} \
/* Get/set. */ \
a_attr a_name##_tsd_wrapper_t * \
a_name##_tsd_get_wrapper(void) \
{ \
 a_name##_tsd_wrapper_t *wrapper = (a_name##_tsd_wrapper_t *) \
 pthread_getspecific(a_name##_tsd); \
 \
 if (wrapper == NULL) { \
 tsd_init_block_t block; \
 wrapper = tsd_init_check_recursion( \
 &a_name##_tsd_init_head, &block); \
 if (wrapper) \
 return (wrapper); \
 wrapper = (a_name##_tsd_wrapper_t *) \
 malloc_tsd_malloc(sizeof(a_name##_tsd_wrapper_t)); \
 block.data = wrapper; \
 if (wrapper == NULL) { \
 malloc_write("<jemalloc>: Error allocating" \
 " TSD for "#a_name"\n"); \
 abort(); \
 } else { \
 static a_type tsd_static_data = a_initializer; \
 wrapper->initialized = false; \
 wrapper->val = tsd_static_data; \
 } \
 if (pthread_setspecific(a_name##_tsd, \
 (void *)wrapper)) { \
 malloc_write("<jemalloc>: Error setting" \
 " TSD for "#a_name"\n"); \
 abort(); \
 } \
 tsd_init_finish(&a_name##_tsd_init_head, &block); \
 } \
 return (wrapper); \
} \
a_attr a_type * \
a_name##_tsd_get(void) \
{ \
 a_name##_tsd_wrapper_t *wrapper; \
 \
 assert(a_name##_booted); \
 wrapper = a_name##_tsd_get_wrapper(); \
 return (&wrapper->val); \
} \
a_attr void \
a_name##_tsd_set(a_type *val) \
{ \
 a_name##_tsd_wrapper_t *wrapper; \
 \
 assert(a_name##_booted); \
 wrapper = a_name##_tsd_get_wrapper(); \
 wrapper->val = *(val); \
 if (a_cleanup != malloc_tsd_no_cleanup) \
 wrapper->initialized = true; \
}
#endif

#endif /* JEMALLOC_H_TYPES */
/******************************************************************************/
#ifdef JEMALLOC_H_STRUCTS

#if (!defined(JEMALLOC_MALLOC_THREAD_CLEANUP) && !defined(JEMALLOC_TLS) && \
 !defined(_WIN32))
struct tsd_init_block_s {
 ql_elm(tsd_init_block_t) link;
 pthread_t thread;
 void *data;
};
struct tsd_init_head_s {
 ql_head(tsd_init_block_t) blocks;
 malloc_mutex_t lock;
};
#endif

#endif /* JEMALLOC_H_STRUCTS */
/******************************************************************************/
#ifdef JEMALLOC_H_EXTERNS

void *malloc_tsd_malloc(size_t size);
void malloc_tsd_dalloc(void *wrapper);
void malloc_tsd_no_cleanup(void *);
void malloc_tsd_cleanup_register(bool (*f)(void));
void malloc_tsd_boot(void);
#if (!defined(JEMALLOC_MALLOC_THREAD_CLEANUP) && !defined(JEMALLOC_TLS) && \
 !defined(_WIN32))
void *tsd_init_check_recursion(tsd_init_head_t *head,
 tsd_init_block_t *block);
void tsd_init_finish(tsd_init_head_t *head, tsd_init_block_t *block);
#endif

#endif /* JEMALLOC_H_EXTERNS */
/******************************************************************************/
#ifdef JEMALLOC_H_INLINES

#endif /* JEMALLOC_H_INLINES */
/******************************************************************************/