server-skynet-source-3rd-je.../include/jemalloc/internal/mutex.h

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

typedef struct malloc_mutex_s malloc_mutex_t;

#ifdef _WIN32
#  define MALLOC_MUTEX_INITIALIZER
#elif (defined(JEMALLOC_OSSPIN))
#  define MALLOC_MUTEX_INITIALIZER {0}
#elif (defined(JEMALLOC_MUTEX_INIT_CB))
#  define MALLOC_MUTEX_INITIALIZER {PTHREAD_MUTEX_INITIALIZER, NULL}
#else
#  if (defined(JEMALLOC_HAVE_PTHREAD_MUTEX_ADAPTIVE_NP) &&		\
       defined(PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP))
#    define MALLOC_MUTEX_TYPE PTHREAD_MUTEX_ADAPTIVE_NP
#    define MALLOC_MUTEX_INITIALIZER {PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP}
#  else
#    define MALLOC_MUTEX_TYPE PTHREAD_MUTEX_DEFAULT
#    define MALLOC_MUTEX_INITIALIZER {PTHREAD_MUTEX_INITIALIZER}
#  endif
#endif

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

struct malloc_mutex_s {
#ifdef _WIN32
	CRITICAL_SECTION	lock;
#elif (defined(JEMALLOC_OSSPIN))
	OSSpinLock		lock;
#elif (defined(JEMALLOC_MUTEX_INIT_CB))
	pthread_mutex_t		lock;
	malloc_mutex_t		*postponed_next;
#else
	pthread_mutex_t		lock;
#endif
};

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

#ifdef JEMALLOC_LAZY_LOCK
extern bool isthreaded;
#else
#  undef isthreaded /* Undo private_namespace.h definition. */
#  define isthreaded true
#endif

bool	malloc_mutex_init(malloc_mutex_t *mutex);
void	malloc_mutex_prefork(malloc_mutex_t *mutex);
void	malloc_mutex_postfork_parent(malloc_mutex_t *mutex);
void	malloc_mutex_postfork_child(malloc_mutex_t *mutex);
bool	mutex_boot(void);

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

#ifndef JEMALLOC_ENABLE_INLINE
void	malloc_mutex_lock(malloc_mutex_t *mutex);
void	malloc_mutex_unlock(malloc_mutex_t *mutex);
#endif

#if (defined(JEMALLOC_ENABLE_INLINE) || defined(JEMALLOC_MUTEX_C_))
JEMALLOC_INLINE void
malloc_mutex_lock(malloc_mutex_t *mutex)
{

	if (isthreaded) {
#ifdef _WIN32
		EnterCriticalSection(&mutex->lock);
#elif (defined(JEMALLOC_OSSPIN))
		OSSpinLockLock(&mutex->lock);
#else
		pthread_mutex_lock(&mutex->lock);
#endif
	}
}

JEMALLOC_INLINE void
malloc_mutex_unlock(malloc_mutex_t *mutex)
{

	if (isthreaded) {
#ifdef _WIN32
		LeaveCriticalSection(&mutex->lock);
#elif (defined(JEMALLOC_OSSPIN))
		OSSpinLockUnlock(&mutex->lock);
#else
		pthread_mutex_unlock(&mutex->lock);
#endif
	}
}
#endif

#endif /* JEMALLOC_H_INLINES */
/******************************************************************************/
Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)). 2010-01-17 01:53:50 +08:00			`/******************************************************************************/`
			`#ifdef JEMALLOC_H_TYPES`

Postpone mutex initialization on FreeBSD. Postpone mutex initialization on FreeBSD until after base allocation is safe. 2012-04-03 23:47:07 +08:00			`typedef struct malloc_mutex_s malloc_mutex_t;`

Add support for Mingw 2012-04-22 12:27:46 +08:00			`#ifdef _WIN32`
			`# define MALLOC_MUTEX_INITIALIZER`
			`#elif (defined(JEMALLOC_OSSPIN))`
			`# define MALLOC_MUTEX_INITIALIZER {0}`
Postpone mutex initialization on FreeBSD. Postpone mutex initialization on FreeBSD until after base allocation is safe. 2012-04-03 23:47:07 +08:00			`#elif (defined(JEMALLOC_MUTEX_INIT_CB))`
Add support for Mingw 2012-04-22 12:27:46 +08:00			`# define MALLOC_MUTEX_INITIALIZER {PTHREAD_MUTEX_INITIALIZER, NULL}`
Use OSSpinLock*() for locking on OS X. pthread_mutex_lock() can call malloc() on OS X (!!!), which causes deadlock. Work around this by using spinlocks that are built of more primitive stuff. 2011-03-19 10:30:18 +08:00			`#else`
correctly detect adaptive mutexes in pthreads PTHREAD_MUTEX_ADAPTIVE_NP is an enum on glibc and not a macro, we must test for their existence by attempting compilation. 2014-08-31 11:57:06 +08:00			`# if (defined(JEMALLOC_HAVE_PTHREAD_MUTEX_ADAPTIVE_NP) && \`
Port to FreeBSD. Use FreeBSD-specific functions (_pthread_mutex_init_calloc_cb(), _malloc_{pre,post}fork()) to avoid bootstrapping issues due to allocation in libc and libthr. Add malloc_strtoumax() and use it instead of strtoul(). Disable validation code in malloc_vsnprintf() and malloc_strtoumax() until jemalloc is initialized. This is necessary because locale initialization causes allocation for both vsnprintf() and strtoumax(). Force the lazy-lock feature on in order to avoid pthread_self(), because it causes allocation. Use syscall(SYS_write, ...) rather than write(...), because libthr wraps write() and causes allocation. Without this workaround, it would not be possible to print error messages in malloc_conf_init() without substantially reworking bootstrapping. Fix choose_arena_hard() to look at how many threads are assigned to the candidate choice, rather than checking whether the arena is uninitialized. This bug potentially caused more arenas to be initialized than necessary. 2012-02-03 14:04:57 +08:00			`defined(PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP))`
			`# define MALLOC_MUTEX_TYPE PTHREAD_MUTEX_ADAPTIVE_NP`
Postpone mutex initialization on FreeBSD. Postpone mutex initialization on FreeBSD until after base allocation is safe. 2012-04-03 23:47:07 +08:00			`# define MALLOC_MUTEX_INITIALIZER {PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP}`
Reduce cpp conditional logic complexity. Convert configuration-related cpp conditional logic to use static constant variables, e.g.: #ifdef JEMALLOC_DEBUG [...] #endif becomes: if (config_debug) { [...] } The advantage is clearer, more concise code. The main disadvantage is that data structures no longer have conditionally defined fields, so they pay the cost of all fields regardless of whether they are used. In practice, this is only a minor concern; config_stats will go away in an upcoming change, and config_prof is the only other major feature that depends on more than a few special-purpose fields. 2012-02-11 12:22:09 +08:00			`# else`
Port to FreeBSD. Use FreeBSD-specific functions (_pthread_mutex_init_calloc_cb(), _malloc_{pre,post}fork()) to avoid bootstrapping issues due to allocation in libc and libthr. Add malloc_strtoumax() and use it instead of strtoul(). Disable validation code in malloc_vsnprintf() and malloc_strtoumax() until jemalloc is initialized. This is necessary because locale initialization causes allocation for both vsnprintf() and strtoumax(). Force the lazy-lock feature on in order to avoid pthread_self(), because it causes allocation. Use syscall(SYS_write, ...) rather than write(...), because libthr wraps write() and causes allocation. Without this workaround, it would not be possible to print error messages in malloc_conf_init() without substantially reworking bootstrapping. Fix choose_arena_hard() to look at how many threads are assigned to the candidate choice, rather than checking whether the arena is uninitialized. This bug potentially caused more arenas to be initialized than necessary. 2012-02-03 14:04:57 +08:00			`# define MALLOC_MUTEX_TYPE PTHREAD_MUTEX_DEFAULT`
Postpone mutex initialization on FreeBSD. Postpone mutex initialization on FreeBSD until after base allocation is safe. 2012-04-03 23:47:07 +08:00			`# define MALLOC_MUTEX_INITIALIZER {PTHREAD_MUTEX_INITIALIZER}`
Reduce cpp conditional logic complexity. Convert configuration-related cpp conditional logic to use static constant variables, e.g.: #ifdef JEMALLOC_DEBUG [...] #endif becomes: if (config_debug) { [...] } The advantage is clearer, more concise code. The main disadvantage is that data structures no longer have conditionally defined fields, so they pay the cost of all fields regardless of whether they are used. In practice, this is only a minor concern; config_stats will go away in an upcoming change, and config_prof is the only other major feature that depends on more than a few special-purpose fields. 2012-02-11 12:22:09 +08:00			`# endif`
Port to Mac OS X. Add Mac OS X support, based in large part on the OS X support in Mozilla's version of jemalloc. 2010-09-06 01:35:13 +08:00			`#endif`

Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)). 2010-01-17 01:53:50 +08:00			`#endif /* JEMALLOC_H_TYPES */`
			`/******************************************************************************/`
			`#ifdef JEMALLOC_H_STRUCTS`

Postpone mutex initialization on FreeBSD. Postpone mutex initialization on FreeBSD until after base allocation is safe. 2012-04-03 23:47:07 +08:00			`struct malloc_mutex_s {`
Add support for Mingw 2012-04-22 12:27:46 +08:00			`#ifdef _WIN32`
			`CRITICAL_SECTION lock;`
			`#elif (defined(JEMALLOC_OSSPIN))`
Postpone mutex initialization on FreeBSD. Postpone mutex initialization on FreeBSD until after base allocation is safe. 2012-04-03 23:47:07 +08:00			`OSSpinLock lock;`
			`#elif (defined(JEMALLOC_MUTEX_INIT_CB))`
			`pthread_mutex_t lock;`
			`malloc_mutex_t *postponed_next;`
			`#else`
			`pthread_mutex_t lock;`
			`#endif`
			`};`

Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)). 2010-01-17 01:53:50 +08:00			`#endif /* JEMALLOC_H_STRUCTS */`
			`/******************************************************************************/`
			`#ifdef JEMALLOC_H_EXTERNS`

			`#ifdef JEMALLOC_LAZY_LOCK`
			`extern bool isthreaded;`
			`#else`
Fix isthreaded-related build breakage. 2012-04-21 05:12:30 +08:00			`# undef isthreaded /* Undo private_namespace.h definition. */`
Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)). 2010-01-17 01:53:50 +08:00			`# define isthreaded true`
			`#endif`

			`bool malloc_mutex_init(malloc_mutex_t *mutex);`
Fix fork-related bugs. Acquire/release arena bin locks as part of the prefork/postfork. This bug made deadlock in the child between fork and exec a possibility. Split jemalloc_postfork() into jemalloc_postfork_{parent,child}() so that the child can reinitialize mutexes rather than unlocking them. In practice, this bug tended not to cause problems. 2012-03-14 07:31:41 +08:00			`void malloc_mutex_prefork(malloc_mutex_t *mutex);`
			`void malloc_mutex_postfork_parent(malloc_mutex_t *mutex);`
			`void malloc_mutex_postfork_child(malloc_mutex_t *mutex);`
Postpone mutex initialization on FreeBSD. Postpone mutex initialization on FreeBSD until after base allocation is safe. 2012-04-03 23:47:07 +08:00			`bool mutex_boot(void);`
Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)). 2010-01-17 01:53:50 +08:00
			`#endif /* JEMALLOC_H_EXTERNS */`
			`/******************************************************************************/`
			`#ifdef JEMALLOC_H_INLINES`

			`#ifndef JEMALLOC_ENABLE_INLINE`
			`void malloc_mutex_lock(malloc_mutex_t *mutex);`
			`void malloc_mutex_unlock(malloc_mutex_t *mutex);`
			`#endif`

			`#if (defined(JEMALLOC_ENABLE_INLINE) \|\| defined(JEMALLOC_MUTEX_C_))`
			`JEMALLOC_INLINE void`
			`malloc_mutex_lock(malloc_mutex_t *mutex)`
			`{`

Use OSSpinLock*() for locking on OS X. pthread_mutex_lock() can call malloc() on OS X (!!!), which causes deadlock. Work around this by using spinlocks that are built of more primitive stuff. 2011-03-19 10:30:18 +08:00			`if (isthreaded) {`
Add support for Mingw 2012-04-22 12:27:46 +08:00			`#ifdef _WIN32`
			`EnterCriticalSection(&mutex->lock);`
			`#elif (defined(JEMALLOC_OSSPIN))`
Postpone mutex initialization on FreeBSD. Postpone mutex initialization on FreeBSD until after base allocation is safe. 2012-04-03 23:47:07 +08:00			`OSSpinLockLock(&mutex->lock);`
Use OSSpinLock*() for locking on OS X. pthread_mutex_lock() can call malloc() on OS X (!!!), which causes deadlock. Work around this by using spinlocks that are built of more primitive stuff. 2011-03-19 10:30:18 +08:00			`#else`
Postpone mutex initialization on FreeBSD. Postpone mutex initialization on FreeBSD until after base allocation is safe. 2012-04-03 23:47:07 +08:00			`pthread_mutex_lock(&mutex->lock);`
Use OSSpinLock*() for locking on OS X. pthread_mutex_lock() can call malloc() on OS X (!!!), which causes deadlock. Work around this by using spinlocks that are built of more primitive stuff. 2011-03-19 10:30:18 +08:00			`#endif`
			`}`
Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)). 2010-01-17 01:53:50 +08:00			`}`

			`JEMALLOC_INLINE void`
			`malloc_mutex_unlock(malloc_mutex_t *mutex)`
			`{`

Use OSSpinLock*() for locking on OS X. pthread_mutex_lock() can call malloc() on OS X (!!!), which causes deadlock. Work around this by using spinlocks that are built of more primitive stuff. 2011-03-19 10:30:18 +08:00			`if (isthreaded) {`
Add support for Mingw 2012-04-22 12:27:46 +08:00			`#ifdef _WIN32`
			`LeaveCriticalSection(&mutex->lock);`
			`#elif (defined(JEMALLOC_OSSPIN))`
Postpone mutex initialization on FreeBSD. Postpone mutex initialization on FreeBSD until after base allocation is safe. 2012-04-03 23:47:07 +08:00			`OSSpinLockUnlock(&mutex->lock);`
Use OSSpinLock*() for locking on OS X. pthread_mutex_lock() can call malloc() on OS X (!!!), which causes deadlock. Work around this by using spinlocks that are built of more primitive stuff. 2011-03-19 10:30:18 +08:00			`#else`
Postpone mutex initialization on FreeBSD. Postpone mutex initialization on FreeBSD until after base allocation is safe. 2012-04-03 23:47:07 +08:00			`pthread_mutex_unlock(&mutex->lock);`
Use OSSpinLock*() for locking on OS X. pthread_mutex_lock() can call malloc() on OS X (!!!), which causes deadlock. Work around this by using spinlocks that are built of more primitive stuff. 2011-03-19 10:30:18 +08:00			`#endif`
			`}`
Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)). 2010-01-17 01:53:50 +08:00			`}`
			`#endif`

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