PS1P WIP News - PSOne Emu for PSP Coming Soon

[JKKDARK]

Nice, I can't wait for the first vesion!

[Malksta]

Awesome

[Jiji01]

In computer science, dynamic recompilation (sometimes abbreviated to dynarec) is a feature of some emulators and virtual machines, where the system may recompile some part of a program during execution. By compiling during execution, the system can tailor the generated code to reflect the program's run-time environment, and perhaps produce more efficient code by exploiting information that is not available to a traditional static compiler.

Example

Suppose a program is being run in an emulator and needs to copy a string.
The program is compiled originally for a very simple processor. This processor can only copy a byte at a time, and must do so by first reading it from the source string into a register, then writing it from that register into the destination string.
The original program might look something like this:

beginning:
mov A,[first string pointer] ;Put location of first character of source string in register A
mov B,[second string pointer] ;Put location of first character of destination string in register B
loop:
mov C,[A] ;Copy byte at address in register A to register C
mov [B],C ;Copy byte in register C to the address in register B
cmp [B],#0 ;Compare the data we just copied to 0
inc A ;Increment the address in register A to point to the next byte
inc B ;Increment the address in register B to point to the next byte
jnz loop ;If it wasn't 0 then we have more to copy, so go back and copy the next byte
end: ;If we didn't loop then we must have finished, so carry on with something else.

The emulator might be running on a processor which is similar, but extremely good at copying strings, and the emulator knows it can take advantage of this.

It might recognise the string copy sequence of instructions and decide to rewrite them more efficiently just before execution, to speed up the emulation.

Say there is an instruction on our new processor called movs, specifically designed to copy strings efficiently. Our theoretical movs instruction copies 16 bytes at a time, without having to load them into register C in between, but will stop if it copies a 0 byte (which marks the end of a string) and set the zero flag. It also knows that the addresses of the strings will be in registers A and B, so it increments A and B by 16 every time it executes, ready for the next copy. Our new recompiled code might look something like this:

beginning:
mov A,[first string pointer] ;Put location of first character of source string in register A
mov B,[second string pointer] ;Put location of first character of destination string in register B
loop:
movs [B],[A] ;Copy 16 bytes at address in register A to address in register B,
then increment A and B by 16
jnz loop ;If the zero flag isn't set then we haven't reached the end of the string,
so go back and copy some more.
end: ;If we didn't loop then we must have finished, so carry on with something else.

There is an immediate speed benefit simply because the processor doesn't have to load so many instructions to do the same task, but also because the movs instruction is likely to be optimised by the processor designer to be more efficient than the sequence used in the first example (for example it may make better use of parallel execution in the processor to increment A and B while it is still copying bytes).

In an ironic twist in real world usage, the first sequence of instructions (RISC) is generally preferred over the next (CISC). The reasons provided are slow CISC processor execution, prevention of pipeline stalls, and lower hardware overheads.
from wikipedia

so i think that dynarec is exactly what we already know, a way to make PS1P faster

(Sorry if my english isn't perfect, it's not my native language)

[Datahax]

In computer science, dynamic recompilation (sometimes abbreviated to dynarec) is a feature of some emulators and virtual machines, where the system may recompile some part of a program during execution. By compiling during execution, the system can tailor the generated code to reflect the program's run-time environment, and perhaps produce more efficient code by exploiting information that is not available to a traditional static compiler.

from wikipedia so i think that dynarec is exactly what we already know, a way to make PS1P faster

(Sorry if my english isn't perfect, it's not my native language)

Basically code written for one system may work great for that system because it uses everything as best as it can, but a different system executes the code differently and because of changes possibly less efficently, so this way the code is recompiled to work as best as it can on the different system.

[Jiji01]

thanks datahax, no i think we're ok with what a dynarec is.

Just keep on the good work AC, we're all with you [pom pom girl mode off/]

[acn010]

im waiting for it!!!!
XD

[Shuin0]

Im really starting to get iffy with the PS1 Emu.... I'm not taking that this is real or ever coming out. But we will see. But if it does i give all support if he can get anythin PS1 running on the PSP

[mexicansnake]

Awesome! I cant wait!.

[acn010]

Im really starting to get iffy with the PS1 Emu.... I'm not taking that this is real or ever coming out. But we will see. But if it does i give all support if he can get anythin PS1 running on the PSP

it is real, wraggy even introduce who is the coder on this emu

[canwemakelove]

gud newz