External PC processors

I had this ideea thinking about modern graphics cards and how they have so much computing power but which remains unused a lot of the time. So why not create PCI processor+memory cards that you can plug in into your PCI slots, and use them to do parallel processing (besides using normal CPUs) in any regular PC.

They would just come with their own memory onboard, technically they would should not be harder to manufacture then a graphic card (for example at speeds of a few hundred Mhz and 64-128 Mb RAM they should cost a farely small amount, comparable to, or less then, a normal graphics card). The memory on the board would be mapped into the adress space of the process using it, so programs would simply write code into that memory, and then use a specialised control API (let's name it External Processor Api, EPA) which should ideally be a standard, used for any tipe of compatible processor, and with ports across the existing OSs. The API would most likely be some DLL or equivalent which would interface with the manufacturer's driver for the card, similar to what OpenGL for example does for graphic cards.

Sketch for a simple API:
GetProcessorInfo(processordata *data) //get some processor info such as memory size, processor id, number of flags if implemented (see below), other capabilities,etc..
ExectueCode(void *code) //adress of memory-mapped code to execute
SetSignalFlag(int)
ClearSignalFlag(int)
ReadSignalFlag(int) //sets,clears,reads a signal, out of n signals the processor has.. used for sincronization and stuff
void *GetCurrentAdress() //adress of the program counter
IsRunning() //checks if the processor is running any code at the moment
StopCode() //stop program

Of course the running process would be able to simply read/write the memory of the plug in processor at any time since it's mapped into it's adress space, although that would probably cause slowdown, because of the memory access from the main CPU. Which is why i used the flag ideea, and have 2 separate memories with a separate memory controller on the board. A tipical program would load code&data into the board memory, run and when processing is finished (= one of the flags is set), retrieve the results. Thus only a limited number of memory "syncronizations" between the board and the main PC memory would occur. The operation would be asyncronous/parallel.

As you can see i haven't defined the type of processor that would be on the board. It could be general purpose (even i386 compatible), it oculd be very specialised (for math processing, engeneering, etc..), it could be some hardware implementation of a VM, it could just be for testing technology, it could be an emulation of old processor (Z80, etc...). It could even be a porcessor that does something additional to just giving results back, as in having some ouput on the back of the card which can be used for different purposes such as automation (where it would probably most useful in practice, since you could still use a PC to control the process, yet have the software run realtime, because it dosen't compete with the other PC processes for time). All this would be handled transparantely by the usage of the generalised API, which communicates with the specific manufacturer's low-level driver. Applications need only query the processor's type and capabilities to see if it's what they require. Also you could have more then one card installed at the same time...