Articles

O que é acumulador?


Melhor resposta

Um acumulador é um objeto que rastreia incrementalmente as somas, contagens que são necessárias para o cálculo eficiente das médias, desvio padrão, minutos , max etc ,. em vez de ter que recalcular todas as vezes.

Resposta

Deixe-me refinar sua pergunta um pouco: Qual é a diferença entre uma arquitetura de conjunto de instruções de acumulador e uma arquitetura de conjunto de instruções de registro de propósito geral?

Estes representam dois pontos no espaço de design para conjuntos de instruções. Considere o que uma instrução CPU precisa fazer. Por enquanto, basta considerar as instruções compute . No mínimo, ele precisa fornecer as seguintes informações:

  • Qual cálculo realizar (adicionar, subtrair, deslocar, comparar)
  • Em quais valores realizar o cálculo ( as entradas para o cálculo)
  • Onde colocar o resultado (a saída do cálculo)

Por exemplo, se eu escrevesse a declaração do programa de alto nível X = Y + Z, você precisa dizer ao processador para buscar os valores mantidos em Y e Z, adicioná-los e gravar o resultado em X.

Em uma arquitetura de acumulador, a maioria as instruções de computação operam em um registro especial denominado acumulador. A maioria das operações, portanto, tem o acumulador como um argumento implícito para a instrução. O acumulador fornece uma entrada para a instrução, recebe a saída da instrução ou ambos. Para executar X = Y + Z em uma máquina baseada em acumulador, a sequência de instruções seria mais ou menos assim:

  • Carregar Y no acumulador
  • Adicione Z ao acumulador
  • Armazene o acumulador a X

Se eu tivesse uma expressão mais complexa, como “I = J + K + L + M + N + O “, a sequência pode ser parecida com esta:

  • Carregar J no acumulador
  • Adicionar K ao acumulador
  • Adicionar L ao acumulador
  • Adicione M ao acumulador
  • Adicione N ao acumulador
  • Adicione O ao acumulador
  • Armazene o acumulador a I

Como a maioria das operações envolve o acumulador, você não precisa dedicar nenhum opcode bits para especificá-lo. Como mencionei antes, o acumulador é implícito . Além disso, na própria máquina, o acumulador pode ser embutido na própria unidade aritmética, simplificando o hardware.

Em uma arquitetura de registro de uso geral, instrução de computação s recebem vários argumentos para especificar de quais registros ler os valores. Isso os torna mais flexíveis. Porém, a flexibilidade tem um custo: você precisa de mais bits de opcode para especificar em quais registradores operar e precisa fornecer caminhos para todos esses registradores para a unidade aritmética.

Para as expressões de exemplo acima , o código acaba não parecendo muito diferente:

  • Carregue Y no registro R0
  • Carregue Z no registro R1
  • Adicione R0 ao R1, colocando o resultado em R2
  • Armazene R2 em X

Máquinas de registro de propósito geral começam a mostrar uma vantagem quando você pode manter valores em registros em muitas operações. Por exemplo, suponha que eu queira executar este programa um pouco mais complicado:

X = A + B

Y = A - B

Em uma máquina acumuladora, eu teria que recarregar A e B para ambas as operações. Em uma máquina de uso geral, eu carregaria A e B apenas uma vez.

Em máquinas de registro de uso geral, também existem várias variedades: (Esta lista não é exaustiva; também, algumas arquiteturas combinam esses conceitos. )

  • Memória de registro: Um operando vem de um registrador e um operando vem da memória.
  • Register-Register, 2-address: Ambos os operandos vêm de registradores, mas o resultado deve sobrescrever uma das entradas.
  • Register-Register, 3-address: Ambos os operandos vêm de registradores, e o resultado pode ir para seu próprio registrador.

O processador x86, por exemplo, é uma máquina de registrador-memória que também oferece instruções de registrador-registrador de 2 endereços. A maioria das máquinas RISC são máquinas de registro-registro de 3 endereços, com instruções de carregamento / armazenamento separadas. Ambos são máquinas de registro de uso geral.

Compare-os com o 6502 , que é uma máquina acumuladora. A maior parte da aritmética (adição, subtração, rotação e deslocamento) opera no registrador A. Os outros dois registradores, X e Y, suportam apenas incremento, decremento e comparação; eles são usados ​​principalmente para indexar memória e contadores de loop.

Um terceiro tipo de arquitetura que você não mencionou é a arquitetura de pilha . Uma arquitetura de pilha é semelhante a uma arquitetura de acumulador em que toda a computação é focada em um único ponto. A diferença é que uma arquitetura de pilha sempre lê seus argumentos de uma pilha e sempre coloca seus resultados na pilha.Ambas as entradas e as saídas de uma instrução de computação estão implícitas. Outras instruções, então, precisam gerenciar empurrar e retirar valores da pilha.

Você não encontra muitas arquiteturas de pilha em chips reais. Mas, elas são populares em interpretadores (bytecode Java, por exemplo , ou FORTH), e em certas calculadoras, como as calculadoras baseadas em RPN da HP.

Deixe uma resposta

O seu endereço de email não será publicado. Campos obrigatórios marcados com *