MEDIUM: pools: centralize cache eviction in a common function
We currently have two functions to evict cold objects from local caches:
pool_evict_from_local_cache() to evict from a single cache, and
pool_evict_from_local_caches() to evict oldest objects from all caches.
The new function pool_evict_last_items() focuses on scanning oldest
objects from a pool and releasing a predefined number of them, either
to the shared pool or to the system. For now they're evicted one at a
time, but the next step will consist in creating clusters.
diff --git a/src/pool.c b/src/pool.c
index 2257dc9..2a56cd4 100644
--- a/src/pool.c
+++ b/src/pool.c
@@ -301,44 +301,54 @@
#ifdef CONFIG_HAP_POOLS
-/* Evicts some of the oldest objects from one local cache, until its number of
- * objects is no more than 16+1/8 of the total number of locally cached objects
- * or the total size of the local cache is no more than 75% of its maximum (i.e.
- * we don't want a single cache to use all the cache for itself). For this, the
- * list is scanned in reverse.
+/* removes up to <count> items from the end of the local pool cache <ph> for
+ * pool <pool>. The shared pool is refilled with these objects in the limit
+ * of the number of acceptable objects, and the rest will be released to the
+ * OS. It is not a problem is <count> is larger than the number of objects in
+ * the local cache. The counters are automatically updated.
*/
-void pool_evict_from_local_cache(struct pool_head *pool)
+static void pool_evict_last_items(struct pool_head *pool, struct pool_cache_head *ph, uint count)
{
- struct pool_cache_head *ph = &pool->cache[tid];
- struct pool_item *pi, *to_free = NULL;
struct pool_cache_item *item;
+ struct pool_item *pi;
+ uint released = 0;
uint to_free_max;
to_free_max = pool_releasable(pool);
- while (ph->count >= 16 + pool_cache_count / 8 &&
- pool_cache_bytes > CONFIG_HAP_POOL_CACHE_SIZE * 3 / 4) {
+ while (released < count && !LIST_ISEMPTY(&ph->list)) {
item = LIST_PREV(&ph->list, typeof(item), by_pool);
- ph->count--;
- pool_cache_bytes -= pool->size;
- pool_cache_count--;
LIST_DELETE(&item->by_pool);
LIST_DELETE(&item->by_lru);
+ released++;
if (to_free_max) {
pi = (struct pool_item *)item;
- pi->next = to_free;
- to_free = pi;
+ pi->down = NULL;
+ pool_put_to_shared_cache(pool, pi, 1);
to_free_max--;
} else
pool_free_nocache(pool, item);
}
+ ph->count -= released;
+ pool_cache_count -= released;
+ pool_cache_bytes -= released * pool->size;
+}
+
- while (to_free) {
- pi = to_free;
- pi->down = NULL;
- to_free = pi->next;
- pool_put_to_shared_cache(pool, pi, 1);
+/* Evicts some of the oldest objects from one local cache, until its number of
+ * objects is no more than 16+1/8 of the total number of locally cached objects
+ * or the total size of the local cache is no more than 75% of its maximum (i.e.
+ * we don't want a single cache to use all the cache for itself). For this, the
+ * list is scanned in reverse.
+ */
+void pool_evict_from_local_cache(struct pool_head *pool)
+{
+ struct pool_cache_head *ph = &pool->cache[tid];
+
+ while (ph->count >= 16 + pool_cache_count / 8 &&
+ pool_cache_bytes > CONFIG_HAP_POOL_CACHE_SIZE * 3 / 4) {
+ pool_evict_last_items(pool, ph, 1);
}
}
@@ -358,19 +368,7 @@
*/
ph = LIST_NEXT(&item->by_pool, struct pool_cache_head *, list);
pool = container_of(ph - tid, struct pool_head, cache);
- LIST_DELETE(&item->by_pool);
- LIST_DELETE(&item->by_lru);
- ph->count--;
- pool_cache_count--;
- pool_cache_bytes -= pool->size;
- if (unlikely(pool_is_crowded(pool)))
- pool_free_nocache(pool, item);
- else {
- struct pool_item *pi = (struct pool_item *)item;
-
- pi->down = NULL;
- pool_put_to_shared_cache(pool, pi, 1);
- }
+ pool_evict_last_items(pool, ph, 1);
} while (pool_cache_bytes > CONFIG_HAP_POOL_CACHE_SIZE * 7 / 8);
}