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

#ifndef JEMALLOC_INTERNAL_EXTENT_INLINES_H
#define JEMALLOC_INTERNAL_EXTENT_INLINES_H

#include "jemalloc/internal/mutex.h"
#include "jemalloc/internal/mutex_pool.h"
#include "jemalloc/internal/pages.h"
#include "jemalloc/internal/prng.h"
#include "jemalloc/internal/ql.h"
#include "jemalloc/internal/sc.h"
#include "jemalloc/internal/sz.h"

static inline void
extent_lock(tsdn_t *tsdn, extent_t *extent) {
	assert(extent != NULL);
	mutex_pool_lock(tsdn, &extent_mutex_pool, (uintptr_t)extent);
}

static inline void
extent_unlock(tsdn_t *tsdn, extent_t *extent) {
	assert(extent != NULL);
	mutex_pool_unlock(tsdn, &extent_mutex_pool, (uintptr_t)extent);
}

static inline void
extent_lock2(tsdn_t *tsdn, extent_t *extent1, extent_t *extent2) {
	assert(extent1 != NULL && extent2 != NULL);
	mutex_pool_lock2(tsdn, &extent_mutex_pool, (uintptr_t)extent1,
	    (uintptr_t)extent2);
}

static inline void
extent_unlock2(tsdn_t *tsdn, extent_t *extent1, extent_t *extent2) {
	assert(extent1 != NULL && extent2 != NULL);
	mutex_pool_unlock2(tsdn, &extent_mutex_pool, (uintptr_t)extent1,
	    (uintptr_t)extent2);
}

#endif /* JEMALLOC_INTERNAL_EXTENT_INLINES_H */
Break up headers into constituent parts This is part of a broader change to make header files better represent the dependencies between one another (see https://github.com/jemalloc/jemalloc/issues/533). It breaks up component headers into smaller parts that can be made to have a simpler dependency graph. For the autogenerated headers (smoothstep.h and size_classes.h), no splitting was necessary, so I didn't add support to emit multiple headers. 2017-01-11 10:06:31 +08:00			`#ifndef JEMALLOC_INTERNAL_EXTENT_INLINES_H`
			`#define JEMALLOC_INTERNAL_EXTENT_INLINES_H`
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
Header refactoring: unify and de-catchall mutex module 2017-05-24 03:28:19 +08:00			`#include "jemalloc/internal/mutex.h"`
Header refactoring: unify and de-catchall mutex_pool. 2017-05-24 05:56:24 +08:00			`#include "jemalloc/internal/mutex_pool.h"`
Header refactoring: pages.h - unify and remove from catchall. 2017-04-25 09:05:15 +08:00			`#include "jemalloc/internal/pages.h"`
Header refactoring: prng module - remove from the catchall and unify. 2017-04-20 03:48:50 +08:00			`#include "jemalloc/internal/prng.h"`
Header refactoring: break out ql.h dependencies 2017-04-11 08:11:33 +08:00			`#include "jemalloc/internal/ql.h"`
Hide size class computation behind a layer of indirection. This class removes almost all the dependencies on size_classes.h, accessing the data there only via the new module sc.h, which does not depend on any configuration options. In a subsequent commit, we'll remove the configure-time size class computations, doing them at boot time, instead. 2017-12-15 04:46:39 +08:00			`#include "jemalloc/internal/sc.h"`
Header refactoring: Pull size helpers out of jemalloc module. 2017-05-31 01:45:37 +08:00			`#include "jemalloc/internal/sz.h"`
Header refactoring: break out ql.h dependencies 2017-04-11 08:11:33 +08:00
Protect the rtree/extent interactions with a mutex pool. Instead of embedding a lock bit in rtree leaf elements, we associate extents with a small set of mutexes. This gets us two things: - We can use the system mutexes. This (hypothetically) protects us from priority inversion, and lets us stop doing a backoff/sleep loop, instead opting for precise wakeups from the mutex. - Cuts down on the number of mutex acquisitions we have to do (from 4 in the worst case to two). We end up simplifying most of the rtree code (which no longer has to deal with locking or concurrency at all), at the cost of additional complexity in the extent code: since the mutex protecting the rtree leaf elements is determined by reading the extent out of those elements, the initial read is racy, so that we may acquire an out of date mutex. We re-check the extent in the leaf after acquiring the mutex to protect us from this race. 2017-05-16 05:23:51 +08:00			`static inline void`
			`extent_lock(tsdn_t tsdn, extent_t extent) {`
			`assert(extent != NULL);`
			`mutex_pool_lock(tsdn, &extent_mutex_pool, (uintptr_t)extent);`
			`}`

			`static inline void`
			`extent_unlock(tsdn_t tsdn, extent_t extent) {`
			`assert(extent != NULL);`
			`mutex_pool_unlock(tsdn, &extent_mutex_pool, (uintptr_t)extent);`
			`}`

			`static inline void`
			`extent_lock2(tsdn_t tsdn, extent_t extent1, extent_t *extent2) {`
			`assert(extent1 != NULL && extent2 != NULL);`
			`mutex_pool_lock2(tsdn, &extent_mutex_pool, (uintptr_t)extent1,`
			`(uintptr_t)extent2);`
			`}`

			`static inline void`
			`extent_unlock2(tsdn_t tsdn, extent_t extent1, extent_t *extent2) {`
			`assert(extent1 != NULL && extent2 != NULL);`
			`mutex_pool_unlock2(tsdn, &extent_mutex_pool, (uintptr_t)extent1,`
			`(uintptr_t)extent2);`
			`}`

Break up headers into constituent parts This is part of a broader change to make header files better represent the dependencies between one another (see https://github.com/jemalloc/jemalloc/issues/533). It breaks up component headers into smaller parts that can be made to have a simpler dependency graph. For the autogenerated headers (smoothstep.h and size_classes.h), no splitting was necessary, so I didn't add support to emit multiple headers. 2017-01-11 10:06:31 +08:00			`#endif /* JEMALLOC_INTERNAL_EXTENT_INLINES_H */`