Add basic CPU benchmark

Ported from DingusPPC's benchmark code (dingusdev/dingusppc@6124dfd)

Author: mihaip

.gitignore

@@ -18,6 +18,7 @@ depcomp
 install-sh
 missing
 ylwrap
+*.o
 
 # Emscripten autoconf output
 a.wasm

src/Makefile.am

@@ -27,7 +27,8 @@ ppc_LDFLAGS	= @PPC_LDFLAGS@
 
 ppc_SOURCES	= main.cc info.h ppc_img.c ppc_img.h \
 ppc_font.c ppc_font.h ppc_button_changecd.c ppc_button_changecd.h \
-configparser.cc configparser.h
+configparser.cc configparser.h \
+ppc_bench.cc ppc_bench.h
 
 dist2: distdir
 	$(AMTAR) chof - $(distdir) | BZIP2=$(BZIP2_ENV) bzip2 -c >$(distdir).tar.bz2

src/cpu/cpu_generic/ppc_dec.cc

@@ -87,11 +87,19 @@ static void ppc_opc_invalid(uint32 opc)
 		gCPU.pc = gCPU.npc;
 		return;
 	}
+	if (opc == 0x00005AF0) {
+		// End of benchmark stream
+		ppc_cpu_stop();
+		return;
+	}
 	fprintf(stderr, "[PPC/DEC] Bad opcode: %08x (%u:%u)\n",
 		opc, PPC_OPC_MAIN(opc),
 		PPC_OPC_EXT(opc));
 
 	SINGLESTEP("unknown instruction\n");
+
+	// Avoids some benchmarking overhead.
+	__builtin_unreachable();
 }
 
 // main opcode 19

src/debug/tracers.h

@@ -25,7 +25,7 @@
 #include "tools/snprintf.h"
 
 
-#define PPC_CPU_TRACE(msg...) ht_printf("[CPU/CPU] " msg)
+//#define PPC_CPU_TRACE(msg...) ht_printf("[CPU/CPU] " msg)
 #define PPC_ALU_TRACE(msg...) ht_printf("[CPU/ALU] " msg)
 #define PPC_FPU_TRACE(msg...) ht_printf("[CPU/FPU] " msg)
 #define PPC_DEC_TRACE(msg...) ht_printf("[CPU/DEC] " msg)

src/main.cc

@@ -49,6 +49,7 @@
 #include "system/gif.h"
 #include "system/ui/gui.h"
 
+#include "ppc_bench.h"
 #include "ppc_font.h"
 #include "ppc_img.h"
 #include "ppc_button_changecd.h"
@@ -235,6 +236,10 @@ int main(int argc, char *argv[])
 	if (!initAtom()) return 3;
 	if (!initData()) return 4;
 	if (!initOSAPI()) return 5;
+
+	if (strncmp(argv[1], "bench", 5) == 0) {
+		return ppc_bench();
+	}
 	try {
 		gConfig = new ConfigParser();
 		gConfig->acceptConfigEntryStringDef("ppc_start_resolution", "800x600x15");

src/ppc_bench.cc

@@ -0,0 +1,141 @@
+#include <chrono>
+
+#include "configparser.h"
+#include "cpu/cpu.h"
+#include "cpu/mem.h"
+#include "system/types.h"
+#include "tools/snprintf.h"
+#include "debug/ppcdis.h"
+#include "cpu/cpu_generic/ppc_mmu.h"
+#include "cpu/cpu_generic/ppc_cpu.h"
+#include "system/arch/sysendian.h"
+
+uint32 cs_code[] = {
+    0x3863FFFC, 0x7C861671, 0x41820090, 0x70600002, 0x41E2001C, 0xA0030004,
+    0x3884FFFE, 0x38630002, 0x5486F0BF, 0x7CA50114, 0x41820070, 0x70C60003,
+    0x41820014, 0x7CC903A6, 0x84030004, 0x7CA50114, 0x4200FFF8, 0x5486E13F,
+    0x41820050, 0x80030004, 0x7CC903A6, 0x80C30008, 0x7CA50114, 0x80E3000C,
+    0x7CA53114, 0x85030010, 0x7CA53914, 0x42400028, 0x80030004, 0x7CA54114,
+    0x80C30008, 0x7CA50114, 0x80E3000C, 0x7CA53114, 0x85030010, 0x7CA53914,
+    0x4200FFE0, 0x7CA54114, 0x70800002, 0x41E20010, 0xA0030004, 0x38630002,
+    0x7CA50114, 0x70800001, 0x41E20010, 0x88030004, 0x5400402E, 0x7CA50114,
+    0x7C650194, /* 0x4E800020 */ 0x00005AF0
+};
+
+constexpr uint32 test_size = 0x8000; // 0x7FFFFFFC is the max
+constexpr uint32 test_samples = 2000;
+constexpr uint32 test_iterations = 5;
+
+int ppc_bench() {
+    gConfig = new ConfigParser();
+    ppc_cpu_init_config();
+
+    if (!ppc_init_physical_memory(64 * 1024 * 1024)) { // 64MB is the minimum
+        ht_printf("cannot initialize memory.\n");
+        return 1;
+    }
+    if (!ppc_cpu_init()) {
+        ht_printf("cpu_init failed! Out of memory?\n");
+        return 1;
+    }
+
+    size_t code_size = sizeof(cs_code) / sizeof(cs_code[0]);
+    ht_printf("Loading %llu instructions:\n", code_size);
+
+    /* load executable code into RAM at address 0 */
+    for (int i = 0; i < code_size; i++) {
+        uint32 instr_code = cs_code[i];
+        uint32 instr_code_be = ppc_word_to_BE(instr_code);
+        uint32 instr_addr = i * 4;
+        uint32 instr_physical_addr;
+	    int r = ppc_effective_to_physical(instr_addr, PPC_MMU_WRITE | PPC_MMU_CODE, instr_physical_addr);
+        if (r != PPC_MMU_OK) {
+            ht_printf("MMU error when mapping instruction address: %d\n", r);
+            return 1;
+        }
+
+        // ppc_write_physical_word gets optimized out, do its equivalent.
+        *((uint32*)(gMemory+instr_physical_addr)) = instr_code_be;
+
+        PPCDisassembler dis(PPC_MODE_32);
+        CPU_ADDR addr;
+        addr.addr32.offset = instr_addr;
+        const char *instr_disasm = dis.str(dis.decode((byte*)&instr_code_be, 4, addr), 0);
+        ht_printf("Instruction %02llu: 0x%08x %s\n", i, instr_code, instr_disasm);
+    }
+
+    srand(0xCAFEBABE);
+
+    ht_printf("Test size: 0x%X\n", test_size);
+    ht_printf("First few bytes:\n");
+    bool did_lf = false;
+    for (int i = 0; i < test_size; i++) {
+        uint8 val = rand() % 256;
+        if (i < 64) {
+            ht_printf("%02x", val);
+            did_lf = false;
+            if (i % 32 == 31) {
+                ht_printf("\n");
+                did_lf = true;
+            }
+        }
+
+        uint32 addr = 0x1000+i;
+        uint32 physical_addr;
+	    int r = ppc_effective_to_physical(addr, PPC_MMU_WRITE, physical_addr);
+        if (r != PPC_MMU_OK) {
+            ht_printf("MMU error when mapping data address: %d\n", r);
+            return 1;
+        }
+
+        gMemory[physical_addr] = val;
+    }
+    if (!did_lf)
+        ht_printf("\n");
+
+    // Run once to warm up the cache cache and to get the expected checksum value.
+    ppc_cpu_set_pc(0, 0);
+    ppc_cpu_set_gpr(0, 3, 0x1000);    // buf
+    ppc_cpu_set_gpr(0, 4, test_size); // len
+    ppc_cpu_set_gpr(0, 5, 0);         // sum
+    ppc_cpu_run();
+    uint32 checksum = ppc_cpu_get_gpr(0, 3);
+    ht_printf("Checksum: 0x%08X\n", checksum);
+
+    // Also warm up the clock
+    uint64_t overhead = -1;
+    for (int i = 0; i < test_samples; i++) {
+        auto start_time   = std::chrono::steady_clock::now();
+        auto end_time     = std::chrono::steady_clock::now();
+        auto time_elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time);
+        if (time_elapsed.count() < overhead) {
+            overhead = time_elapsed.count();
+        }
+    }
+    ht_printf("Overhead Time: %lld ns\n", overhead);
+
+    ht_printf("Running benchmark...\n");
+    for (int i = 0; i < test_iterations; i++) {
+        uint64_t best_sample = -1;
+        for (int j = 0; j < test_samples; j++) {
+            ppc_cpu_set_pc(0, 0);
+            ppc_cpu_set_gpr(0, 3, 0x1000);    // buf
+            ppc_cpu_set_gpr(0, 4, test_size); // len
+            ppc_cpu_set_gpr(0, 5, 0);         // sum
+
+            auto start_time   = std::chrono::steady_clock::now();
+            ppc_cpu_run();
+            auto end_time     = std::chrono::steady_clock::now();
+            auto time_elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time);
+            if (time_elapsed.count() < best_sample)
+                best_sample = time_elapsed.count();
+        }
+        uint32 iter_checksum = ppc_cpu_get_gpr(0, 3);
+        if (iter_checksum != checksum)
+        ht_printf("Checksum changed in iteration %d: 0x%08X\n", i, iter_checksum);
+        best_sample -= overhead;
+        ht_printf("(%d) %lld ns, %.4lf MiB/s\n", i+1, best_sample, 1E9 * test_size / (best_sample * 1024 * 1024));
+    }
+
+    return 0;
+}

src/ppc_bench.h

@@ -0,0 +1 @@
+int ppc_bench();