Add simple LRU MMU cache

Simple MMU translation lookup cache using a ringbuffer.

Author: onnokort

mmu_cache.h

@@ -0,0 +1,65 @@
+#pragma once
+#include <string.h>
+/* This currently implements a simple, fixed-size LRU cache for MMU
+   entries. Assumes that address 0 is never cached and it is used to
+   flag empty entries. If a returned translation is zero, the calling
+   logic has to assume that this means 'no entry available'. */
+
+#define MMU_CACHE_ENTRIES 3
+#define MMU_CACHE_IDX_TYPE int
+#define MMU_CACHE_COUNTERS 0
+
+struct _mmu_cache_ctx {
+    MMU_CACHE_IDX_TYPE write_idx;
+    uint32_t from[MMU_CACHE_ENTRIES];
+    uint32_t to[MMU_CACHE_ENTRIES];
+#if MMU_CACHE_COUNTERS
+    uint64_t hits, misses;
+#endif
+};
+
+static inline void mmu_cache_reset_ctx(struct _mmu_cache_ctx* cc) {
+    if (MMU_CACHE_ENTRIES) {
+	cc->write_idx=0;
+	for (size_t i=0; i != MMU_CACHE_ENTRIES; i++) {
+	    cc->from[i]=cc->to[i]=0;
+	}
+    }
+}
+
+static inline uint32_t mmu_cache_lookup(struct _mmu_cache_ctx* cc,
+				 uint32_t high_part) {
+    if (!MMU_CACHE_ENTRIES) {
+#if MMU_CACHE_COUNTERS
+    cc->misses++;
+#endif
+	return 0;
+    }
+    MMU_CACHE_IDX_TYPE i = cc->write_idx;
+    do {
+	if (cc->from[i] == high_part) {
+#if MMU_CACHE_COUNTERS
+	    cc->hits++;
+#endif
+	    return cc->to[i];
+	}
+	i--;
+	if (i<0) i = MMU_CACHE_ENTRIES-1;
+    } while(i != cc->write_idx);
+#if MMU_CACHE_COUNTERS
+    cc->misses++;
+#endif
+    return 0; // no entry available
+}
+
+static inline void mmu_cache_insert(struct _mmu_cache_ctx* cc,
+				    uint32_t ifrom,
+				    uint32_t ito) {
+    if (!MMU_CACHE_ENTRIES) return;
+    MMU_CACHE_IDX_TYPE idx = cc->write_idx+1;
+    if (idx == MMU_CACHE_ENTRIES)
+	idx = 0;
+    cc->write_idx = idx;
+    cc->from[idx]=ifrom;
+    cc->to[idx]=ito;
+}

riscv.c

@@ -167,11 +167,19 @@ static inline uint32_t read_rs2(const vm_t *vm, uint32_t insn)
 
 /* virtual addressing */
 
+static void mmu_invalidate_caches(vm_t *vm) {
+    mmu_cache_reset_ctx(&vm->mmu_cache_fetch_ctx);
+    mmu_cache_reset_ctx(&vm->mmu_cache_load_ctx);
+    mmu_cache_reset_ctx(&vm->mmu_cache_store_ctx);
+}
+
+
 /* Pre-verify the root page table to minimize page table access during
  * translation time.
  */
 static void mmu_set(vm_t *vm, uint32_t satp)
 {
+    mmu_invalidate_caches(vm);
     if (satp >> 31) {
         uint32_t *page_table = vm->mem_page_table(vm, satp & MASK(22));
         if (!page_table)
@@ -228,16 +236,25 @@ static bool mmu_lookup(const vm_t *vm,
     return true;
 }
 
-static void mmu_translate(vm_t *vm,
-                          uint32_t *addr,
-                          const uint32_t access_bits,
-                          const uint32_t set_bits,
-                          const bool skip_privilege_test,
-                          const uint8_t fault,
-                          const uint8_t pfault)
+static inline void mmu_translate(vm_t *vm,
+                                 struct _mmu_cache_ctx *cctx,
+                                 uint32_t *addr,
+                                 const uint32_t access_bits,
+                                 const uint32_t set_bits,
+                                 const bool skip_privilege_test,
+                                 const uint8_t fault,
+                                 const uint8_t pfault)
 {
+    const uint32_t high_part = *addr & ~MASK(RV_PAGE_SHIFT);
+    uint32_t caddr=mmu_cache_lookup(cctx, high_part);
+
     /* NOTE: save virtual address, for physical accesses, to set exception. */
     vm->exc_val = *addr;
+
+    if (caddr) {
+        *addr= caddr | (*addr & MASK(RV_PAGE_SHIFT));
+        return;
+    }
     if (!vm->page_table)
         return;
 
@@ -265,16 +282,18 @@ static void mmu_translate(vm_t *vm,
         *pte_ref = new_pte;
 
     *addr = ((*addr) & MASK(RV_PAGE_SHIFT)) | (ppn << RV_PAGE_SHIFT);
+    mmu_cache_insert(cctx, high_part, ppn << RV_PAGE_SHIFT);
 }
 
 static void mmu_fence(vm_t *vm UNUSED, uint32_t insn UNUSED)
 {
-    /* no-op for now */
+    mmu_invalidate_caches(vm);
 }
 
 static void mmu_fetch(vm_t *vm, uint32_t addr, uint32_t *value)
 {
-    mmu_translate(vm, &addr, (1 << 3), (1 << 6), false, RV_EXC_FETCH_FAULT,
+    mmu_translate(vm, &vm->mmu_cache_fetch_ctx,
+                  &addr, (1 << 3), (1 << 6), false, RV_EXC_FETCH_FAULT,
                   RV_EXC_FETCH_PFAULT);
     if (vm->error)
         return;
@@ -287,7 +306,8 @@ static void mmu_load(vm_t *vm,
                      uint32_t *value,
                      bool reserved)
 {
-    mmu_translate(vm, &addr, (1 << 1) | (vm->sstatus_mxr ? (1 << 3) : 0),
+    mmu_translate(vm, &vm->mmu_cache_load_ctx,
+                  &addr, (1 << 1) | (vm->sstatus_mxr ? (1 << 3) : 0),
                   (1 << 6), vm->sstatus_sum && vm->s_mode, RV_EXC_LOAD_FAULT,
                   RV_EXC_LOAD_PFAULT);
     if (vm->error)
@@ -306,7 +326,8 @@ static bool mmu_store(vm_t *vm,
                       uint32_t value,
                       bool cond)
 {
-    mmu_translate(vm, &addr, (1 << 2), (1 << 6) | (1 << 7),
+    mmu_translate(vm, &vm->mmu_cache_store_ctx,
+                  &addr, (1 << 2), (1 << 6) | (1 << 7),
                   vm->sstatus_sum && vm->s_mode, RV_EXC_STORE_FAULT,
                   RV_EXC_STORE_PFAULT);
     if (vm->error)
@@ -336,6 +357,8 @@ void vm_set_exception(vm_t *vm, uint32_t cause, uint32_t val)
 
 void vm_trap(vm_t *vm)
 {
+    mmu_invalidate_caches(vm);
+
     /* Fill exception fields */
     vm->scause = vm->exc_cause;
     vm->stval = vm->exc_val;
@@ -357,6 +380,8 @@ void vm_trap(vm_t *vm)
 
 static void op_sret(vm_t *vm)
 {
+    mmu_invalidate_caches(vm);
+
     /* Restore from stack */
     vm->pc = vm->sepc;
     vm->s_mode = vm->sstatus_spp;

riscv.h

@@ -2,6 +2,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "mmu_cache.h"
 
 /* ERR_EXCEPTION indicates that the instruction has raised one of the
  * exceptions defined in the specification. If this flag is set, the
@@ -96,6 +97,8 @@ struct __vm_internal {
     uint32_t satp; /**< MMU */
     uint32_t *page_table;
 
+    struct _mmu_cache_ctx mmu_cache_fetch_ctx, mmu_cache_load_ctx, mmu_cache_store_ctx;
+
     void *priv; /**< environment supplied */
 
     /* Memory access sets the vm->error to indicate failure. On successful