MINOR: pools: create unified pool_{get_from,put_to}_cache()
These two functions are now responsible for allocating directly from
the cache and releasing to the cache.
Now the pool_alloc() function simply does this:
if cache enabled
return pool_alloc_from_cache() if no NULL
return pool_alloc_nocache() otherwise
and the pool_free() function does this:
if cache enabled
pool_put_to_cache()
else
pool_free_nocache()
For now this only introduces these two functions without changing anything
else, but the goal is to soon allow to make them implementation-specific.
diff --git a/include/haproxy/pool.h b/include/haproxy/pool.h
index df01991..dc01e1a 100644
--- a/include/haproxy/pool.h
+++ b/include/haproxy/pool.h
@@ -260,6 +260,45 @@
#endif /* CONFIG_HAP_LOCKLESS_POOLS */
+/* These are generic cache-aware wrappers that allocate/free from/to the local
+ * cache first, then from the second level if it exists.
+ */
+
+
+/* Tries to allocate from the local cache first, then from the shared cache if
+ * it exists. Returns the item found or NULL if none was found.
+ */
+static inline void *pool_get_from_cache(struct pool_head *pool)
+{
+ void *ptr;
+
+ ptr = pool_get_from_local_cache(pool);
+ if (!ptr)
+ ptr = pool_get_from_shared_cache(pool);
+ return ptr;
+}
+
+/* Releases the object to the cache. Usually the local cache will be used,
+ * unless it is too crowded in which case the cache may decide to move objects
+ * to the shared cache, which itself may decide to release some of them to the
+ * OS. While it is unspecified what the object becomes past this point, it is
+ * guaranteed to be released from the users' perpective.
+ */
+static inline void pool_put_to_cache(struct pool_head *pool, void *ptr)
+{
+ /* put the object back into the cache only if there are not too
+ * many objects yet in this pool (no more than half of the cached
+ * is used or this pool uses no more than 1/8 of the cache size).
+ */
+ if ((pool_cache_bytes <= CONFIG_HAP_POOL_CACHE_SIZE * 3 / 4 ||
+ pool->cache[tid].count < 16 + pool_cache_count / 8)) {
+ pool_put_to_local_cache(pool, ptr);
+ return;
+ }
+ pool_put_to_shared_cache(pool, ptr);
+}
+
+
#endif /* CONFIG_HAP_POOLS */
@@ -282,10 +321,7 @@
#ifdef CONFIG_HAP_POOLS
if (!p)
- p = pool_get_from_local_cache(pool);
-
- if (!p)
- p = pool_get_from_shared_cache(pool);
+ p = pool_get_from_cache(pool);
#endif
if (!p)
p = pool_alloc_nocache(pool);
@@ -338,16 +374,7 @@
memset(ptr, mem_poison_byte, pool->size);
#ifdef CONFIG_HAP_POOLS
- /* put the object back into the cache only if there are not too
- * many objects yet in this pool (no more than half of the cached
- * is used or this pool uses no more than 1/8 of the cache size).
- */
- if ((pool_cache_bytes <= CONFIG_HAP_POOL_CACHE_SIZE * 3 / 4 ||
- pool->cache[tid].count < 16 + pool_cache_count / 8)) {
- pool_put_to_local_cache(pool, ptr);
- return;
- }
- pool_put_to_shared_cache(pool, ptr);
+ pool_put_to_cache(pool, ptr);
#else
pool_free_nocache(pool, ptr);
#endif