Here is an idea:
- The computer program issue’s load and store requests to the memory system.
Instead of only specifieing the memory address, the computer program would also specifiy the instruction pointer.
The memory system fetches the memory located at the memory address and returns it but it also returns the instruction pointer.
Because the instruction pointer is returned, this allows the computer program to go back to the instruction that was “stalled” or “skipped”.
This would allow the computer program to issue memory requests, but not have to wait for them. The computer program would jump back to the instruction location once it’s memory
has been retrieved. This would allow the computer program to simply move on/go on with executing other instructions and potentially retrieving other memory locations.
^ All these instructions specify an memory address, but also specify the instruction pointer to main memory, and also specify a register where to load the memory into.
The question is now:
What to do with other instruction which depend on the registers to be “live” / “filled” with data.
Well perhaps these instructions could all check a “flag” inside the register.
If the register is “live” the instructions get executed. If the register is “dead” (/“stalled”) the instruction is skipped.
This would allow a programmer to program a lot of semi-parallel code which gets or gets not executed depending on if the memory came in…
The program would then simply jump back at appriorate times… when the memory comes in… like an interrupt handler or like an exception handler.
So this is probably a totally new instruction flow idea.
Finally if the memory loading takes so long that the program cannot do anything anymore then the programmer could issue a wait:
The processor would then either wait for all loads to complete or some other interrupts to occur.
So another way to describe this system would be a really short abstract way:
“An event driven memory system”.
(I also posted this on usenet ! )