Eu tenho alguns aspectos adicionais aqui:
Considere que a operação "a = b / c" x86 implementaria isso como
mov eax,b
xor edx,edx
div dword ptr c
mov a,eax
Como um bônus adicional da instrução div, edx conterá o restante.
Um processador RISC exigiria primeiro carregar os endereços de bec, carregar bec da memória para os registradores, fazer a divisão e carregar o endereço de a e então armazenar o resultado. Dst, sintaxe src:
mov r5,addr b
mov r5,[r5]
mov r6,addr c
mov r6,[r6]
div r7,r5,r6
mov r5,addr a
mov [r5],r7
Aqui normalmente não haverá resto.
Se alguma variável deve ser carregada através de ponteiros, ambas as sequências podem se tornar mais longas, embora isso seja menos possível para o RISC, porque ele pode ter um ou mais ponteiros já carregados em outro registro. x86 tem menos registros, portanto, a probabilidade de o ponteiro estar em um deles é menor.
Prós e contras:
As instruções RISC podem ser misturadas com o código circundante para melhorar o agendamento da instrução, isso é menos possível com o x86 que, em vez disso, faz este trabalho (mais ou menos bem, dependendo da sequência) dentro da própria CPU. A sequência RISC acima normalmente terá 28 bytes de comprimento (7 instruções de 32 bits / 4 bytes de largura cada) em uma arquitetura de 32 bits. Isso fará com que a memória fora do chip funcione mais ao buscar as instruções (sete buscas). A sequência x86 mais densa contém menos instruções e, embora suas larguras variem, você provavelmente está vendo uma média de 4 bytes / instrução lá também. Mesmo se você tiver caches de instrução para acelerar isso, sete buscas significa que você terá um déficit de três em outro lugar para compensar em comparação com o x86.
A arquitetura x86 com menos registros para salvar / restaurar significa que provavelmente fará mudanças de thread e tratará interrupções mais rápido do que RISC. Mais registros para salvar e restaurar requerem mais espaço de pilha de RAM temporário para fazer interrupções e mais espaço de pilha permanente para armazenar estados de thread. Esses aspectos devem tornar o x86 um candidato melhor para executar RTOS puro.
Em uma nota mais pessoal, acho mais difícil escrever um assembly RISC do que x86. Eu resolvo isso escrevendo a rotina RISC em C, compilando e modificando o código gerado. Isso é mais eficiente do ponto de vista de produção de código e provavelmente menos eficiente do ponto de vista de execução. Todos esses 32 registros para acompanhar. Com x86 é o contrário: 6-8 registros com nomes "reais" tornam o problema mais gerenciável e instila mais confiança de que o código produzido funcionará conforme o esperado.
Feio? Isso está nos olhos de quem vê. Eu prefiro "diferente".