PCSX2 Documentation/Introduction to Dynamic Recompilation: Difference between revisions

''Originally written by cottonvibes''

Assume we are emulating a very simple processor. Processors have instruction sets which are a set of different instructions they can compute.

Lets assume the processor we are emulating is a made-up chip I'll call SL3 (super lame 3), and has only these 3 instructions (and each instruction has fixed width of 4 bytes):

MOV dest_reg, src1_reg // Move source register to destination register

ADD dest_reg, src1_reg, src2_reg // Add source1 and source2 registers, and store the result in destination register

BR relative_address // Branch (jump) to relative address (PC += relative_address * 4)

Processors generally have what we call registers which can hold data, and the processor's instructions perform the operations on these registers.

Now to program for this processor, we can have the following code:

MOV reg1, reg0

ADD reg4, reg2, reg3

BR 5

What this code does is:

So that is how we can program for the SL3 processor in assembly code. But how do we emulate it?

To actually emulate this processor we can use an interpreter. An interpreter simply fetches each instruction opcode and executes them accordingly (e.g. by calling emulated methods for each different instruction). The rest of the emulator (emulating other processors/peripherals of our system) can then get updated sometime in between instructions or after a group of cpu instructions are run. Interpreters are a simple and complete way to emulate a system.

Using interpreters we constantly have to be fetching and executing instructions one-by-one. There is a lot of overhead in this, and minimal room for optimization since most special case optimizations will have the overhead of checking for them (so it will for example add extra if-statements and conditionals... reducing the gain from the optimization). But there's a faster way to do processor emulation which doesn't have these draw-backs... using dynamic recompilation!

So for instance remember our above SL3 program:

MOV reg1, reg0

ADD reg4, reg2, reg3

BR 5

Lets assume this code is part of some function and gets called 100's of times a second (this could sound crazy, but games/applications commonly call the same code hundreds or thousands of times a second).

PCSX2 has a very cool emitter that looks very similar to x86-32 assembly, except the instructions have an 'x' before them.

So for example:

mov eax, ecx;

is

xMOV(eax, ecx);

with the pcsx2 emitter.

The code for actually recompiling these blocks looks something like this:

// This is our emulated MOV instruction

void MOV() {

     }

}

Note the above code doesn't have any logic to successfully exit once it starts executing recompiled blocks... I left this stuff out in order to not complicate things... so assume that somehow execution ends and we can get back to running the other parts of the emulator...  

I should also add that currently pcsx2 has the following dynarecs: