18 Feb 2016 16:29
|As some may know, the Apollo core is a superscalar 68k processor as was the 68060. "Superscalar" means that the processor can schedule more than one instruction per cycle. Under some circumstances the 68060 could schedule two simple instructions in one cycle where the 68040 had to execute the two instructions one after the other which then took two cycles.|
A typical pair of instructions that can be executed on a superscalar processor such as the 68060 requires the instructions to be scheduled in parallel to be independent. This means the result of the first instruction must not be used in the subsequent instruction:
The 68060 can execute these two instructions in the same cycle and so can the Apollo. But the Apollo core has many advantages over the 68060 which is also why it is faster than the 68060 when running at the same clock rate.
As already mentioned above, the Apollo core is also superscalar. However, it can execute a much higher variety of instruction in its different pipelines than the 68060. Only a few complex instructions such as DIV and MOVEM are always executed in the first pipeline. Already this feature alone means that far more combinations of two independent instructions can be scheduled in the same cycle on Apollo core as compared to the 68060.
But the Apollo core can also execute some instruction pairs in parallel that the 68060 cannot. This is called "Instruction Bonding". By bonding two instructions, the Apollo core can execute some combinations of dependent instructions in parallel on two of its pipelines. One example:
This updates two registers, d1 and d2 (C syntax: d1 = 1234; d2 += d1;) which cannot be done by the instruction fusing explained in another thread which will execute two instructions as one in a single pipeline. Fusing instructions requires both instructions to operate on the same destination register and thus can be executed as one instruction in one pipeline. Bonding instructions, on the other hand, updates two different destination registers and therefore will be executed by two pipelines. However, a traditional superscalar processor such as the 68060 could not do this as the two instructions are dependent on each other.
Using instruction fusing and instruction bonding in addition to normal superscalar execution the Apollo core can execute two instructions in parallel more often than a 68060 could. This is one of the reasons why the Apollo core is faster than even higher clocked 68060 processors.
P.S.: if you don't understand this explanation, feel free to ask (in this forum)