Reduce interpreter and JIT overhead

This introduces three optimizations:
1. Block-level cycle counting
   - Remove per-instruction cycle++ from RVOP macro
   - Pre-compute block->cycle_cost at translation time
   - Add cycle cost at block entry (interpreter) or exit (JIT)
2. Timer derivation from cycle counter (SYSTEM mode)
   - Remove per-instruction rv->timer++
   - Derive timer on-demand: timer = csr_cycle + timer_offset
   - Extend CSR sync to TIME/TIMEH registers
3. Page-boundary block termination with fallthrough chaining
   - Terminate blocks at 4KB page boundaries
   - Implement fallthrough chaining via branch_taken pointer
   - Add page_index_insert() for O(1) cache invalidation

Author: jserv

mk/common.mk

@@ -35,8 +35,9 @@ endef
 
 # Get specified feature (supports both ENABLE_* and CONFIG_*)
 POSITIVE_WORDS = 1 true yes y
+NEGATIVE_WORDS = 0 false no n
 define has
-$(if $(filter $(firstword $(ENABLE_$(strip $1))), $(POSITIVE_WORDS)),1,$(call config-to-feature,$1))
+$(if $(filter $(firstword $(ENABLE_$(strip $1))),$(NEGATIVE_WORDS)),0,$(if $(filter $(firstword $(ENABLE_$(strip $1))),$(POSITIVE_WORDS)),1,$(call config-to-feature,$1)))
 endef
 
 # Set compiler feature flag from config

src/cache.c

@@ -54,15 +54,36 @@ typedef struct {
  * detached and freed, and the stored information will be inherited by the new
  * entry.
  */
+
+#if RV32_HAS(JIT) && RV32_HAS(SYSTEM)
+/* Page index entry: links blocks in the same page bucket */
+typedef struct page_block_entry {
+    void *block;                   /* pointer to block_t */
+    struct page_block_entry *next; /* next entry in bucket chain */
+} page_block_entry_t;
+#endif
+
 typedef struct cache {
     struct list_head list;       /* list of live cache */
     struct list_head ghost_list; /* list of evicted cache */
     hashtable_t map; /* hash map which contains both live and evicted cache */
     uint32_t size;
     uint32_t ghost_list_size;
     uint32_t capacity;
+#if RV32_HAS(JIT) && RV32_HAS(SYSTEM)
+    /* Page index for O(1) invalidation by virtual address.
+     * Each bucket contains a linked list of blocks starting in that page.
+     */
+    page_block_entry_t *page_index[PAGE_INDEX_SIZE];
+#endif
 } cache_t;
 
+#if RV32_HAS(JIT) && RV32_HAS(SYSTEM)
+/* Forward declarations for page index functions */
+static void page_index_insert(cache_t *cache, block_t *block);
+static void page_index_remove(cache_t *cache, block_t *block);
+#endif
+
 #define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
 
 static inline void INIT_HLIST_NODE(struct hlist_node *h)
@@ -178,6 +199,11 @@ cache_t *cache_create(uint32_t size_bits)
     for (uint32_t i = 0; i < cache_size; i++)
         INIT_HLIST_HEAD(&cache->map.ht_list_head[i]);
 
+#if RV32_HAS(JIT) && RV32_HAS(SYSTEM)
+    /* Initialize page index for O(1) invalidation lookup */
+    memset(cache->page_index, 0, sizeof(cache->page_index));
+#endif
+
     return cache;
 
 fail_cache:
@@ -290,6 +316,11 @@ void *cache_put(cache_t *cache, uint32_t key, void *value)
         assert(replaced->alive);
 
         replaced_value = replaced->value;
+#if RV32_HAS(JIT) && RV32_HAS(SYSTEM)
+        /* Remove replaced block from page index before eviction */
+        if (replaced_value)
+            page_index_remove(cache, (block_t *) replaced_value);
+#endif
         replaced->alive = false;
         list_del_init(&replaced->list);
         cache->size--;
@@ -333,6 +364,13 @@ void *cache_put(cache_t *cache, uint32_t key, void *value)
 
     cache->size++;
 
+#if RV32_HAS(JIT) && RV32_HAS(SYSTEM)
+    /* Page index for O(1) invalidation - blocks are page-terminated
+     * and use fallthrough chaining for non-branch block boundaries.
+     */
+    page_index_insert(cache, (block_t *) value);
+#endif
+
     cache_ghost_list_update(cache);
 
     assert(cache->size <= cache->capacity);
@@ -342,6 +380,17 @@ void *cache_put(cache_t *cache, uint32_t key, void *value)
 
 void cache_free(cache_t *cache)
 {
+#if RV32_HAS(JIT) && RV32_HAS(SYSTEM)
+    /* Free all page index entries */
+    for (uint32_t i = 0; i < PAGE_INDEX_SIZE; i++) {
+        page_block_entry_t *entry = cache->page_index[i];
+        while (entry) {
+            page_block_entry_t *next = entry->next;
+            free(entry);
+            entry = next;
+        }
+    }
+#endif
     free(cache->map.ht_list_head);
     free(cache);
 }
@@ -436,6 +485,43 @@ void clear_cache_hot(const struct cache *cache, clear_func_t func)
  * changes, appropriate locking must be added around cache->list traversal.
  */
 
+/* Hash function for page index using golden ratio multiplicative hash */
+HASH_FUNC_IMPL(page_index_hash, PAGE_INDEX_BITS, PAGE_INDEX_SIZE)
+
+/* Insert a block into the page index */
+static void page_index_insert(cache_t *cache, block_t *block)
+{
+    uint32_t page = block->pc_start & ~(RV_PG_SIZE - 1);
+    uint32_t bucket = page_index_hash(page >> RV_PG_SHIFT);
+
+    page_block_entry_t *entry = malloc(sizeof(page_block_entry_t));
+    if (!entry)
+        return; /* Graceful degradation: O(1) lookup unavailable for this block
+                 */
+
+    entry->block = block;
+    entry->next = cache->page_index[bucket];
+    cache->page_index[bucket] = entry;
+}
+
+/* Remove a block from the page index */
+static void page_index_remove(cache_t *cache, block_t *block)
+{
+    uint32_t page = block->pc_start & ~(RV_PG_SIZE - 1);
+    uint32_t bucket = page_index_hash(page >> RV_PG_SHIFT);
+
+    page_block_entry_t **pp = &cache->page_index[bucket];
+    while (*pp) {
+        if ((*pp)->block == block) {
+            page_block_entry_t *tmp = *pp;
+            *pp = (*pp)->next;
+            free(tmp);
+            return;
+        }
+        pp = &(*pp)->next;
+    }
+}
+
 uint32_t cache_invalidate_satp(cache_t *cache, uint32_t satp)
 {
     if (unlikely(!cache->capacity))
@@ -465,36 +551,25 @@ uint32_t cache_invalidate_va(cache_t *cache, uint32_t va, uint32_t satp)
 
     /* Extract page-aligned VA for the target address */
     uint32_t va_page = va & ~(RV_PG_SIZE - 1);
+    uint32_t bucket = page_index_hash(va_page >> RV_PG_SHIFT);
     uint32_t count = 0;
 
-    cache_entry_t *entry = NULL;
-#ifdef __HAVE_TYPEOF
-    list_for_each_entry (entry, &cache->list, list)
-#else
-    list_for_each_entry (entry, &cache->list, list, cache_entry_t)
-#endif
-    {
-        block_t *block = (block_t *) entry->value;
-        if (!block || block->satp != satp || block->invalidated)
-            continue;
-
-        /* Check if target VA page overlaps with block's address range.
-         * A block may span multiple pages, so we check if va_page falls
-         * within [block_start_page, block_end_page].
-         *
-         * Note: pc_end is exclusive (address after last instruction), so we
-         * use (pc_end - 1) to get the page containing the last byte. This
-         * avoids false invalidation when pc_end falls exactly on a page
-         * boundary.
-         */
-        uint32_t block_start_page = block->pc_start & ~(RV_PG_SIZE - 1);
-        uint32_t last_byte = block->pc_end > block->pc_start ? block->pc_end - 1
-                                                             : block->pc_start;
-        uint32_t block_end_page = last_byte & ~(RV_PG_SIZE - 1);
-        if (va_page >= block_start_page && va_page <= block_end_page) {
-            block->invalidated = true;
-            count++;
+    /* O(1) lookup via page index.
+     * With page-bounded blocks, each block fits entirely within one 4KB page.
+     * We only need to check the bucket for this specific page.
+     */
+    page_block_entry_t *entry = cache->page_index[bucket];
+    while (entry) {
+        block_t *block = (block_t *) entry->block;
+        if (block && block->satp == satp && !block->invalidated) {
+            /* Verify block belongs to this page (hash collision check) */
+            uint32_t block_page = block->pc_start & ~(RV_PG_SIZE - 1);
+            if (block_page == va_page) {
+                block->invalidated = true;
+                count++;
+            }
         }
+        entry = entry->next;
     }
     return count;
 }

src/cache.h

@@ -68,6 +68,14 @@ void clear_cache_hot(const struct cache *cache, clear_func_t func);
 uint32_t cache_freq(const struct cache *cache, uint32_t key);
 
 #if RV32_HAS(JIT) && RV32_HAS(SYSTEM)
+
+/* Page index for O(1) cache invalidation by virtual address.
+ * With page-bounded blocks, each block fits entirely within one 4KB page,
+ * allowing direct lookup by page address instead of O(n) scan.
+ */
+#define PAGE_INDEX_BITS 10
+#define PAGE_INDEX_SIZE (1 << PAGE_INDEX_BITS)
+
 /**
  * cache_invalidate_satp - invalidate all blocks matching the given SATP
  * @cache: a pointer to target cache
@@ -88,6 +96,7 @@ uint32_t cache_invalidate_satp(struct cache *cache, uint32_t satp);
  *
  * This is used by SFENCE.VMA with rs1!=0 (address-specific flush) to
  * invalidate JIT-compiled blocks in a specific virtual page.
+ * Uses O(1) page-indexed lookup instead of O(n) scan.
  */
 uint32_t cache_invalidate_va(struct cache *cache, uint32_t va, uint32_t satp);
 #endif