| | | Factorization and Computing Quants |
In a first approach to parallelize programs we asume, that the algorithms used to realize some processing task can be - and are - chosen in a way, that very high factorization can be acchieved. The "main" program and all subroutines can be executed individually in any CPU on the array, because they fit into the (small) available memory of each. We also suppose, that each subroutine only has to process a very small amount of data as parameters and returns a very small amount of data as results. At runtime the subroutines and the parameters are packed together into a quant and sent as a messages to the array. They are transfered either as a block of data, or by reference to their location in the (yet to define) secondary storage. The quant is distributed as a decaying wave to the whole array, i.e. it is stored and replicated through the grid until it gets absorbed by one or more CPU. We will deal later with the implications of decay and absorbtion, as well as with details of the messaging process.
The originating CPU leaves it's fingerprint in the message, by which the result can be routed back through the grid. A CPU which decides to execute a quant, instead of replicating it is said to absorb it. During the execution of the respective code, further quants are eventually spawned to the grid from the CPU which absorbed the original quant during execution. As a result, the execution of a specific program results in many superposed waves of computing quants which dissapate back and forth trough the whole grid as computation advances.
| | | Factorization and Computing Quants |