Memory constraints. CISCs benefit is reduced instruction set size. Let's take multiplication as an example. It consumes less memory to use a single multiplication instruction than it is to construct that same multiplication using additions and shifts. Also, it's likely to be faster as it's executed in "hardware".
To illustrate using multiplication. Here is a multiplication routine
written in 6502 assembly language (the 6502 does not have a multiplication instruction):
Code:
;32 bit multiply with 64 bit product
MULTIPLY: lda #$00
sta PROD+4 ;Clear upper half of
sta PROD+5 ;product
sta PROD+6
sta PROD+7
ldx #$20 ;Set binary count to 32
SHIFT_R: lsr MULR+3 ;Shift multiplyer right
ror MULR+2
ror MULR+1
ror MULR
bcc ROTATE_R ;Go rotate right if c = 0
lda PROD+4 ;Get upper half of product
clc ; and add multiplicand to
adc MULND ; it
sta PROD+4
lda PROD+5
adc MULND+1
sta PROD+5
lda PROD+6
adc MULND+2
sta PROD+6
lda PROD+7
adc MULND+3
ROTATE_R: ror a ;Rotate partial product
sta PROD+7 ; right
ror PROD+6
ror PROD+5
ror PROD+4
ror PROD+3
ror PROD+2
ror PROD+1
ror PROD
dex ;Decrement bit count and
bne SHIFT_R ; loop until 32 bits are
clc ; done
lda MULXP1 ;Add dps and put sum in MULXP2
adc MULXP2
sta MULXP2
rts
Using CISC, assuming the processor has a multiplication instruction, one could merely write:
Code:
mul R1, R2 ; Multiply the values of R1 and R2
Note: The CISC instruction is hypothetical and is intended for illustrative purposes only.
As you can see the CISC code is much, much smaller. As for execution time it depends on how quickly a processor can execute all of the instructions used to build the multiplication routine versus the time taken to execute a single multiplication instruction.
The concept of RISC is each instruction can be executed very quickly and therefore the sum to execute all of them would be less than that of a single multiplication instruction. For CISC the idea is that the built in MUL op code would execute faster than a bunch of smaller op codes. However not all processor instructions are actually hardwired. They are built upon microcode which is, for this discussion, a small program within the processor itself.
Once again the 80/20 rule can be invoked. RISC designers found that applications primarily (80%) consist of a small number of frequently used instructions and optimized for them. The other 20% could, as the multiplication example above shows, be built from those instructions.
HTH
www.guru3d.com
