Refactor ARC into LFU and integrate mpool

We have implemented an adaptive replacement cache to reduce memory usage.
However, the complexity of the replacement policy of ARC can lead to a
decrease in overall performance. As a result, we implemented the LFU cache,
which performed better, but we still retained the ARC for future use.
Additionally, we imported the memory pool we developed to limit the memory
usage of both caches.

The statistics below illustrate the performance of the LFU cache and ARC
while running the CoreMark benchmark, indicating that the LFU cache outperforms ARC.

| Test |  CoreMark(Iterations/Sec)  |
|------+----------------------------|
| ARC  |         1123.776           |
| LFU  |         1155.174           |

Author: qwe661234

.github/workflows/main.yml

@@ -18,6 +18,8 @@ jobs:
             make check
             make tests
             make misalign
+            make ENABLE_ARC=1 clean all
+            make ENABLE_ARC=1 tests
     - name: diverse configurations
       run: |
             make distclean ENABLE_EXT_C=0 check

Makefile

@@ -40,6 +40,10 @@ ifeq ($(call has, EXT_F), 1)
 LDFLAGS += -lm
 endif
 
+# Enable adaptive replacement cache policy, default is LRU 
+ENABLE_ARC ?= 0
+$(call set-feature, ARC)
+
 # Experimental SDL oriented system calls
 ENABLE_SDL ?= 1
 ifeq ($(call has, SDL), 1)

mk/tests.mk

@@ -9,15 +9,23 @@ CACHE_OBJS := $(addprefix $(CACHE_BUILD_DIR)/, $(CACHE_OBJS))
 OBJS += $(CACHE_OBJS)
 deps += $(CACHE_OBJS:%.o=%.o.d)
 
-
+# Check adaptive replacement cache policy is enabled or not, default is LRU 
+ifeq ($(ENABLE_ARC), 1)
+CACHE_CHECK_ELF_FILES := \
+	arc/cache-new \
+	arc/cache-put \
+	arc/cache-get \
+	arc/cache-lru-replace \
+	arc/cache-lfu-replace \
+	arc/cache-lru-ghost-replace \
+	arc/cache-lfu-ghost-replace 
+else
 CACHE_CHECK_ELF_FILES := \
-	cache-new \
-	cache-put \
-	cache-get \
-	cache-lru-replace \
-	cache-lfu-replace \
-	cache-lru-ghost-replace \
-	cache-lfu-ghost-replace 
+	lfu/cache-new \
+	lfu/cache-put \
+	lfu/cache-get \
+	lfu/cache-lfu-replace 
+endif
 
 CACHE_OUT = $(addprefix $(CACHE_BUILD_DIR)/, $(CACHE_CHECK_ELF_FILES:%=%.out))
 
@@ -39,9 +47,9 @@ $(CACHE_OUT): $(TARGET)
 
 $(TARGET): $(CACHE_OBJS)
 	$(VECHO) "  CC\t$@\n"
-	$(Q)$(CC) $^ build/cache.o -o $(CACHE_BUILD_DIR)/$(TARGET)
+	$(Q)$(CC) $^ build/cache.o build/mpool.o -o $(CACHE_BUILD_DIR)/$(TARGET)
 
 $(CACHE_BUILD_DIR)/%.o: $(CACHE_TEST_DIR)/%.c 
 	$(VECHO) "  CC\t$@\n"
-	$(Q)mkdir -p $(dir $@)
+	$(Q)mkdir -p $(dir $@)/arc $(dir $@)/lfu
 	$(Q)$(CC) -o $@ $(CFLAGS) -I./src -c -MMD -MF $@.d $<

src/cache.c

@@ -10,14 +10,20 @@
 #include <string.h>
 
 #include "cache.h"
+#include "mpool.h"
 
 #define MIN(a, b) ((a < b) ? a : b)
 #define GOLDEN_RATIO_32 0x61C88647
 #define HASH(val) \
     (((val) * (GOLDEN_RATIO_32)) >> (32 - (cache_size_bits))) & (cache_size - 1)
+/* THRESHOLD is set to identify hot spots. Once the frequency of use for a block
+ * exceeds the THRESHOLD, it will be translated into machine code.*/
+#define THRESHOLD 1000
 
 static uint32_t cache_size, cache_size_bits;
+static struct mpool *cache_mp;
 
+#if RV32_HAS(ARC)
 /*
  * Adaptive Replacement Cache (ARC) improves the fundamental LRU strategy
  * by dividing the cache into two lists, T1 and T2. list T1 is for LRU
@@ -37,7 +43,7 @@ typedef enum {
     LFU_ghost_list,
     N_CACHE_LIST_TYPES
 } cache_list_t;
-
+#endif
 struct list_head {
     struct list_head *prev, *next;
 };
@@ -50,6 +56,7 @@ struct hlist_node {
     struct hlist_node *next, **pprev;
 };
 
+#if RV32_HAS(ARC)
 /*
  * list maintains four cache lists T1, T2, B1, and B2.
  * ht_list maintains hashtable and improves the performance of cache searching.
@@ -61,17 +68,31 @@ typedef struct {
     struct list_head list;
     struct hlist_node ht_list;
 } arc_entry_t;
+#else
+typedef struct {
+    void *value;
+    uint32_t key;
+    uint32_t frequency;
+    struct list_head list;
+    struct hlist_node ht_list;
+} lfu_entry_t;
+#endif
 
 typedef struct {
     struct hlist_head *ht_list_head;
 } hashtable_t;
 
 typedef struct cache {
+#if RV32_HAS(ARC)
     struct list_head *lists[N_CACHE_LIST_TYPES];
     uint32_t list_size[N_CACHE_LIST_TYPES];
+    uint32_t lru_capacity;
+#else
+    struct list_head *lists[THRESHOLD];
+    uint32_t list_size;
+#endif
     hashtable_t *map;
     uint32_t capacity;
-    uint32_t lru_capacity;
 } cache_t;
 
 static inline void INIT_LIST_HEAD(struct list_head *head)
@@ -80,6 +101,13 @@ static inline void INIT_LIST_HEAD(struct list_head *head)
     head->prev = head;
 }
 
+#if !RV32_HAS(ARC)
+static inline int list_empty(const struct list_head *head)
+{
+    return (head->next == head);
+}
+#endif
+
 static inline void list_add(struct list_head *node, struct list_head *head)
 {
     struct list_head *next = head->next;
@@ -107,6 +135,9 @@ static inline void list_del_init(struct list_head *node)
 
 #define list_entry(node, type, member) container_of(node, type, member)
 
+#define list_first_entry(head, type, member) \
+    list_entry((head)->next, type, member)
+
 #define list_last_entry(head, type, member) \
     list_entry((head)->prev, type, member)
 
@@ -194,14 +225,15 @@ static inline void hlist_del_init(struct hlist_node *n)
          pos = hlist_entry_safe((pos)->member.next, type, member))
 #endif
 
+
 cache_t *cache_create(int size_bits)
 {
     cache_t *cache = malloc(sizeof(cache_t));
     if (!cache)
         return NULL;
     cache_size_bits = size_bits;
     cache_size = 1 << size_bits;
-
+#if RV32_HAS(ARC)
     for (int i = 0; i < N_CACHE_LIST_TYPES; i++) {
         cache->lists[i] = malloc(sizeof(struct list_head));
         INIT_LIST_HEAD(cache->lists[i]);
@@ -224,12 +256,41 @@ cache_t *cache_create(int size_bits)
     for (uint32_t i = 0; i < cache_size; i++) {
         INIT_HLIST_HEAD(&cache->map->ht_list_head[i]);
     }
+    cache->lru_capacity = cache_size / 2;
+    cache_mp =
+        mpool_create(cache_size * 2 * sizeof(arc_entry_t), sizeof(arc_entry_t));
+#else
+    for (int i = 0; i < THRESHOLD; i++) {
+        cache->lists[i] = malloc(sizeof(struct list_head));
+        INIT_LIST_HEAD(cache->lists[i]);
+    }
 
+    cache->map = malloc(sizeof(hashtable_t));
+    if (!cache->map) {
+        free(cache->lists);
+        free(cache);
+        return NULL;
+    }
+    cache->map->ht_list_head = malloc(cache_size * sizeof(struct hlist_head));
+    if (!cache->map->ht_list_head) {
+        free(cache->map);
+        free(cache->lists);
+        free(cache);
+        return NULL;
+    }
+    for (uint32_t i = 0; i < cache_size; i++) {
+        INIT_HLIST_HEAD(&cache->map->ht_list_head[i]);
+    }
+    cache->list_size = 0;
+    cache_mp =
+        mpool_create(cache_size * sizeof(lfu_entry_t), sizeof(lfu_entry_t));
+#endif
     cache->capacity = cache_size;
-    cache->lru_capacity = cache_size / 2;
     return cache;
 }
 
+
+#if RV32_HAS(ARC)
 /* Rules of ARC
  * 1. size of LRU_list + size of LFU_list <= c
  * 2. size of LRU_list + size of LRU_ghost_list <= c
@@ -273,12 +334,14 @@ static inline void move_to_mru(cache_t *cache,
     list_del_init(&entry->list);
     list_add(&entry->list, cache->lists[type]);
 }
+#endif
 
 void *cache_get(cache_t *cache, uint32_t key)
 {
     if (!cache->capacity || hlist_empty(&cache->map->ht_list_head[HASH(key)]))
         return NULL;
 
+#if RV32_HAS(ARC)
     arc_entry_t *entry = NULL;
 #ifdef __HAVE_TYPEOF
     hlist_for_each_entry (entry, &cache->map->ht_list_head[HASH(key)], ht_list)
@@ -323,13 +386,35 @@ void *cache_get(cache_t *cache, uint32_t key)
     }
 
     CACHE_ASSERT(cache);
+#else
+    lfu_entry_t *entry = NULL;
+#ifdef __HAVE_TYPEOF
+    hlist_for_each_entry (entry, &cache->map->ht_list_head[HASH(key)], ht_list)
+#else
+    hlist_for_each_entry (entry, &cache->map->ht_list_head[HASH(key)], ht_list,
+                          lfu_entry_t)
+#endif
+    {
+        if (entry->key == key)
+            break;
+    }
+    if (!entry || entry->key != key)
+        return NULL;
+
+    /* We would translate the block with a frequency of more thanTHRESHOLD */
+    if (entry->frequency < THRESHOLD) {
+        list_del_init(&entry->list);
+        list_add(&entry->list, cache->lists[entry->frequency++]);
+    }
+#endif
     /* return NULL if cache miss */
     return entry->value;
 }
 
 void *cache_put(cache_t *cache, uint32_t key, void *value)
 {
     void *delete_value = NULL;
+#if RV32_HAS(ARC)
     assert(cache->list_size[LRU_list] + cache->list_size[LRU_ghost_list] <=
            cache->capacity);
     /* Before adding new element to cach, we should check the status
@@ -343,7 +428,7 @@ void *cache_put(cache_t *cache, uint32_t key, void *value)
             list_del_init(&delete_target->list);
             hlist_del_init(&delete_target->ht_list);
             delete_value = delete_target->value;
-            free(delete_target);
+            mpool_free(cache_mp, delete_target);
             cache->list_size[LRU_ghost_list]--;
             if (cache->list_size[LRU_list] &&
                 cache->list_size[LRU_list] >= cache->lru_capacity)
@@ -357,7 +442,7 @@ void *cache_put(cache_t *cache, uint32_t key, void *value)
             list_del_init(&delete_target->list);
             hlist_del_init(&delete_target->ht_list);
             delete_value = delete_target->value;
-            free(delete_target);
+            mpool_free(cache_mp, delete_target);
             cache->list_size[LRU_list]--;
         }
     } else {
@@ -372,12 +457,12 @@ void *cache_put(cache_t *cache, uint32_t key, void *value)
             list_del_init(&delete_target->list);
             hlist_del_init(&delete_target->ht_list);
             delete_value = delete_target->value;
-            free(delete_target);
+            mpool_free(cache_mp, delete_target);
             cache->list_size[LFU_ghost_list]--;
         }
         REPLACE_LIST(>, >=)
     }
-    arc_entry_t *new_entry = malloc(sizeof(arc_entry_t));
+    arc_entry_t *new_entry = mpool_alloc(cache_mp);
     new_entry->key = key;
     new_entry->value = value;
     /* check if all cache become LFU */
@@ -393,21 +478,63 @@ void *cache_put(cache_t *cache, uint32_t key, void *value)
     hlist_add_head(&new_entry->ht_list, &cache->map->ht_list_head[HASH(key)]);
 
     CACHE_ASSERT(cache);
+#else
+    assert(cache->list_size <= cache->capacity);
+    /* Before adding new element to cach, we should check the status
+     * of cache.
+     */
+    if (cache->list_size == cache->capacity) {
+        for (int i = 0; i < THRESHOLD; i++) {
+            if (!list_empty(cache->lists[i])) {
+                lfu_entry_t *delete_target =
+                    list_last_entry(cache->lists[i], lfu_entry_t, list);
+                list_del_init(&delete_target->list);
+                hlist_del_init(&delete_target->ht_list);
+                delete_value = delete_target->value;
+                cache->list_size--;
+                mpool_free(cache_mp, delete_target);
+                break;
+            }
+        }
+    }
+    lfu_entry_t *new_entry = mpool_alloc(cache_mp);
+    new_entry->key = key;
+    new_entry->value = value;
+    new_entry->frequency = 0;
+    list_add(&new_entry->list, cache->lists[new_entry->frequency++]);
+    cache->list_size++;
+    hlist_add_head(&new_entry->ht_list, &cache->map->ht_list_head[HASH(key)]);
+    assert(cache->list_size <= cache->capacity);
+#endif
     return delete_value;
 }
 
 void cache_free(cache_t *cache, void (*callback)(void *))
 {
+#if RV32_HAS(ARC)
     for (int i = 0; i < N_CACHE_LIST_TYPES; i++) {
         arc_entry_t *entry, *safe;
 #ifdef __HAVE_TYPEOF
         list_for_each_entry_safe (entry, safe, cache->lists[i], list)
 #else
         list_for_each_entry_safe (entry, safe, cache->lists[i], list,
                                   arc_entry_t)
+#endif
+#else
+    for (int i = 0; i < THRESHOLD; i++) {
+        if (list_empty(cache->lists[i]))
+            continue;
+        lfu_entry_t *entry, *safe;
+#ifdef __HAVE_TYPEOF
+        list_for_each_entry_safe (entry, safe, cache->lists[i], list)
+#else
+        list_for_each_entry_safe (entry, safe, cache->lists[i], list,
+                                  lfu_entry_t)
+#endif
 #endif
             callback(entry->value);
     }
+    mpool_destory(cache_mp);
     free(cache->map->ht_list_head);
     free(cache->map);
     free(cache);

src/feature.h

@@ -48,6 +48,11 @@
 #define RV32_FEATURE_GDBSTUB 1
 #endif
 
+/* Import adaptive replacement cache to manage block */
+#ifndef RV32_FEATURE_ARC
+#define RV32_FEATURE_ARC 0
+#endif
+
 /* Feature test macro */
 #define RV32_HAS(x) RV32_FEATURE_##x
 

tests/cache/arc/cache-get.expect

@@ -0,0 +1,5 @@
+NEW CACHE
+NULL
+NULL
+3
+FREE CACHE