# passed as-is to CFLAGS). Please check sources for their exact meaning or do
# not use them at all. Some even more obscure ones might also be available
# without appearing here. Currently defined DEBUG macros include DEBUG_FULL,
-# DEBUG_MEM_STATS, DEBUG_DONT_SHARE_POOLS, DEBUG_NO_LOCKLESS_POOLS, DEBUG_FD,
+# DEBUG_MEM_STATS, DEBUG_DONT_SHARE_POOLS, DEBUG_FD,
# DEBUG_NO_POOLS, DEBUG_FAIL_ALLOC, DEBUG_STRICT_NOCRASH, DEBUG_HPACK,
# DEBUG_AUTH, DEBUG_SPOE, DEBUG_UAF, DEBUG_THREAD, DEBUG_STRICT, DEBUG_DEV,
# DEBUG_TASK.
#define CONFIG_HAP_POOLS
#endif
-/* On architectures supporting threads and double-word CAS, we can implement
- * lock-less memory pools. This isn't supported for debugging modes however.
- */
-#if defined(USE_THREAD) && defined(HA_HAVE_CAS_DW) && defined(CONFIG_HAP_POOLS) && !defined(DEBUG_NO_LOCKLESS_POOLS)
-#define CONFIG_HAP_LOCKLESS_POOLS
-#endif
-
/* On modern architectures with many threads, a fast memory allocator, and
* local pools, the global pools with their single list can be way slower than
* the standard allocator which already has its own per-thread arenas. In this
struct pool_head {
void **free_list;
- __decl_thread(HA_SPINLOCK_T lock); /* the spin lock */
unsigned int used; /* how many chunks are currently in use */
unsigned int needed_avg;/* floating indicator between used and allocated */
unsigned int allocated; /* how many chunks have been allocated */
pool_free_nocache(pool, ptr);
}
-#elif defined(CONFIG_HAP_LOCKLESS_POOLS)
-
-/****************** Lockless pools implementation ******************/
+#else /* CONFIG_HAP_NO_GLOBAL_POOLS */
/*
* Returns a pointer to type <type> taken from the pool <pool_type> if
swrate_add(&pool->needed_avg, POOL_AVG_SAMPLES, pool->used);
}
-#else /* CONFIG_HAP_LOCKLESS_POOLS */
-
-/****************** Locked pools implementation ******************/
-
-/*
- * Returns a pointer to type <type> taken from the pool <pool_type> if
- * available, otherwise returns NULL. No malloc() is attempted, and poisonning
- * is never performed. The purpose is to get the fastest possible allocation.
- * This version takes the pool's lock in order to do this.
- */
-static inline void *pool_get_from_shared_cache(struct pool_head *pool)
-{
- void *p;
-
- HA_SPIN_LOCK(POOL_LOCK, &pool->lock);
- if ((p = pool->free_list) != NULL)
- pool->free_list = *POOL_LINK(pool, p);
- HA_SPIN_UNLOCK(POOL_LOCK, &pool->lock);
- if (p)
- _HA_ATOMIC_INC(&pool->used);
-
-#ifdef DEBUG_MEMORY_POOLS
- if (p) {
- /* keep track of where the element was allocated from */
- *POOL_LINK(pool, p) = (void *)pool;
- }
-#endif
- return p;
-}
-
-/* unconditionally stores the object as-is into the global pool. The object
- * must not be NULL. Use pool_free() instead.
- */
-static inline void pool_put_to_shared_cache(struct pool_head *pool, void *ptr)
-{
- _HA_ATOMIC_DEC(&pool->used);
-
- HA_SPIN_LOCK(POOL_LOCK, &pool->lock);
- if (!pool_is_crowded(pool)) {
- *POOL_LINK(pool, ptr) = (void *)pool->free_list;
- pool->free_list = (void *)ptr;
- ptr = NULL;
- }
- HA_SPIN_UNLOCK(POOL_LOCK, &pool->lock);
-
- if (ptr) {
- /* still not freed */
- pool_put_to_os(pool, ptr);
- }
- swrate_add(&pool->needed_avg, POOL_AVG_SAMPLES, pool->used);
-}
-
-#endif /* CONFIG_HAP_LOCKLESS_POOLS */
+#endif /* CONFIG_HAP_NO_GLOBAL_POOLS */
/* These are generic cache-aware wrappers that allocate/free from/to the local
* cache first, then from the second level if it exists.
enum lock_label {
TASK_RQ_LOCK,
TASK_WQ_LOCK,
- POOL_LOCK,
LISTENER_LOCK,
PROXY_LOCK,
SERVER_LOCK,
switch (label) {
case TASK_RQ_LOCK: return "TASK_RQ";
case TASK_WQ_LOCK: return "TASK_WQ";
- case POOL_LOCK: return "POOL";
case LISTENER_LOCK: return "LISTENER";
case PROXY_LOCK: return "PROXY";
case SERVER_LOCK: return "SERVER";
LIST_INIT(&pool->cache[thr].list);
}
#endif
- HA_SPIN_INIT(&pool->lock);
}
pool->users++;
return pool;
/* Tries to allocate an object for the pool <pool> using the system's allocator
* and directly returns it. The pool's allocated counter is checked and updated,
- * but no other checks are performed. The pool's lock is not used and is not a
- * problem either.
+ * but no other checks are performed.
*/
void *pool_get_from_os(struct pool_head *pool)
{
/* Tries to allocate an object for the pool <pool> using the system's allocator
* and directly returns it. The pool's counters are updated but the object is
* never cached, so this is usable with and without local or shared caches.
- * This may be called with or without the pool lock held, so it must not use
- * the pool's lock.
*/
void *pool_alloc_nocache(struct pool_head *pool)
{
#else /* CONFIG_HAP_NO_GLOBAL_POOLS */
-#if defined(CONFIG_HAP_LOCKLESS_POOLS)
-
/*
* This function frees whatever can be freed in pool <pool>.
*/
/* here, we should have pool->allocated == pool->used */
}
-#else /* CONFIG_HAP_LOCKLESS_POOLS */
-
-/*
- * This function frees whatever can be freed in pool <pool>.
- */
-void pool_flush(struct pool_head *pool)
-{
- void *temp, **next;
-
- if (!pool)
- return;
-
- HA_SPIN_LOCK(POOL_LOCK, &pool->lock);
- next = pool->free_list;
- pool->free_list = NULL;
- HA_SPIN_UNLOCK(POOL_LOCK, &pool->lock);
-
- while (next) {
- temp = next;
- next = *POOL_LINK(pool, temp);
- pool_put_to_os(pool, temp);
- }
- /* here, we should have pool->allocated == pool->used */
-}
-
-#endif /* CONFIG_HAP_LOCKLESS_POOLS */
-
/*
* This function frees whatever can be freed in all pools, but respecting
* the minimum thresholds imposed by owners. It makes sure to be alone to
pool->users--;
if (!pool->users) {
LIST_DELETE(&pool->list);
-#ifndef CONFIG_HAP_LOCKLESS_POOLS
- HA_SPIN_DESTROY(&pool->lock);
-#endif
/* note that if used == 0, the cache is empty */
free(pool);
}
allocated = used = nbpools = 0;
chunk_printf(&trash, "Dumping pools usage. Use SIGQUIT to flush them.\n");
list_for_each_entry(entry, &pools, list) {
-#ifndef CONFIG_HAP_LOCKLESS_POOLS
- HA_SPIN_LOCK(POOL_LOCK, &entry->lock);
-#endif
chunk_appendf(&trash, " - Pool %s (%u bytes) : %u allocated (%u bytes), %u used, needed_avg %u, %u failures, %u users, @%p%s\n",
entry->name, entry->size, entry->allocated,
entry->size * entry->allocated, entry->used,
allocated += entry->allocated * entry->size;
used += entry->used * entry->size;
nbpools++;
-#ifndef CONFIG_HAP_LOCKLESS_POOLS
- HA_SPIN_UNLOCK(POOL_LOCK, &entry->lock);
-#endif
}
chunk_appendf(&trash, "Total: %d pools, %lu bytes allocated, %lu used.\n",
nbpools, allocated, used);
projects / thirdparty / haproxy.git / commitdiff
