Originally posted by Bobboau
but you get paralel processing, while the PPU is multiplying a half dozen matricies the game can already be sending the polygon data off to the graphics card, the PPU can send it's result to the graphics card when it gets done, and by this time the program has sent another matrix stack to the PPU.
That depends on the amount of data being sent; it's unlikely at the moment to be enough to cause a problem (with the exception of gfx cards; the XBox and GC both have the GPU rather than CPU responsible for the data bus because of that IIRC), but I can't help but wonder how easy it would be to maintain control if you keep parallelizing that.
And also the concurrency issue; what if the physics code is modifying the exact same co-ordinate or geometry values being manipulated by the GPU or CPU? How easy is it to maintain global coherence over shared data (and does that actually matter in real terms or not?)
Originally posted by Bobboau
abstraction layers don't sap performence unless built stupidly, FS's abstraction layer is just as fast as calling the API specific functions directly.
Ah, but i'm talking about high-level hardware abstraction here; specifically, that would hide the hardware access details in order to allow
cheap (in cost) programming - and also to ensure you don't need to have a dedicated physics processor when running it, for example.
There might also be a side issue of contention between the parallel processing - firstly if you have multiple pipelines you need to balance, and also if you have data consistency within them (also maybe if you need to share data between them).....basically if you need to synch complex processing and data management tasks between multiple parallel processes/threads, you'd either have to implement code for handling the hardware combinations, or consider an abstraction layer.
And as you move from specific code->abstraction you lose performance
control, because more of your hardware level optimization is associated with the abstraction code.
The main thing, though, is the increase of hardware combinations - how will developers handle it, and what will the cost in terms of dev time? That'll be key to adoption on PCs, IMO.