DIFERENÇAS ENTRE ARQUITETURAS RISC E CISC
A transição de CISC para RISC foi uma mudança radical na arquitetura. Os conjuntos de instruções foram mudados, sacrificando a compatibilidade binária para o desempenho. Reduzindo o conjunto de instruções, o processador cabia em um chip menor que permitia que os desenvolvedores aumentassem a velocidade do clock. Além disso, o processador poderia ser pipelineado e uma unidade de controle microcodificada tornou-se desnecessária. RISC, "resolve os casos comuns mais rápidos", era o princípio que conduziu a um aumento impressionante da performance comparado com os processadores CISC. Os processadores mais adiantados tais como IBM RT, SPARCv7 e MIPS R2000 aderiram completamente ao princípio fundamental RISC. Entretanto, enquanto a tecnologia avançava para aumentar os tamanhos dos dados e aumentar a densidade do transistor, os desenvolvedores do processador RISC começaram a considerar maneiras de usar esse espaço novo do chip. Alguns dos usos desse espaço incluíram:
Registros adicionais;
On-chip chaces que são cronometrados tão rapidamente quanto o processador;
Unidades funcionais adicionais para execução superescalar;
Instruções adicionais não-RISC (mais rápidas);
On-chip aceitando operações de ponto flutuante;
Profundidade aumentada no Pipelined.
Assim, a geração atual de processadores de desempenho elevado carrega poucas características dos processadores que iniciaram a revolução RISC.
Arquiteturas RISC
Nas arquiteturas RISC, a grande maioria dos processadores possuem 32 registros genéricos de 32 bits – para representar valores inteiros e/ou endereços de memória – para além de 32 registros de 32 bits para representação de valores em vírgula flutuante. Estes registros são considerados de uso genérico e podem ser usados explicitamente por qualquer instrução que aceda operandos de registros, com exceção de um registro que contenha o valor ZERO, que não pode ser alterado (só de leitura). Ainda visível ao programador está sempre também o apontador para a próxima instrução, o instruction pointer ou program counter.
Arquiteturas CISC
A existência de um grande número de registros nas arquiteturas RISC, aliado à evolução da tecnologia dos compiladores dos últimos anos (em especial, na geração de código), vem permitindo representar a maioria das variáveis escalares diretamente em registro, não havendo necessidade de recorrer com tanta freqüência à memória. Esta organização não foi contudo economicamente viável nas gerações anteriores de microprocessadores, com destaque para a família da Motorola (M680x0) e, ainda mais antiga, a família da Intel (ix86). Estes processadores dispunham de um menor nº de registros e , consequentemente, uma diferente organização que suportasse eficientemente diversos mecanismos de acesso à memória.
No caso da família M680x0, o programador tinha disponível dois bancos de 8 registros genéricos de 32 bits: um para dados (D) e outro para apontadores para a memória (A), suportando este último banco um variado leque de modos de endereçamento à memória. Apenas um dos registros (A7) é usado implicitamente em certas operações de manuseamento da stack.
A família Intel é mais complicada, por não Ter variadamente registros de uso genérico. A arquitetura de base dispõe efetivamente de 4 registros para conter operandos aritméticos (A, B, C e D), mais 4 para trabalhar com apontadores para a memória (BP, SP, DI e SI) e outros 4 para lidar com uma memória segmentada (CS, DS, SS e ES; a única maneira de uma arquitetura de 16 bits poder aceder a mais de 64K células de memória). Cada um destes registros não pode ser considerado de uso genérico, pois quase todos eles são usados implicitamente (isto é, sem o programador explicitar o seu uso) em várias instruções (por exemplo, os registros A e D funcionam de acumuladores em operações de multiplicação e divisão, enquanto o registro C é usado implicitamente como variável de contagem em instruções de controle de ciclos). A situação complica-se ainda mais com a variação da dimensão dos registros na mesma família (de registros de 16 bits no i286 para registros de 32 bits no i386), pois o formato de instrução foi concebido para distinguir apenas operandos de 8 e de 16 bits, e um bit bastava; para garantir compatibilidade ao longo de toda a arquitetura, os novos processadores têm de distinguir operandos de 8, 16 e 32 bits, usando o mesmo formato de instrução.
Diferenças entre RISC e CISC
Todos os processadores dispõem de instruções de salto "de ida e volta", normalmente designados de instruções de chamada de sub-rotinas: nestas, para além de se alterar o conteúdo do registro PC como qualquer instrução de salto, primeiro guarda-se o endereço de instrução que segue a instrução de salto ( e que se encontra no PC); nas arquiteturas CISC este valor é normalmente guardado na stack; nas arquiteturas RISC esse valor é normalmente guardado num registro.
Conjunto de instruções de um processador RISC
O conjunto de instruções que cada processador suporta é bastante variado. Contudo é possível identificar e caracterizar grupos de instruções que se encontram presentes em qualquer arquitetura.
Para transferência de informação: integram este grupo as instruções que transferem informação entre registros e a memória (load/store), entre registros (simulado no Assembler do MIPS, e implementando com uma soma com o registro 0), diretamente entre posições de memória (suportado por exemplo, no M680x0, mas não disponível em qualquer arquitetura RISC), ou entre registros e a stack, com incremento/decremento automático do sp (disponível em qualquer arquitetura CISC, mas incomum em arquiteturas RISC);
Operações aritméticas, lógicas, ...: soma, subtração e multiplicação com inteiros e fp, e operações lógicas AND, OR, NOT, ShiftLeft/Right são as mais comuns; alguns processadores suportam ainda a divisão, quer diretamente por hardware, quer por microprogramação.
Acesso a operandos em memória em CISC e RISC
Uma das conseqüências do fato das arquiteturas CISC disporem de um menor número de registros é a alocação das variáveis escalares, em regra, a posições de memória, enquanto que nas arquiteturas RISC, a regra era a alocação a registros. Atendendo ao modelo de programação estruturada tão em voga nos anos 70, ao fato da maioria das variáveis escalares serem locais a um dado procedimento, e à necessidade do modelo de programação ter de suportar o aninhamento e recursividade de procedimentos, as arquiteturas CISC necessitavam de um leque rico de modos de endereçamento à memória, para reduzir o gap semântico entre uma HLL e a linguagem máquina.
Resume-se aqui, as principais diferenças entre as arquiteturas CISC e RISC, nas facilidades de acesso a operandos que se encontram em memória:
CISC: grande riqueza na especificação de modos de endereçamento; exemplo do i86: modo absoluto; por registro indireto –(R), - (SP), (SP)+; por registro base –(Rb)+desloc8,16,32, (Rb)+(R), (Rb)+desloc8,16,32; com acessos indiretos à memória, isto é, com apontadores para as variáveis sem memória armazenados em células de memória.
RISC: apenas em operações load/store e apenas 1 ou 2 modos; exemplo do MIPS: apenas (R)+desloc16.
Operações lógicas e aritméticas em CISC e RISC
Duas grandes diferenças se fazem notar entre estes 2 modelos: na localização dos operandos neste tipo de operações, e o nº de operandos que é possível especificar em cada instrução. Resumindo o que foi visto anteriormente (complementando com exemplos na aula):
CISC: 1 ou mais operandos em memória (máx 1 no i86 e M68K); nem sempre se especificam 3 operandos (máx 2 no i86 eM68K).
RISC: operandos sempre em registros; 3 operandos especificados (1 dest, 2 fontes). O que é RISC?