Initial Contribution

1 files changed, 222 insertions, 0 deletions

diff --git a/emulator/qtools/bbprof.cpp b/emulator/qtools/bbprof.cpp
new file mode 100644
index 0000000..36d0941
--- /dev/null
+++ b/emulator/qtools/bbprof.cpp
@@ -0,0 +1,222 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+#include "trace_reader.h"
+#include "armdis.h"
+
+struct MyStaticRec {
+    StaticRec   bb;
+    uint32_t    *insns;
+    uint32_t    *cycles;    // number of cycles for each insn
+    uint32_t    elapsed;    // number of cycles for basic block
+    int         freq;       // execution frequency
+    MyStaticRec *inner;     // pointer to an inner basic block
+    int         is_thumb;
+};
+
+MyStaticRec **assign_inner_blocks(int num_blocks, MyStaticRec *blocks);
+
+// This function is called from quicksort to compare addresses of basic
+// blocks.
+int cmp_inc_addr(const void *a, const void *b) {
+    MyStaticRec *bb1, *bb2;
+
+    bb1 = *(MyStaticRec**)a;
+    bb2 = *(MyStaticRec**)b;
+    if (bb1->bb.bb_addr < bb2->bb.bb_addr)
+        return -1;
+    if (bb1->bb.bb_addr > bb2->bb.bb_addr)
+        return 1;
+    return bb1->bb.bb_num - bb2->bb.bb_num;
+}
+
+// This function is called from quicksort to compare the elapsed time
+// of basic blocks.
+int cmp_dec_elapsed(const void *a, const void *b) {
+    MyStaticRec *bb1, *bb2;
+
+    bb1 = *(MyStaticRec**)a;
+    bb2 = *(MyStaticRec**)b;
+    if (bb1->elapsed < bb2->elapsed)
+        return 1;
+    if (bb1->elapsed > bb2->elapsed)
+        return -1;
+    return bb1->bb.bb_num - bb2->bb.bb_num;
+}
+
+// This function is called from quicksort to compare frequencies of
+// basic blocks.
+int cmp_dec_freq(const void *a, const void *b) {
+    MyStaticRec *bb1, *bb2;
+
+    bb1 = *(MyStaticRec**)a;
+    bb2 = *(MyStaticRec**)b;
+    if (bb1->freq < bb2->freq)
+        return 1;
+    if (bb1->freq > bb2->freq)
+        return -1;
+    return bb1->bb.bb_num - bb2->bb.bb_num;
+}
+
+int main(int argc, char **argv)
+{
+    if (argc != 2) {
+        fprintf(stderr, "Usage: %s trace_file\n", argv[0]);
+        exit(1);
+    }
+
+    char *trace_filename = argv[1];
+    TraceReaderBase *trace = new TraceReaderBase;
+    trace->Open(trace_filename);
+    TraceHeader *header = trace->GetHeader();
+    uint32_t num_static_bb = header->num_static_bb;
+
+    // Allocate space for all of the static blocks
+    MyStaticRec *blocks = new MyStaticRec[num_static_bb];
+
+    // Read in all the static blocks
+    for (uint32_t ii = 0; ii < num_static_bb; ++ii) {
+        trace->ReadStatic(&blocks[ii].bb);
+        blocks[ii].is_thumb = blocks[ii].bb.bb_addr & 1;
+        blocks[ii].bb.bb_addr &= ~1;
+        uint32_t num_insns = blocks[ii].bb.num_insns;
+        blocks[ii].insns = new uint32_t[num_insns];
+        blocks[ii].cycles = new uint32_t[num_insns];
+        memset(blocks[ii].cycles, 0, num_insns * sizeof(uint32_t));
+        trace->ReadStaticInsns(num_insns, blocks[ii].insns);
+        blocks[ii].elapsed = 0;
+        blocks[ii].freq = 0;
+        blocks[ii].inner = NULL;
+    }
+
+    MyStaticRec **sorted = assign_inner_blocks(num_static_bb, blocks);
+
+    uint32_t prev_time = 0;
+    uint32_t elapsed = 0;
+    uint32_t dummy;
+    uint32_t *cycle_ptr = &dummy;
+    uint32_t *bb_elapsed_ptr = &dummy;
+    while (1) {
+        BBEvent event;
+
+        if (trace->ReadBB(&event))
+            break;
+        // Assign frequencies to each basic block
+        uint64_t bb_num = event.bb_num;
+        int num_insns = event.num_insns;
+        blocks[bb_num].freq += 1;
+        for (MyStaticRec *bptr = blocks[bb_num].inner; bptr; bptr = bptr->inner)
+            bptr->freq += 1;
+
+        // Assign simulation time to each instruction
+        for (MyStaticRec *bptr = &blocks[bb_num]; bptr; bptr = bptr->inner) {
+            uint32_t bb_num_insns = bptr->bb.num_insns;
+            for (uint32_t ii = 0; num_insns && ii < bb_num_insns; ++ii, --num_insns) {
+                uint32_t sim_time = trace->ReadInsnTime(event.time);
+                elapsed = sim_time - prev_time;
+                prev_time = sim_time;
+
+                // Attribute the elapsed time to the previous instruction and
+                // basic block.
+                *cycle_ptr += elapsed;
+                *bb_elapsed_ptr += elapsed;
+                cycle_ptr = &bptr->cycles[ii];
+                bb_elapsed_ptr = &bptr->elapsed;
+            }
+        }
+    }
+    *cycle_ptr += 1;
+    *bb_elapsed_ptr += 1;
+
+    // Sort the basic blocks into decreasing elapsed time
+    qsort(sorted, num_static_bb, sizeof(MyStaticRec*), cmp_dec_elapsed);
+
+    char spaces[80];
+    memset(spaces, ' ', 79);
+    spaces[79] = 0;
+    for (uint32_t ii = 0; ii < num_static_bb; ++ii) {
+        printf("bb %lld addr: 0x%x, insns: %d freq: %u elapsed: %u\n",
+               sorted[ii]->bb.bb_num, sorted[ii]->bb.bb_addr,
+               sorted[ii]->bb.num_insns, sorted[ii]->freq,
+               sorted[ii]->elapsed);
+        int num_insns = sorted[ii]->bb.num_insns;
+        uint32_t addr = sorted[ii]->bb.bb_addr;
+        for (int jj = 0; jj < num_insns; ++jj) {
+            uint32_t elapsed = sorted[ii]->cycles[jj];
+            uint32_t insn = sorted[ii]->insns[jj];
+            if (insn_is_thumb(insn)) {
+                insn = insn_unwrap_thumb(insn);
+
+                // thumb_pair is true if this is the first of a pair of
+                // thumb instructions (BL or BLX).
+                bool thumb_pair = ((insn & 0xf800) == 0xf000);
+
+                // Get the next thumb instruction (if any) because we may need
+                // it for the case where insn is BL or BLX.
+                uint32_t insn2 = 0;
+                if (thumb_pair && (jj + 1 < num_insns)) {
+                    insn2 = sorted[ii]->insns[jj + 1];
+                    insn2 = insn_unwrap_thumb(insn2);
+                    jj += 1;
+                }
+                char *disasm = disasm_insn_thumb(addr, insn, insn2, NULL);
+                if (thumb_pair) {
+                    printf("  %4u %08x %04x %04x %s\n", elapsed, addr, insn,
+                           insn2, disasm);
+                    addr += 2;
+                } else {
+                    printf("  %4u %08x     %04x %s\n", elapsed, addr, insn,
+                           disasm);
+                }
+                addr += 2;
+            } else {
+                char *disasm = Arm::disasm(addr, insn, NULL);
+                printf("  %4u %08x %08x %s\n", elapsed, addr, insn, disasm);
+                addr += 4;
+            }
+        }
+    }
+
+    delete[] sorted;
+    return 0;
+}
+
+// Find the basic blocks that are subsets of other basic blocks.
+MyStaticRec **assign_inner_blocks(int num_blocks, MyStaticRec *blocks)
+{
+    int ii;
+    uint32_t addr_end, addr_diff;
+
+    // Create a list of pointers to the basic blocks that we can sort.
+    MyStaticRec **sorted = new MyStaticRec*[num_blocks];
+    for (ii = 0; ii < num_blocks; ++ii) {
+        sorted[ii] = &blocks[ii];
+    }
+
+    // Sort the basic blocks into increasing address order
+    qsort(sorted, num_blocks, sizeof(MyStaticRec*), cmp_inc_addr);
+
+    // Create pointers to inner blocks and break up the enclosing block
+    // so that there is no overlap.
+    for (ii = 0; ii < num_blocks - 1; ++ii) {
+        int num_bytes;
+        if (sorted[ii]->is_thumb)
+            num_bytes = sorted[ii]->bb.num_insns << 1;
+        else
+            num_bytes = sorted[ii]->bb.num_insns << 2;
+        addr_end = sorted[ii]->bb.bb_addr + num_bytes;
+        if (addr_end > sorted[ii + 1]->bb.bb_addr) {
+            sorted[ii]->inner = sorted[ii + 1];
+            addr_diff = sorted[ii + 1]->bb.bb_addr - sorted[ii]->bb.bb_addr;
+            uint32_t num_insns;
+            if (sorted[ii]->is_thumb)
+                num_insns = addr_diff >> 1;
+            else
+                num_insns = addr_diff >> 2;
+            sorted[ii]->bb.num_insns = num_insns;
+        }
+    }
+
+    return sorted;
+}