REPRESENTAÇÃO DE INSTRUÇÕES

CICLO DE INSTRUÇÃO
Primeiramente, o programa a ser executado precisa ser carregado (armazenado) na MP, o que é feito pelo Sistema Operacional, que também se encarrega de informar à UCP onde o programa começa. O Sistema Operacional faz isto "setando" o Contador de Instruções (isto é, colocando no CI o endereço da MP onde está localizada a primeira instrução daquele programa).
A partir daí se realiza o processamento automático, executando-se as instruções seqüencialmente uma a uma, o que é obtido através do incremento automático do CI.
Obs: Se o programa inclui uma instrução de desvio, o fluxo seqüencial pode ser alterado.
A UCP não diferencia um dado de uma instrução. A UCP não "executa" dados devido ao conteúdo do CI, que é incrementado pelo tamanho da instrução e fica sempre apontando para a próxima instrução. Mas se em um programa houver uma instrução de desvio para um endereço em que esteja contido um dado, a UCP interpretaria o valor binário do dado como se fosse o código de uma instrução, tentaria executar e o resultado seria imprevisível.

Ciclo de Instrução
1 - A UCP busca o código de operação na MP e armazena no Registrador de Instrução da UC
Fase: Busca da instrução - (Instruction Fetch) - ciclo de busca
RI <--- (CI)
Micro-operações:
- a UC lê o conteúdo do CI (endereço da próxima instrução ) e coloca o endereço no REM;
- a UC envia um sinal à memória de operação de leitura (memory read), via barramento de controle;
- a memória lê o endereço que está no REM, via barramento de endereços, e busca o conteúdo da célula referenciada;
- a memória coloca no RDM, via barramento de dados, o conteúdo da célula lida;
- a memória envia à UC, via barramento de controle, um sinal de "leitura concluída";
- a UC transfere o código de operação (o conteúdo do RDM) ao RI.

2 - A UC (decodificador de instruções) decodifica o Código de Operação.
Fase: Busca da instrução - (Instruction Fetch) - ciclo de busca
Micro-operações:
- o Decodificador de Instruções decodifica o opcode;
- o Decodificador de Instruções determina quantas células a instrução ocupa;
- a UC incrementa o CI para apontar para a próxima instrução: CI <--- (CI + n), onde n = nº de células que a instrução ocupa.
- a UC incrementa o REM para apontar para o operando: REM <--- (REM + 1);

3 - A UC busca (se houver) o(s) operando(s)
Fase: Busca de operandos (Operand Fetch) - ciclo de execução
RI <--- (Op)
Micro-operações:
- a UC envia um sinal à memória de operação de leitura (memory read), via barramento de controle;
- a memória lê o endereço que está no REM, via barramento de endereços, e busca o conteúdo da célula referenciada;
- a memória coloca no RDM, via barramento de dados, o conteúdo da célula lida;
- a memória envia à UC, via barramento de controle, um sinal de "leitura concluída";
- a UC transfere o operando (o conteúdo do RDM) ao RI.
* Se o operando é o próprio dado:
-- a UC transfere o dado (o conteúdo do RDM) ao ACC.
-- vai para operação 4; caso contrário:
* Se o operando é um ponteiro para onde o dado está armazenado:
-- a UC coloca no REM o endereço de onde o dado está armazenado;
-- a UC envia um sinal à memória de operação de leitura (memory read), via barramento de controle;
-- a memória lê o endereço que está no REM, via barramento de endereços, e busca o conteúdo da célula referenciada;
-- a memória coloca no RDM, via barramento de dados, o conteúdo da célula lida;
-- a memória envia à UC, via barramento de controle, um sinal de "leitura concluída";
-- a UC transfere o dado (o conteúdo do RDM) ao ACC;
-- vai para operação 4.

4 - A UC comanda a execução da instrução (a operação é executada sobre o dado).
Fase: Execução da instrução - ciclo de execução
- UAL executa a iinstrução.

5 - Se o programa tiver terminado, Para; senão, volta ao passo 1.

Exemplo 1:
Formato da Instrução de Máquina:

Conteúdo da Memória Principal:

MP

Nesta máquina, considere que o código de operação 2A significa LDA Op ==> ACC <--- (Op)
Obs.: A instrução do exercício LDA Op (LDA é um mnemônico para "load accumulator") significa "carrega no acumulador o conteúdo da posição de memória indicada no operando".

Solução:
Neste exemplo:
O CI tem 8 bits porque o operando tem 8 bits; o mapa de memória também mostra isso, com os endereços ocupando 2 dígitos hexadecimais (cada dígito hexadecimal requer 4 bits).
A célula de memória tem 8 bits, conforme vemos pelo mapa de memória, em que os conteúdos das células ocupam 2 dígitos hexadecimais.
O RI tem 16 bits porque a instrução tem 16 bits.
ACC - não daria para assegurar porque depende do tamanho da palavra; vamos assumir 8 bits, de vez que como o operando, o opcode e a célula têm 8 bits, o RDM e o Acumulador provavelmente também terão 8 bits
A instrução LDA Op ocupará 2 células, logo o incremento do CI = n = 2

Vamos acompanhar o processamento da instrução LOAD (2A neste exemplo) => colocar o conteúdo do endereço indicado pelo operando no ACC (carrega dado no acumulador); T0, T1 e T2 representam os diversos estados dos registradores (nos respectivos tempos do ciclo de busca da instrução).
n=2 (2 acessos à MP para buscar instrução)

Obs.: usamos um x para indicar que o conteúdo de uma célula ou de parte da célula não importa ("don't care") e não é considerado (é desprezado) para a presente operação, podendo ser nulo ou então conter o resultado de uma operação anterior.

Exemplo 2:
Considerando a mesma máquina do exemplo anterior, qual seria o processamento da instrução
LDIA Op ==> ACC <--- ((Op))
Obs.: A instrução do exercício LDIA Op (LDIA é um mnemônico para "load accumulator indirect") significa "carrega no acumulador o conteúdo da posição de memória apontada pela posição indicada no operando". Portanto, a posição de memória indicada pelo Operando é um ponteiro para a posição onde está o dado e existe uma indireção. Esse assunto será tratado em detalhe na próxima seção - Modo de Endereçamento.

Exemplo 3:
Numa máquina de 2 operandos, a MP tem 256 células com 20 bits, o RDM tem 20 bits e cada instrução ocupa 1 célula. Em seu conjunto de instruções, o código binário 6 tem o seguinte significado:
6 => ADD Op1, Op2 ==> (Op1) <---- (Op1) + (Op2) - soma o conteúdo da posição de memória indicada em Op1 com o conteúdo da posição de memória indicada em Op2 e coloca o resultado na posição de memória indicada em Op1.
Mostre o conteúdo dos registradores da UCP e das posições de memória que se alterarem após a execução da instrução dada.

Mapa da memória:

 Solução:
A MP tem 256 células = 2⁸ células ----> REM = 8 bits ----> CI = 8 bits
Célula = 20 bits e 1 instrução = 20 bits
RDM = 20 bits e RI = 20 bits
Operando = 8 bits ---> 8 bits x 2 operandos = 16 bits (cada instrução tem 2 operandos); logo, o opcode tem 4 bits.
Cada instrução ocupa uma célula, logo n=1 (o incremento do CI será sempre 1).

CÁLCULO DO VALOR DO ACUMULADOR
03210
04594+
--------
077A1
Resp.: A posição de memória B2 será alterada para o valor 077A1. Nenhuma outra posição de memória é alterada.

Exemplo 4:
Máquina com Instruções de 3 operandos
Resolver a expressão: X = A * (B + C * D - E/F)

Conjunto de Instruções:
ADD X,A,B ===> (X) <--- (A) + (B) => soma conteúdo das posições de memória A e B e coloca o resultado em X
SUB A,B,X ===> (X) <--- (A) - (B) => subtrai conteúdo da posição de memória B da A e coloca o resultado em X
MULT A,B,X ===> (X) <--- (A) * (B) => multiplica conteúdo das posições de memória A e B e coloca o resultado em X
DIV A,B,X ===> (X) <--- (A) / (B) => divide conteúdo da posição de memória A pela B e coloca o resultado em X

Solução:
MULT C, D, X ----> (X) <--- (C) * (D)
DIV E, F, T ------> (T) <--- (E) / (F) (sendo T uma variável temporária - nenhuma variável deve ser sobrescrita)
ADD B, X, X ----> (X) <--- (B) + [(C) * (D)]
SUB X, T, X -----> (X) <--- (B) + [(C) * (D)] - [(E) / (F)]
MULT A, X, X ----> ((X) <--- (A) * {(B) + [(C) * (D)] - [(E) / (F)]}

Obs: o número de instruções é igual ao número de operações da expressão.

Exemplo 4:
Máquina com Instruções de 2 operandos
Resolver a expressão: X = A * (B + C * D - E/F)

Conjunto de Instruções:
ADD X,A ===> (X) <--- (X) + (A) ===> Soma o conteúdo de X e A e coloca o resultado em X
SUB X,A ===> (X) <--- (X) - (A)
MULT X,A ===> (X) <--- (X) * (A)
DIV X,A ===> (X) <--- (X) / (A)
MOV X,A ===> (X) <--- (A) ==> copia o conteúdo de A para X.

Obs.: observar que, ao não dispor do 3º operando (o qual indica uma terceira posição de memória, onde será colocado o resultado), o conteúdo do 1º operando é sobrescrito (portanto, é destruído) pela instrução, pois o resultado vai para ele; desta forma, é necessário uma outra instrução, para mover o conteúdo de uma posição de memória para outra posição, de forma a permitir salvar o conteúdo de uma variável e também mover o resultado, se necessário:

Solução:
MOV X, C ==> (X) <--- (C) (copiou o conteúdo de C para X)
MULT X, D ==> (X) <--- (C) * (D) (desta forma não se perde o conteúdo de C)
MOV T, E ==> (T) <--- (E) (copiou o conteúdo de E para uma variável temporária T)
DIV T, F ==> (T) <--- (E) / (F)
ADD X, B ==> (X) <--- (B) + [(C) * (D)]
SUB X, T ==> (X) <--- (B) + [(C) * (D)] - [(E) / (F)]
MULT X, A ==> (X) <--- (A) * {(B) + [(C) * (D)] - [(E) / (F)]}

OBS: o número de instruções é maior que o número de operações da expressão

Exemplo 5:
Máquina com Instruções de 1 operando
Resolver a expressão: X = A * (B + C * D - E/F)

Conjunto de Instruções:
ADD X ==> ACC <--- ACC + (X) ==> soma os conteúdos do acumulador e de X e coloca o resultado no acumulador.
SUB X ==> ACC <--- ACC - (X)
MPY X ==> ACC <--- ACC * (X)
DIV X ==> ACC <--- ACC / (X)
LOAD X ==> ACC <---- (X) ==> carrega o conteúdo de X no acumulador
STORE X ==> (X) <--- ACC ==> salva o conteúdo do acumulador na posição de memória X.

Obs.: Observe que, ao dispor de apenas 1 operando (portanto, teria a indicação de apenas 1 dado da operação), o 2º dado e o local onde será colocado o resultado são substituídos pelo ACUMULADOR que funciona como um OPERANDO IMPLÍCITO. O conteúdo do acumulador é sobrescrito (destruído) pela instrução, pois o resultado vai para ele; desta forma, são necessárias duas outras instruções, para carregar o conteúdo de uma posição de memória para o acumulador e para salvar o conteúdo do acumulador para outra posição de memória, de forma a permitir mover dados e o resultado da instrução, entre o acumulador e a a memória:

Solução:
LOAD E ==> ACC <--- (E) (carregou o conteúdo de E no acumulador)
DIV F ==> ACC <--- (E) / (F) (não se perde o conteúdo de E ou F)
STORE X ==> (X) <--- (E) / (F) (salvou o conteúdo do acumulador em X)
LOAD C ==> ACC <--- (C) (carregou o conteúdo de C no acumulador)
MULT D ==> ACC <--- (C) * (D) (não se perde o conteúdo de C ou D)
ADD B ==> ACC <--- (B) + [(C) * (D)]
SUB X ==> ACC <--- (B) + [(C) * (D)] - [(E) / (F)]
MULT A ==> ACC <--- (A) * {(B) + [(C) * (D)] - [(E) / (F)]}
STORE X ==> (X) <--- (A) * {(B) + [(C) * (D)] - [(E) / (F)]} (salva o conteúdo do acumulador na posição de memória X)

OBS: o número de instruções é maior que o número de operações da expressão. Não foi necessário utilizar qualquer variável temporária.

Exercício 6
Compare os exemplos anteriores em relação ao tempo de execução, número de instruções e memória. Experimente resolver as expressões executando as instruções em ordem diferente, e seus efeitos em relação ao número de instruções e de variáveis temporárias usadas.

(Os exemplos 3, 4, 5 e 6 foram adaptados do livro Introdução à Organização Estruturada de Computadores - Mário A. Monteiro)

>