Executando o Programa

O Descodificador e os Sinais de Controlo

Na Figura 17  os números mais pequenos junto das diversas linhas indicam o número de linhas de bit que essa linha pretende representar. As linhas que referem os sinais de controlo resultantes da descodificação dos Opcode, identificadas por números envolvidos em círculos amarelos, têm o significado que referimos de seguida. A referência ao tipo de traço que representa esses sinais quando ativos a 1, ativos a 0 ou inativos ( ativo ou inativo significa com ou sem relevância para a instrução) tem a ver com os gráficos das figuras que nos vão acompanhar nos diversos passos da execução do programa.

1. DEFPLI (2 bits) – Este sinal é ativo em todas as instruções. A linha que o representa estará a preto negrito sombreado (—) quando incrementa o contador (00) e a vermelho negrito sombreado (—) quando pretende induzir um salto ou carregamento em paralelo do contador (01,10,11).
2. DEFULA (2 bits) – Será representado a vermelho negrito sombreado (—) quando nessa instrução estiver em curso uma operação na ULA. Quando assim não for a sua representação é a vermelho fino (—).
3. MEMA (1 bit) – Será representado a vermelho negrito sombreado (—) quando ativo e a preto fino (—) quando inativo.
4. DEFA (1 bit) – Será representado a vermelho negrito sombreado (—) quando ativo a 1 , a preto negrito sombreado (—) quando ativo a 0  e a preto fino (—) quando inativo .
5. DEFB (1 bit) – Será representado da mesma forma que o anterior.
6. WR (1 bit) – Será representado a preto negrito sombreado (—) quando ativo e a vermelho fino (—) quando inativo.

Consideramos que, por ser o seu estado natural, aos valores 00 para DEFPLI (incrementa), 1 para WR (não escreve na MD) e 0 para MEMA (não escreve no RegA), quando esse for o seu estado, não faremos menção.

No Registador PI (Ponteiro da Instrução) temos algumas notações a fazer apoiadas na Figura 17a:

1. Linha superior – Contém o endereço na MI da instrução em execução.
2. Linha do meio – Contém o endereço na MI da instrução a executar no ciclo seguinte. Incrementada ou proveniente de um carregamento em paralelo (salto).
3. Linha inferior – Contém o endereço na MI a ser carregado em paralelo, se DEFPLI assim o definir.

As Instruções

Vamos verificar graficamente a forma como a máquina executa com 0 e 1, através dos sinais de seleção, as instruções que lhe demos em C e em Assembly, encaminhando em cada ciclo de clock, os valores lógicos  a partir dos Registadores sobre que atuarem e pelos circuitos que selecionarem, até às barreiras de fim de instrução, de novo os Registadores.

Em cada um dos gráficos poderemos visualizar os valores nos Registadores e na ULA bem como os circuitos intervenientes na UCP Op (operação máquina) referida.

1ª Instrução C

Em C atribui-se o valor 4 à constante simbólica N com a instrução.
#define N 4
O Assembly faz o mesmo com a diretiva
N EQU 4.

Assembly Linha 1 – Diretiva
N EQU 4.

O Assembler, perante esta diretiva, vai colocar esse valor 00000100 em todas as constantes das instruções máquina que façam referência a N, como se pode ver na posição 0 da MI na  Figura 18. Porque não gera código máquina, não há lugar a qualquer operação máquina.

2ª Instrução C

int fatorial = N;

Com esta instrução em C atribui-se o valor N à variável fatorial. Como já referimos na introdução que fizemos ao programa em C, numa instrução deste tipo o compilador cria um espaço em memória para essa variável, passa a identificá-la pela sua posição e guarda lá o seu valor. Assim, a esta instrução C correspondem em Assembly uma diretiva EQU e duas instruções.

Fctr EQU 100
em que se atribui o valor 100 à constante simbólica Fctr.
LD A,N
em que se carrega no RegA o valor da constante N.
LD [Fctr],A
em que se coloca no endereço [Fctr] da MD o valor no RegA, portanto o valor de N.

Assembly Linha 2 – Diretiva
Fctr EQU 100

Perante esta diretiva o Assembler vai colocar esse valor 01100100 em todas as constantes das instruções máquina que façam referência a fatorial, como se pode ver nas posições 1, 6 e 7 da MI na Figura 18. O nome fatorial que nós demos à variável em C, não tem direito a nome por parte da UCP. É tratada como uma posição na MD, a que é atribuído o endereço Fctr e é nomeada como um apontador [Fctr] que aponta para a posição da MD que conterá o valor de fatorial ao longo do cálculo do fatorial de N (4).

Esta diretiva Assembly não gera código máquina e portanto não lhe corresponde qualquer operação máquina.

Assembly Linha 4 – UCP Op 0
LD A,N

representada na Figura 18. A esta instrução Assembly corresponde a instrução  em código máquina
000000000100
e a Operação 0 da UCP.
O Registador PI aponta para o endereço 00000000 da MI, onde se encontra a instrução a executar.
É uma instrução do tipo LD A,Valor.
O Opcode correspondente é descodificado nos valores de sinais de controlo necessários para encaminhar e carregar no RegA a constante (00000100) definida na instrução. Concretamente, interessam a esta instrução:

• DEFB que é 0 e seleciona a constante na MI.
• DEFA que é 1 e seleciona a saída do DEMUX B, a constante neste caso.
• MEMA que é 1 e memoriza no RegA o valor de saída do DEMUX A, no nosso caso a constante.

Esta instrução escreve no RegA o valor de N indicado pela constante da instrução, (linha Azul) e incrementa o Registador PI (linha Preta) .

Este valor só vai ser mostrado na saída do RegA no gráfico da instrução seguinte, pois ele só lá é memorizado quando o clock cai e nós estamos a representar a situação com o clock em alta.

 Assembly Linha 5 – UCP Op 1
LD [Fctr],A

representada na Figura 19. A esta instrução Assembly corresponde a instrução  em código máquina
001001100100
e a Operação 1 da UCP
O Registador PI aponta agora para o endereço 00000001 da MI, onde se encontra a instrução a executar.
É uma instrução do tipo LD [endereço],A.
O Opcode desta instrução define WR como ativo (0), forçando a escrita do valor memorizado em RegA na posição da MD cujo endereço é definido pela constante.

Esta instrução transfere o valor em RegA para a MD (linha Azul) e incrementa o contador (linha Preta ).

Está cumprida a 2ª instrução C. Foi definido um espaço na MD para a variável fatorial e foi-lhe atribuído o valor N (4). Para a UCP passou a chamar-se [Fctr].

3ª instrução C

int temporário = N-1;

Com esta instrução em C atribui-se o valor N-1 à variável temporário. Pelas mesmas razões que referimos atrás, a esta instrução C correspondem em Assembly uma diretiva EQU e duas instruções .

Temp EQU 101
em que se atribui o valor 101 à constante simbólica Temp.
SUB 1
em que se subtrai 1 ao valor que se encontra em RegA. E é o valor N que lá se encontra, vindo da instrução anterior.
LD [Temp],A
em que se coloca no endereço [Temp] da MD o valor no RegA, portanto o valor de N-1.

Assembly Linha 3 – Diretiva
Temp EQU 100

O Assembler ao interpretar o Assembly, vai colocar o valor 01100101 em todas as constantes das instruções máquina que façam referência a Temporário, como se pode ver nas posições 3 e 8 da MI nas Figuras 18 ou 19. A variável temporário em C, passa a ser uma posição na MD, a que é atribuído o endereço Temp sendo nomeada como [Temp], um apontador para esse local.

Como diretiva Assembly EQU não lhe corresponde qualquer operação na máquina.

Assembly Linha 6 – UCP Op 2
SUB 1

representada na Figura 20. A esta instrução Assembly corresponde a instrução  em código máquina
010100000001
e a Operação 2 da UCP.
O Registador PI aponta agora para o endereço 00000001 da MI, onde se encontra a instrução a executar.
É uma instrução do tipo SUB valor.
O Opcode dá origem aos sinais de controlo:

• DEFB que é 0, selecionando  o valor da constante da instrução, que assim será o 2º operando da ULA.

  

• DEFA que é 0, selecionando o valor proveniente do resultado da subtração a efetuar na ULA.
• MEMA que é 1, memorizando no RegA o valor na sua entrada, o resultado da subtração.
• DEFULA que é 01, escolhendo a operação de  subtração na ULA.

O 1º operando da ULA vem do RegA, onde se encontra já memorizado o mesmo valor que em [Temp].

O 2º operando da ULA é a constante da instrução.

 Ambos se propagam para o interior da ULA onde a subtração é executada, ficando na sua saída o valor do resultado dessa operação, o qual por sua vez se propaga até ao RegA, onde será memorizado na queda do Clock.

Estamos, no caso desta instrução, perante uma operação máquina em que se cumprem várias acções: (Já vamos desfazer a confusão e fazer uma aproximação à realidade)

• Leitura da instrução na MI.
• Descodificação do Opcode da instrução.
• Subtração na ULA de 1 ao valor em RegA.
• Escrita do resultado no RegA.
• Incremento do Registador PI.

Em RegA fica memorizado o valor de temporário já decrementado.

Esta Instrução transfere o valor da constante para o 2º Op. da ULA (linha Violeta ), transfere o valor do RegA para o 1º Op da ULA (linha Verde  ), subtrai os dois valores  registando o resultado no RegA (linha Azul ) e incrementa o Registador PI (linha Preta  ).

Micro Operações (Micro-Ops ou μops)

Estas várias ações de que falámos e que correspondem a uma mesma instrução máquina e no nosso caso a uma mesma operação da UCP, vão ser designadas (cada uma delas) por micro operações ou micro-ops ou ainda μops numa UCP real. As μops são as operações mais básicas executadas pela UCP sobre os seus  registadores, na sequência da interpretação dos sinais de controlo resultantes da descodificação do Opcode. As μops são operações atómicas, isto é, não decomponíveis em quaisquer outras operações e a sua execução  corresponde a um ciclo de Clock ( o que não significa que o seu rssultado se obtenha em um ciclo de clock).

No caso da nossa UCP chamámos-lhe ações de um mesmo Opcode porque todas elas são executadas dentro do mesmo ciclo de clock e num circuito elementar fechado, como simplificação para o entendimento mais básico de uma UCP. Mas na realidade não é assim. Um Opcode é decomponível em várias μops ou operações máquina. Cada μop provavelmente correspondente a cada uma das ações referidas.

A associação que estamos a estabelecer agora entre as  μops e as tais ações vai servir para a  abordagem que vamos fazer de seguida num caso de estudo a uma UCP real. Aí desenvolveremos melhor esta questão.

Assembly Linha 7 – UCP Op 3
LD [Temp],A

representada na Figura 21. A esta instrução Assembly corresponde a instrução  em código máquina
001001100101
e a Operação 3 da UCP.
O Registador PI aponta agora para o endereço 00000011 (3) da MI, onde se encontra a instrução a executar.
É uma instrução do tipo LD [endereço],A.
O Opcode desta instrução define WR como ativo (0), permitindo assim a escrita do valor memorizado em RegA na posição da MD cujo endereço é definido pela constante da instrução.

Com esta instrução o valor da variável temporário foi guardado na posição [Temp] da MD. De salientar que este valor é igual a fatorial menos 1, portanto o próximo valor por que fatorial deve ser multiplicado neste cálculo.

Nesta instrução transfere-se o valor de RegA para a MD (linha Azul) e o Registador PI é incrementado  (linha Preta).

Está cumprida a 3ª instrução C. Foi definido outro espaço na MD para a variável temporário e foi-lhe atribuído o valor N-1 (3). Para a UCP passou a chamar-se [Temp].

4ª Instrução C

while (temporário ≥ 2){
fatorial = fatorial*temporário;
temporário –;}

A esta instrução C correspondem as instruções Assembly que se encontram no corpo iterativo do programa, isto é

SUB 1
LD [Temp],A
CP 2
JPM Fim
MUL [Fctr]
LD [Fctr],A
LD A,[Temp]
JP Repete

A correspondência entre C e Assembly não é possível fazer-se entre blocos de instruções. Depende do compilador e neste caso da forma como a execução em Assembly foi concebida.

As duas primeiras instruções deste ciclo repetitivo Assembly deveriam aparecer no fim do ciclo para que coincidissem com a instrução C.  Mas elas acabaram de ser executadas no cumprimento de outra instrução C.

Em Assembly poderíamos de novo ter incluído estas instruções no fim do ciclo e definir  o início do ciclo (Repete) para a linha com a instrução CP 2. Obteríamos o mesmo efeito, teríamos a correspondência entre blocos de instruções e ficaríamos todos muito felizes. Mas estaríamos a repetir instruções Assembly desnecessariamente, o que não nos parece ser correto em termos do programa Assembly. Assim, essas duas instruções Assembly fazem parte deste ciclo iterativo, estão já executadas nesta 1ª iteração e definimos a etiqueta Repete para a linha Assembly  SUB 1, efetivamente a primeira linha do ciclo iterativo Assembly.

A 1ª operação máquina desta 1ª iteração vai começar após as já executadas duas primeiras instruções do ciclo iterativo, isto é, em CP 2.

Mas no artigo seguinte, pois este já vai longo.