Merge pull request #333 from qwe661234/add_profiler

Add profiler

Author: jserv

README.md

@@ -255,6 +255,23 @@ _Example Instructions Histogram_
 _Example Registers Histogram_
 ![Registers Hisrogram Example](docs/histogram-reg.png)
 
+## RISC-V Basic Block Usage Statistics
+
+To install [lolviz](https://github.com/parrt/lolviz)
+```shell
+$ pip install lolviz
+```
+For macOS users, installing might be required:
+```shell
+$ brew install graphviz
+```
+First, user need to crate the directory `prof` and build profiling data through executing `rv32emu`
+
+```shell
+$ ./build/rv32emu -p ./build/[test_program].elf
+$ ./tools/rv_profiler [--start-address|--stop-address|--graph-ir] [test_program]
+```
+
 ## Contributing
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines.

src/cache.c

@@ -6,21 +6,14 @@
 #include <assert.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "cache.h"
 #include "mpool.h"
 #include "utils.h"
 
-/* Currently, THRESHOLD is set to identify hot spots. Once the using frequency
- * for a block exceeds the THRESHOLD, the tier-1 JIT compiler process is
- * triggered.
- * FIXME: Implement effective  profiler to detect hot spots, instead of simply
- * relying on THRESHOLD.
- */
-#define THRESHOLD 4096
-
 static uint32_t cache_size, cache_size_bits;
 static struct mpool *cache_mp;
 
@@ -166,7 +159,7 @@ cache_t *cache_create(int size_bits)
     return NULL;
 }
 
-void *cache_get(const cache_t *cache, uint32_t key)
+void *cache_get(const cache_t *cache, uint32_t key, bool update)
 {
     if (!cache->capacity ||
         hlist_empty(&cache->map->ht_list_head[cache_hash(key)]))
@@ -192,7 +185,7 @@ void *cache_get(const cache_t *cache, uint32_t key)
      * code. The generated C code is then compiled into machine code by the
      * target compiler.
      */
-    if (entry->frequency < THRESHOLD) {
+    if (update && entry->frequency < THRESHOLD) {
         list_del_init(&entry->list);
         list_add(&entry->list, cache->lists[entry->frequency++]);
     }
@@ -242,7 +235,7 @@ void cache_free(cache_t *cache)
     free(cache);
 }
 
-uint32_t cache_freq(struct cache *cache, uint32_t key)
+uint32_t cache_freq(const struct cache *cache, uint32_t key)
 {
     if (!cache->capacity ||
         hlist_empty(&cache->map->ht_list_head[cache_hash(key)]))
@@ -282,4 +275,16 @@ bool cache_hot(const struct cache *cache, uint32_t key)
     }
     return false;
 }
+void cache_profile(const struct cache *cache,
+                   FILE *output_file,
+                   prof_func_t func)
+{
+    assert(func);
+    for (int i = 0; i < THRESHOLD; i++) {
+        lfu_entry_t *entry, *safe;
+        list_for_each_entry_safe (entry, safe, cache->lists[i], list) {
+            func(entry->value, entry->frequency, output_file);
+        }
+    }
+}
 #endif

src/cache.h

@@ -7,6 +7,13 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include <stdio.h>
+
+/* Currently, THRESHOLD is set to identify hot spots. Once the using frequency
+ * for a block exceeds the THRESHOLD, the tier-1 JIT compiler process is
+ * triggered.
+ */
+#define THRESHOLD 4096
 
 struct cache;
 
@@ -20,9 +27,10 @@ struct cache *cache_create(int size_bits);
  * cache_get - retrieve the specified entry from the cache
  * @cache: a pointer points to target cache
  * @key: the key of the specified entry
+ * @update: update frequency or not
  * @return: the specified entry or NULL
  */
-void *cache_get(const struct cache *cache, uint32_t key);
+void *cache_get(const struct cache *cache, uint32_t key, bool update);
 
 /**
  * cache_put - insert a new entry into the cache
@@ -48,6 +56,11 @@ void cache_free(struct cache *cache);
  * @key: the key of the specified entry
  */
 bool cache_hot(const struct cache *cache, uint32_t key);
+
+typedef void (*prof_func_t)(void *, uint32_t, FILE *);
+void cache_profile(const struct cache *cache,
+                   FILE *output_file,
+                   prof_func_t func);
 #endif
 
-uint32_t cache_freq(struct cache *cache, uint32_t key);
+uint32_t cache_freq(const struct cache *cache, uint32_t key);

src/emulate.c

@@ -305,6 +305,7 @@ static block_t *block_alloc(riscv_t *rv)
     block->translatable = true;
     block->hot = false;
     block->backward = false;
+    block->has_loops = false;
     INIT_LIST_HEAD(&block->list);
 #endif
     return block;
@@ -383,6 +384,11 @@ static bool is_branch_taken = false;
 /* record the program counter of the previous block */
 static uint32_t last_pc = 0;
 
+#if RV32_HAS(JIT)
+static set_t pc_set;
+static bool has_loops = false;
+#endif
+
 /* Interpreter-based execution path */
 #define RVOP(inst, code, asm)                                         \
     static bool do_##inst(riscv_t *rv, rv_insn_t *ir, uint64_t cycle, \
@@ -628,8 +634,10 @@ static void block_translate(riscv_t *rv, block_t *block)
 #endif
         /* stop on branch */
         if (insn_is_branch(ir->opcode)) {
+#if RV32_HAS(JIT)
             if (ir->imm < 0)
                 block->backward = true;
+#endif
             if (ir->opcode == rv_insn_jalr
 #if RV32_HAS(EXT_C)
                 || ir->opcode == rv_insn_cjalr || ir->opcode == rv_insn_cjr
@@ -950,7 +958,7 @@ static block_t *block_find_or_translate(riscv_t *rv)
     block_t *next = block_find(map, rv->PC);
 #else
     /* lookup the next block in the block cache */
-    block_t *next = (block_t *) cache_get(rv->block_cache, rv->PC);
+    block_t *next = (block_t *) cache_get(rv->block_cache, rv->PC, true);
 #endif
 
     if (!next) {
@@ -986,7 +994,7 @@ static block_t *block_find_or_translate(riscv_t *rv)
             rv_insn_t *taken = delete_target->ir_tail->branch_taken,
                       *untaken = delete_target->ir_tail->branch_untaken;
             if (taken && taken->pc != delete_target->pc_start) {
-                block_t *target = cache_get(rv->block_cache, taken->pc);
+                block_t *target = cache_get(rv->block_cache, taken->pc, false);
                 bool flag = false;
                 list_for_each_entry_safe (entry, safe, &target->list, list) {
                     if (entry->block == delete_target) {
@@ -998,7 +1006,8 @@ static block_t *block_find_or_translate(riscv_t *rv)
                 assert(flag);
             }
             if (untaken && untaken->pc != delete_target->pc_start) {
-                block_t *target = cache_get(rv->block_cache, untaken->pc);
+                block_t *target =
+                    cache_get(rv->block_cache, untaken->pc, false);
                 assert(target);
                 bool flag = false;
                 list_for_each_entry_safe (entry, safe, &target->list, list) {
@@ -1039,6 +1048,22 @@ static block_t *block_find_or_translate(riscv_t *rv)
 }
 
 #if RV32_HAS(JIT)
+static bool runtime_profiler(riscv_t *rv, block_t *block)
+{
+    /* Based on our observation, a high percentage of true hotspots involve high
+     * using frequency, loops or backward jumps. Therefore, we believe our
+     * profiler can use three indices to detect hotspots */
+    uint32_t freq = cache_freq(rv->block_cache, block->pc_start);
+    /* to profile the block after chaining, the block should be executed first
+     */
+    if (unlikely(freq >= 2 && (block->backward || block->has_loops)))
+        return true;
+    /* using frequency exceeds predetermined threshold */
+    if (unlikely(freq == THRESHOLD))
+        return true;
+    return false;
+}
+
 typedef void (*exec_block_func_t)(riscv_t *rv, uintptr_t);
 #endif
 
@@ -1056,7 +1081,7 @@ void rv_step(riscv_t *rv, int32_t cycles)
 #if !RV32_HAS(JIT)
             prev = block_find(&rv->block_map, last_pc);
 #else
-            prev = cache_get(rv->block_cache, last_pc);
+            prev = cache_get(rv->block_cache, last_pc, false);
 #endif
         }
         /* lookup the next block in block map or translate a new block,
@@ -1116,17 +1141,16 @@ void rv_step(riscv_t *rv, int32_t cycles)
             prev = NULL;
             continue;
         } /* check if using frequency of block exceed threshold */
-        else if (block->translatable &&
-                 ((block->backward &&
-                   cache_freq(rv->block_cache, block->pc_start) >= 1024) ||
-                  cache_hot(rv->block_cache, block->pc_start))) {
+        else if (block->translatable && runtime_profiler(rv, block)) {
             block->hot = true;
             block->offset = jit_translate(rv, block);
             ((exec_block_func_t) state->buf)(
                 rv, (uintptr_t) (state->buf + block->offset));
             prev = NULL;
             continue;
         }
+        set_reset(&pc_set);
+        has_loops = false;
 #endif
         /* execute the block by interpreter */
         const rv_insn_t *ir = block->ir_head;
@@ -1135,6 +1159,10 @@ void rv_step(riscv_t *rv, int32_t cycles)
             prev = NULL;
             break;
         }
+#if RV32_HAS(JIT)
+        if (has_loops && !block->has_loops)
+            block->has_loops = true;
+#endif
         prev = block;
     }
 }

src/jit.c

@@ -1163,60 +1163,6 @@ static void muldivmod(struct jit_state *state,
 }
 #endif /* RV32_HAS(EXT_M) */
 
-#define SET_SIZE_BITS 10
-#define SET_SIZE (1 << SET_SIZE_BITS)
-#define SET_SLOTS_SIZE 32
-HASH_FUNC_IMPL(set_hash, SET_SIZE_BITS, 1 << SET_SIZE_BITS);
-
-/* The set consists of SET_SIZE buckets, with each bucket containing
- * SET_SLOTS_SIZE slots.
- */
-typedef struct {
-    uint32_t table[SET_SIZE][SET_SLOTS_SIZE];
-} set_t;
-
-/**
- * set_reset - clear a set
- * @set: a pointer points to target set
- */
-static inline void set_reset(set_t *set)
-{
-    memset(set, 0, sizeof(set_t));
-}
-
-/**
- * set_add - insert a new element into the set
- * @set: a pointer points to target set
- * @key: the key of the inserted entry
- */
-static bool set_add(set_t *set, uint32_t key)
-{
-    const uint32_t index = set_hash(key);
-    uint8_t count = 0;
-    while (set->table[index][count]) {
-        if (set->table[index][count++] == key)
-            return false;
-    }
-
-    set->table[index][count] = key;
-    return true;
-}
-
-/**
- * set_has - check whether the element exist in the set or not
- * @set: a pointer points to target set
- * @key: the key of the inserted entry
- */
-static bool set_has(set_t *set, uint32_t key)
-{
-    const uint32_t index = set_hash(key);
-    for (uint8_t count = 0; set->table[index][count]; count++) {
-        if (set->table[index][count] == key)
-            return true;
-    }
-    return false;
-}
-
 static void prepare_translate(struct jit_state *state)
 {
 #if defined(__x86_64__)
@@ -1497,12 +1443,14 @@ static void translate_chained_block(struct jit_state *state,
     translate(state, rv, block);
     rv_insn_t *ir = block->ir_tail;
     if (ir->branch_untaken && !set_has(set, ir->branch_untaken->pc)) {
-        block_t *block1 = cache_get(rv->block_cache, ir->branch_untaken->pc);
+        block_t *block1 =
+            cache_get(rv->block_cache, ir->branch_untaken->pc, false);
         if (block1->translatable)
             translate_chained_block(state, rv, block1, set);
     }
     if (ir->branch_taken && !set_has(set, ir->branch_taken->pc)) {
-        block_t *block1 = cache_get(rv->block_cache, ir->branch_taken->pc);
+        block_t *block1 =
+            cache_get(rv->block_cache, ir->branch_taken->pc, false);
         if (block1->translatable)
             translate_chained_block(state, rv, block1, set);
     }

src/main.c

@@ -37,11 +37,15 @@ static const char *opt_prog_name = "a.out";
 /* target argc and argv */
 static int prog_argc;
 static char **prog_args;
-static const char *optstr = "tgqmhd:a:";
+static const char *optstr = "tgqmhpd:a:";
 
 /* enable misaligned memory access */
 static bool opt_misaligned = false;
 
+/* dump profiling data */
+static bool opt_prof_data = false;
+static char *prof_out_file;
+
 #define MEMIO(op) on_mem_##op
 #define IO_HANDLER_IMPL(type, op, RW)                                     \
     static IIF(RW)(                                                       \
@@ -108,6 +112,7 @@ static void print_usage(const char *filename)
             "  -a [filename] : dump signature to the given file, "
             "required by arch-test test\n"
             "  -m : enable misaligned memory access\n"
+            "  -p : generate profiling data\n"
             "  -h : show this message\n",
             filename);
 }
@@ -137,6 +142,9 @@ static bool parse_args(int argc, char **args)
         case 'm':
             opt_misaligned = true;
             break;
+        case 'p':
+            opt_prof_data = true;
+            break;
         case 'd':
             opt_dump_regs = true;
             registers_out_file = optarg;
@@ -158,6 +166,12 @@ static bool parse_args(int argc, char **args)
      */
     prog_args = &args[optind];
     opt_prog_name = prog_args[0];
+    if (opt_prof_data) {
+        char *prog_name = malloc(strlen(opt_prog_name) - 11);
+        strncpy(prog_name, opt_prog_name + 8, strlen(opt_prog_name) - 12);
+        prof_out_file = malloc(strlen(opt_prog_name) + 1);
+        sprintf(prof_out_file, "./prof/%s.prof", prog_name);
+    }
     return true;
 }
 
@@ -264,6 +278,8 @@ int main(int argc, char **args)
     if (opt_arch_test)
         dump_test_signature(elf);
 
+    if (opt_prof_data)
+        rv_profile(rv, prof_out_file);
     /* finalize the RISC-V runtime */
     elf_delete(elf);
     rv_delete(rv);