drc: don't clear ARM caches on whole translation cache - it's very slow

[pcsx_rearmed.git] / libpcsxcore / new_dynarec / emu_if.c

diff --git a/libpcsxcore/new_dynarec/emu_if.c b/libpcsxcore/new_dynarec/emu_if.c
index 2560eb3..bdf0c8f 100644 (file)
--- a/libpcsxcore/new_dynarec/emu_if.c
+++ b/libpcsxcore/new_dynarec/emu_if.c
@@ -6,38 +6,69 @@
 #include "../psxmem.h"
 #include "../psxhle.h"
 
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
+
 //#define memprintf printf
 #define memprintf(...)
 //#define evprintf printf
 #define evprintf(...)
 
 char invalid_code[0x100000];
+u32 event_cycles[7];
 
-void MTC0_()
+static void schedule_timeslice(void)
 {
-       extern void psxMTC0();
+       u32 i, c = psxRegs.cycle;
+       s32 min, dif;
+
+       min = psxNextsCounter + psxNextCounter - c;
+       for (i = 0; i < ARRAY_SIZE(event_cycles); i++) {
+               dif = event_cycles[i] - c;
+               //evprintf("  ev %d\n", dif);
+               if (0 < dif && dif < min)
+                       min = dif;
+       }
+       next_interupt = c + min;
 
-       memprintf("ari64 MTC0 %08x\n", psxRegs.code);
-       psxMTC0();
-       pending_exception = 1; /* FIXME? */
+#if 0
+       static u32 cnt, last_cycle;
+       static u64 sum;
+       if (last_cycle) {
+               cnt++;
+               sum += psxRegs.cycle - last_cycle;
+               if ((cnt & 0xff) == 0)
+                       printf("%u\n", (u32)(sum / cnt));
+       }
+       last_cycle = psxRegs.cycle;
+#endif
 }
 
 void gen_interupt()
 {
-       evprintf("ari64_gen_interupt\n");
-       evprintf("  +ge %08x, %d->%d\n", psxRegs.pc, psxRegs.cycle, next_interupt);
+       evprintf("  +ge %08x, %u->%u\n", psxRegs.pc, psxRegs.cycle, next_interupt);
 #ifdef DRC_DBG
        psxRegs.cycle += 2;
 #endif
 
        psxBranchTest();
 
-       next_interupt = psxNextsCounter + psxNextCounter;
-       evprintf("  -ge %08x, %d->%d\n", psxRegs.pc, psxRegs.cycle, next_interupt);
+       schedule_timeslice();
+
+       evprintf("  -ge %08x, %u->%u (%d)\n", psxRegs.pc, psxRegs.cycle,
+               next_interupt, next_interupt - psxRegs.cycle);
 
        pending_exception = 1; /* FIXME */
 }
 
+void MTC0_()
+{
+       extern void psxMTC0();
+
+       evprintf("ari64 MTC0 %08x %08x %u\n", psxRegs.code, psxRegs.pc, psxRegs.cycle);
+       psxMTC0();
+       gen_interupt(); /* FIXME: checking pending irqs should be enough */
+}
+
 void check_interupt()
 {
        printf("ari64_check_interupt\n");
@@ -50,37 +81,37 @@ void read_nomem_new()
 
 static void read_mem8()
 {
-       memprintf("ari64_read_mem8  %08x, PC~=%08x\n", address, psxRegs.pc);
+       memprintf("ari64_read_mem8  %08x @%08x %u\n", address, psxRegs.pc, psxRegs.cycle);
        readmem_word = psxMemRead8(address) & 0xff;
 }
 
 static void read_mem16()
 {
-       memprintf("ari64_read_mem16 %08x, PC~=%08x\n", address, psxRegs.pc);
+       memprintf("ari64_read_mem16 %08x @%08x %u\n", address, psxRegs.pc, psxRegs.cycle);
        readmem_word = psxMemRead16(address) & 0xffff;
 }
 
 static void read_mem32()
 {
-       memprintf("ari64_read_mem32 %08x, PC~=%08x\n", address, psxRegs.pc);
+       memprintf("ari64_read_mem32 %08x @%08x %u\n", address, psxRegs.pc, psxRegs.cycle);
        readmem_word = psxMemRead32(address);
 }
 
 static void write_mem8()
 {
-       memprintf("ari64_write_mem8  %08x,       %02x, PC~=%08x\n", address, byte, psxRegs.pc);
+       memprintf("ari64_write_mem8  %08x,       %02x @%08x %u\n", address, byte, psxRegs.pc, psxRegs.cycle);
        psxMemWrite8(address, byte);
 }
 
 static void write_mem16()
 {
-       memprintf("ari64_write_mem16 %08x,     %04x, PC~=%08x\n", address, hword, psxRegs.pc);
+       memprintf("ari64_write_mem16 %08x,     %04x @%08x %u\n", address, hword, psxRegs.pc, psxRegs.cycle);
        psxMemWrite16(address, hword);
 }
 
 static void write_mem32()
 {
-       memprintf("ari64_write_mem32 %08x, %08x, PC~=%08x\n", address, word, psxRegs.pc);
+       memprintf("ari64_write_mem32 %08x, %08x @%08x %u\n", address, word, psxRegs.pc, psxRegs.cycle);
        psxMemWrite32(address, word);
 }
 
@@ -110,7 +141,7 @@ static int ari64_init()
 
        new_dynarec_init();
 
-       for (i = 0; i < sizeof(readmem) / sizeof(readmem[0]); i++) {
+       for (i = 0; i < ARRAY_SIZE(readmem); i++) {
                readmemb[i] = read_mem8;
                readmemh[i] = read_mem16;
                readmem[i] = read_mem32;
@@ -119,7 +150,7 @@ static int ari64_init()
                writemem[i] = write_mem32;
        }
 
-       for (i = 0; i < sizeof(gte_handlers) / sizeof(gte_handlers[0]); i++)
+       for (i = 0; i < ARRAY_SIZE(gte_handlers); i++)
                if (psxCP2[i] != psxNULL)
                        gte_handlers[i] = psxCP2[i];
 
@@ -128,22 +159,42 @@ static int ari64_init()
 
 static void ari64_reset()
 {
-       /* hmh */
        printf("ari64_reset\n");
+       invalidate_all_pages();
+       pending_exception = 1;
 }
 
 static void ari64_execute()
 {
-       next_interupt = psxNextsCounter + psxNextCounter;
+       schedule_timeslice();
+
+       evprintf("ari64_execute %08x, %u->%u (%d)\n", psxRegs.pc,
+               psxRegs.cycle, next_interupt, next_interupt - psxRegs.cycle);
 
-       evprintf("psxNextsCounter %d, psxNextCounter %d\n", psxNextsCounter, psxNextCounter);
-       evprintf("ari64_execute %08x, %d->%d\n", psxRegs.pc, psxRegs.cycle, next_interupt);
        new_dyna_start();
-       evprintf("ari64_execute end %08x, %d->%d\n", psxRegs.pc, psxRegs.cycle, next_interupt);
+
+       evprintf("ari64_execute end %08x, %u->%u (%d)\n", psxRegs.pc,
+               psxRegs.cycle, next_interupt, next_interupt - psxRegs.cycle);
 }
 
-static void ari64_clear(u32 Addr, u32 Size)
+static void ari64_clear(u32 addr, u32 size)
 {
+       u32 start, end;
+
+       evprintf("ari64_clear %08x %04x\n", addr, size);
+
+       /* check for RAM mirrors */
+       if ((addr & ~0xe0000000) < 0x200000) {
+               addr &= ~0xe0000000;
+               addr |=  0x80000000;
+       }
+
+       start = addr >> 12;
+       end = (addr + size) >> 12;
+
+       for (; start <= end; start++)
+               if (!invalid_code[start])
+                       invalidate_block(start);
 }
 
 static void ari64_shutdown()
@@ -184,11 +235,13 @@ void do_insn_cmp() {}
 unsigned int address, readmem_word, word;
 unsigned short hword;
 unsigned char byte;
-int pending_exception;
+int pending_exception, stop;
 unsigned int next_interupt;
 void new_dynarec_init() {}
 void new_dyna_start() {}
 void new_dynarec_cleanup() {}
+void invalidate_all_pages() {}
+void invalidate_block(unsigned int block) {}
 #endif
 
 #ifdef DRC_DBG