2.6. Exemplo de execução de um programa

Suponha que queiramos executar uma instrução de máquina que soma dois números que estão na memória e salve o resultado em outro endereço de memória. Para tal, vamos indicar que a memória (M) se comporta como um vetor (um array) e entre colchetes indicaremos o endereço do dado, ou da instrução. Sendo assim, a instrução que gostaríamos de executar seria:

200: M[100] = M[101] + M[102]

Nesse caso, vamos ler que no endereço 200 da memória há uma instrução que precisa somar o conteúdo do endereço 101, com o conteúdo do endereço 102 e salvar o resultado no endereço 100 da memória. Supondo que M[101] contenha o valor 10, e M[102] contenha o valor 20, ao final da execução, o endereço 100 de memória (M[100]) deverá conter o valor 30.

Como uma instrução como essa será executada depende de cada arquitetura. Aqui vamos utilizar uma abordagem que quebra as instruções em pequenos passos simples, que facilitam o trabalho de decodificação da CPU.

Sendo assim, esse programa seria transformado na seguinte sequência de instruções e executado.

PC = 200;

//Envia comando de leitura de instrução para a memória

IR <- (M[100] = M[101] + M[102]) // Busca instrução da memória

PC = PC + 1

//Instrução é passada do IR para a Unidade de Controle

A primeira ação seria realizar o Ciclo de Busca, visando trazer a instrução a ser executada da memória para o processador. O endereço da instrução (200) seria passado para o PC e um comando de leitura de instrução seria passado para a memória. Baseada no endereço trazido por PC, a memória localizaria a instrução e a enviaria para o processador, que a armazenaria no registrador IR. Antes de passar a instrução para a Unidade de Controle para dar início à execução, o registrador PC é atualizado para o próximo endereço de memória, no caso, 201.

O próximo passo será iniciar o Ciclo de Execução:

//O primeiro dado é trazido da memória para o registrador R1

MAR = 101

//Envia comando de leitura de dado para a memória

MBR <- 10

R1 = MBR    // valor lido da memória é passado para o registrador R1

Como os dados a serem operados estão também na memória, é antes necessário executar uma operação de Busca de Operando, ou Busca de Dado. O primeiro operando está no endereço 101. Sendo assim, o endereço 101 é passado para o registrador de endereço (MAR). Esse endereço é passado para a memória e é enviado um comando de leitura de dado. O conteúdo, o valor 10, é então localizado pela memória e enviado para o processador, que o armazena no registrador de dados (MBR). Como o MBR será utilizado nas próximas etapas de execução, seu conteúdo é salvo em um registrador de propósito específico, o R1.

Em seguida, a Unidade de Controle passa para a busca do segundo operando, contido no endereço 102:

//O segundo dado é trazido da memória para o registrador R1

MAR = 102

//Envia comando de leitura de dado para a memória

MBR <- 20

R2 = MBR   // valor lido da memória é passado para o registrador R2

Essa etapa ainda faz parte do Ciclo de Execução, e também diz respeito à uma Busca de Dado. A busca é mesma do passo anterior, mas agora o endereço buscado é o 102, e o conteúdo é o 20, que é repassado para o registrador R2.

O próximo passo do Ciclo de Execução é executar a operação aritmética propriamente dita. Isso geralmente é feito entre registradores de propósito geral, por serem mais rápidos do que se fosse tratar dados da memória. Os conteúdos de R1 e R2 são somados e armazenados em R3:

R3 = R1 + R2

Para finalizar o processo, o resultado deve ser armazenado de volta na memória:

MAR = 100   // Endereço é passado para MAR

MBR = R3    // Resultado da operação é passado para MBR

// Comando de escrita é passado para a memória

M[100] <- 30    // Endereço 100 da memória recebe o valor 30

Para isso ser realizado, é preciso executar uma operação de escrita na memória. O endereço 100 é então passado para MAR e o resultado da operação, salvo em R3 é passado para MBR. Quando o comando de escrita é enviado pela Unidade de Controle para a memória, ela lê o endereço 100 pelo Barramento de Endereço e o valor 30 pelo Barramento de Dados e salva, então, o valor 30 no endereço 100.

Com isso a operação é finalizada. Essa operação foi executada em aproximadamente 14 passos. Esse valor é aproximado porque alguns deles são apenas o envio de sinal para a memória, e isso geralmente é feito em paralelo com o passo seguinte. Se cada passo for executado dentro de uma batida do relógio (ou ciclo de clock), teremos 14 ciclos de clock para uma única instrução. Mas perceba que o acesso à memória é sempre mais lento do que a execução do processador. Se cada acesso à memória levar 3 ciclos de clock, teremos um total de 20 ciclos de clock.

[Nota]

Apenas uma memória tipo Cache poderia ser acessada com apenas 3 ciclos de clock. Uma memória principal convencional precisa de entre 10 e 15 ciclos de clock para ser lida. Depende de sua tecnologia (e preço!).

Parece bastante, mas algumas instruções podem levar muito mais ciclos do que isso, como operações com Ponto Flutuante (números reais), ou de acesso a um periférico, como o disco rígido. Isso depende muito de como o projeto do computador é elaborado.

Apesar do computador parecer pouco efetivo na execução de uma simples soma, como ele executa numa frequência de clock muito alta, ele acaba executando muitas operações por segundo. Então, utilizar apenas a frequência de clock como medida de desempenho não é uma boa ideia. O mais utilizado é medir a quantidade de operações aritméticas que o processador é capaz de executar por segundo. Hoje em dia um computador pessoal está na escala dos alguns Milhões de Instruções por Segundo (ou MIPS). Mais a seguir vamos estudar como essas e outras medidas de desempenho podem ser calculadas.

[Nota]O que vem por aí

Até o momento vimos como um processador básico trabalha. Nas próximas seções deste capítulo vamos ver como o desempenho pode ser aumentado, ainda mais, aumentando adicionando técnicas avançadas de execução paralela e de análise de programas.