Leveraging Vector Pascal for a PS2 port???

[dmantione]

Excluding all automatically generated files, the ARM directory contains 297 kb of code. That is including an assembler reader, assembler writer and a backend for the internal assembler.

ARM9 should be a matter of extending the current ARM.

[WILL]

I think I'll make another thread for adding ports to FPC in general so that we can keep this thread more PS2 specific as it was intended.


[size=9px]EDIT: I've created the new thread Adding New Ports to FPC to continue our conversation about other possible new ports.[/size]

[VectorPascal]

This sounds doable. The compiler already contains code to do vector operations using MMX, i.e. the code to multiply arrays is there. This can be reused for such a port.

The PS2 uses a MIPS processor, but the compiler has no MIPS code generator yet. It should be straightforward to implement one. The MIPS is a very regular processor so should generally be easy, the only obstacle might be the lack of flags.

Basically all that is needed is someone with plenty of spare time

The port we did includes a code generator for the MIPS including the multi media extensions of the mips. The code generator can get VPU0 to operate as an attached processor, but we did not extend it fully to allow VPU0 and 1 to run independently fetching instructions from their own memory.

We hope to produce a port to the Cell next.

Here we will not be able to avoid the fact that the vector units have to fetch their own instructions.

The intended approach is to parameterise pascal Units with the processor onto which they are to be mounted. Thus one will specify that a particular unit foo is to be loaded onto attached processors 1..3. One can then call the procedure bar in foo with the syntax
foo[2].bar(x,y,z)
denoting, run procedure bar on processor 2

If one specifies that calls to apu s must use call by value semantics then copying of the parameters to the adderess space of the apu by dma should be possible.

A procedure in an apu would run in parallel with the calling environment.
A function call to an apu would cause the calling environment to wait for the return value.

The parallelism model would then be based on calling procedures on several apus to initiate tasks and then doing function calls to get the results of the calculations back.