Lógica Booleana
Cada dispositivo digital, seja um computador pessoal, um telefone celular ou um
roteador de rede, é baseado em uma família de chips projetados para armazenar e
processar informação. Embora estes chips tenham diferentes formas, são feitos dos
mesmos blocos básicos: as portas logicas elementares. Estas podem ser
implementadas fisicamente de muitos materiais diferentes e tecnologias de
fabricação, mas seu comportamento do ponto de vista lógico é consistente em todos
os dispositivos que equipam. Neste capítulo se partirá de uma porta lógica primitiva –
a porta NAND – para se construir todas as outras portas lógicas a partir dela. O
resultado será uma família de portas que serão usadas futuramente para a construção
de um microprocessador e chips de armazenamento diversos. Isto será feito nos
capítulos 2 e 3 respectivamente.
Todos os capítulos do livro relacionados ao hardware, incluso este, tem a mesma
estrutura. Cada capítulo foca em uma tarefa bem definida, designado para construir ou
integrar uma certa família de chips. Os conhecimentos prévios necessários para
realizar tal tarefa são providos pela seção de conceitos preliminares. A próxima seção
provê uma completa especificação das abstrações dos chips, ou seja, os vários
resultados que devem entregar, de uma forma ou de outra. Tendo apresentado o que
é cada chip, a seção subsequente chamada implementação propõe guiar e oferecer
dicas sobre o como implementar cada chip. A seção perspectivas comenta
conclusivamente acerca de tópicos importantes não discutidos anteriormente. Cada
capítulo termina com uma seção técnica intitulada projeto. Esta seção dá instruções
passo a passo para os chips a serem construídos em um computador pessoal, usando o
simulador de hardware fornecido.
Este é o primeiro capítulo abordando hardware do projeto, por isso a seção de
conceitos preliminares é particularmente longo, pois abrange seções especiais a
respeito da descrição de hardware e das ferramentas de simulação a serem
empregadas.
Conceitos Preliminares
Este capítulo se volta para a construção de uma família de chips simples chamados de
portas booleanas. Desde que tais portas são implementações das funções booleanas,
será dado um breve tratamento de álgebra correspondente. Será mostrado também
como portas booleanas que implementam funções booleanas simples podem ser
interconectadas a fim de produzir chips ou funcionalidades mais complexas. Concluir-
se-á esta seção com uma descrição de como o design de hardware é feito na prática,
usando ferramentas de simulação de software.
Álgebra de Boole
A álgebra de Boole lida com valores binários, que podem ser tratados como dois
estados opostos, tais como verdadeiro e falso, sim e não, ligado e desligado, 1 e 0 e
assim por diante. Para efeito deste livro, será usado 0 e 1. Uma função booleana é uma
função que opera com entradas binárias para produzir saídas binárias. Desde que o
hardware de um computador é baseado na representação e manipulação de valores
binários, funções booleanas tem um papel central na especificação, construção e
otimização da arquitetura de hardware. Desta forma, a habilidade para formular e
analisar funções booleanas é o primeiro passo em direção à concepção de arquiteturas
computacionais.
A maneira mais simples de especificar funções booleanas é enumerar todos os valores
possíveis para as variáveis de entrada da função, com a correspondente saída
resultante. Isto é chamado de representação da função por Tabela Verdade, ilustrado
na Tabela 1.
Tabela 1 - Representação da Tabela Verdade de uma Função Exemplo
x y z f (x , y , z)
0 0 0 0
0 0 1 0
0 1 0 1
0 1 1 0
1 0 0 1
1 0 1 0
1 1 0 1
1 1 1 0
As primeiras três colunas da Tabela 1 enumera todos os possíveis valores binários das
variáveis de entrada da função. Para cada uma das 2n tuplas possíveis v 1 ⋯ v n (neste
caso com n=3), a última coluna dá o valor de f (v 1 … v n ).
Em adição à tabela verdade, uma função booleana pode ser especificada usando
operações booleanas sobre suas variáveis de entrada. As operações booleanas básicas
que são tipicamente usadas são “And” ( x And y é 1 exatamente quando ambos x e y
forem 1), “Or” ( x Or y é 1 exatamente quando tanto x ou y ou ambos forem 1) e
“Not” (Not x é 1 quando x for 0). Será usada uma notação aritmética comum para
designar tais operações: x ∙ y significa x And y , x + y denota x Or y e x representa Not
x.
Para ilustrar, a função definida pela Tabela 1 é equivalente a expressão booleana
f ( x , y , z )=(x+ y)∙ z . Desta forma, se desenvolvermos a expressão para
x=0 , y=1 , z=0, com y=1 temos x + y=1. Seguindo, tem-se 1 ∙0=1 ∙1=1. A completa
verificação da equivalência entre a expressão e a tabela verdade é obtida pelo teste de
cada uma das oito possibilidades de entrada combinadas, averiguando assim se
correspondem ao mesmo valor apresentado pela coluna mais à direita.
Cada função booleana pode ser expressa usando ao menos uma expressão booleana
no que é chamado de representação canônica. Começando com a função da tabela
verdade, voltar-se-á para todas as linhas da tabela no qual o valor de saída da função é
1. Para cada linha, será construído um termo formado pela operação And das variáveis
de entrada, negadas ou não, de acordo com o estado assumido por estas entradas na
linha respectiva. Por exemplo, se observada a terceira linha, onde o valor de saída é 1,
os valores das variáveis de entrada assumem x=0 , y=1 , z=0, a partir do qual
constrói-se o termo x ∙ y ∙ z . Seguindo o mesmo procedimento, ter-se-á os termos x yz
e xy zpara as linhas 5 e 7. Neste momento, se reunirmos tais termos através da
operação Or, obtém-se uma expressão booleana que equivale à tabela verdade dada.
Assim, a representação canônica da função booleana exemplificada é:
f ( x , y , z )=x y z + x yz+ xy z
Esta construção leva a seguinte conclusão: cada função booleana, não importando sua
complexidade, pode ser expressa usando três operadores booleanos: And, Or e Not.
Uma inspeção na Tabela 1 revela que o número de expressões booleanas que podem
n
ser definidas para n variáveis binárias é 22 . Por exemplo, as dezesseis funções
booleanas que podem ser obtidas por duas variáveis são listadas na Tabela 2. Estas
funções foram construídas sistematicamente pela enumeração de todas as 4 possíveis
combinações de valores binários, através das quatro colunas à direita. Cada função
tem um nome convencional que descrevem sua operação. Aqui estão alguns
exemplos: o nome da função Nor é uma simplificação de Not-Or, ou seja, pega-se Or
de x e y e posteriormente nega-se o resultado. A função Xor – simplificação para
eXclusive-Or – retorna 1 quando suas duas variáveis têm valores opostos na tabela
verdade. A função “Equivalence” retorna 1 quando as duas variáveis têm valores
idênticos na tabela verdade. A função If-x-then-y (também conhecida por x → y , ou x
implica em y) retorna 1 quando x é 0 ou quando ambos são 1. Demais funções são
autoexplicativas.
A função Nand (bem como a função Nor) possui uma importante propriedade teórica:
cada uma das operações And, Nor e Not podem ser construídas a partir dela e
somente dela (exemplo, x Or y = (x Nand x) Nand (y Nand y)). E desde que cada função
booleana pode ser construída destes operadores usando o método da representação
canônica, segue que cada função booleana pode ser construída apenas de operadores
Nand. Este resultado tem implicações práticas: uma vez que se tem à disposição um
dispositivo físico que implementa Nand, podem ser usadas copias deste, agregado das
devidas conexões, a fim de se implementar em hardware uma função booleana.
Tabela 2 - Todas as funções booleanas sob duas variáveis
x 0011
Função
y 0101
Constant 0 0 0000
And x∙ y 0001
x And Not y x∙ y 0010
x x 0011
Not x And y x∙ y 0100
y y 0101
Xor x∙ y+x∙ y 0110
Or x+ y 0111
Nor x+ y 1000
Equivalence x∙ y+x∙ y 1001
Not y y 1010
If y then x x+ y 1011
Not x x 1100
If x then y x+ y 1101
Nand x∙ y 1110
Constant 1 1 1111
Portas Lógicas
Uma porta é um dispositivo físico que implementa uma função booleana. Se uma
função booleana f opera sobre n variáveis e retorna m resultados binários (em todos
os exemplos dados, m=1), a porta que implementa f deve possuir n pinos de entrada
e m pinos de saída. Quando são colocados valores v 1 … v n nos pinos de entrada da
porta, a lógica desta (baseada em sua estrutura interna), computará f ( v 1 … v n ) e
exibirá sua saída. E como funções booleanas mais complexas podem ser expressas em
termos de funções mais simples, portas complexas são compostas de portas
elementares. A mais simples das portas é feita de componentes de chaveamento
discreto, conhecidos por transistores, rearranjado em conexões de certa topologia, a
fim de prover o efeito da funcionalidade global da porta.
Embora muitos computadores digitais de hoje usam eletricidade para representar e
transmitir dados binários de uma porta para outra, qualquer tecnologia alternativa que
envolva chaveamento e condução pode ser empregada. De fato, durante os últimos
cinquenta anos, pesquisadores construíram muitas implementações em hardware de
funções booleanas, incluindo mecanismos magnéticos, óticos, biológicos, hidráulicos e
pneumáticos. Atualmente, muitas portas são implementadas com transistores
grafados em silício, empacotados em chips. Neste livro será usado os termos chip e
porta de forma intercambiável, com uma tendência ao termo porta quando se
tratarem de chips mais simples.
A disponibilidade de outras opções tecnológicas de chaveamento, por outro lado,
mostra-nos que a álgebra de Boole pode ser usada para abstrair o comportamento de
quaisquer destas tecnologias. Isto implica que é possível se desconsiderar questões
como circuitos, chaveamento, alimentação, dentre outros, no desenvolvimento de
chips em particular, ou de uma arquitetura de computador, em geral. Desta forma, é
possível se voltar às questões meramente da álgebra booleana e da lógica das portas,
confiando no trabalho que físicos e engenheiros eletrônicos fizeram para assegurar sua
realização em hardware. Assim, uma porta primitiva pode ser vista como uma caixa
preta que implementa a operação lógica por trás de um sistema físico complexo que
realiza esta tarefa e sobre o qual não nos preocuparemos. Por isso, o designer de
hardware inicia sua atividade a partir destas portas primitivas, a fim de projetar
funcionalidades mais complicadas, pela interconexão destas, gerando portas
compostas.
Figura 1 - Notação simbólica padrão de algumas portas lógicas elementares
Figura 2 - Implementação de uma porta And de 3 entradas. O retângulo pontilhado à direita define a fronteira
conceitual da interface da porta
Desde que todas as portas lógicas têm a mesma semântica de entrada e saída (0s e 1s),
podem ser encadeadas, criando portas compostas de complexidade arbitrária. Por
exemplo, supondo que se deseja implementar uma função booleana And de três
entradas. Usando a álgebra booleana, pode-se iniciar pela observação da propriedade
a ∙ b ∙ c=(a ∙b)∙ c . Desta forma, pode-se usar esta propriedade para construir tal porta,
como mostrado na Figura 2.
A construção descrita na Figura 2 é um exemplo simples de uma lógica de porta,
também chamado de design lógico, que é a arte de interconectar portas de forma a
implementar funcionalidades mais complexas, levando à noção de porta composta.
Desde que portas compostas são por si só realizações de funções booleanas, sua
aparência externa (como o lado esquerdo da Figura 2) assemelham a uma porta
primitiva. Ao mesmo tempo, sua estrutura interna pode ser bem mais complexa.
Vê-se que qualquer porta lógica pode ser vista então sob duas diferentes perspectivas:
externa e interna. O lado direito da Figura 2 nos dá a arquitetura interna da porta, ou
implementação, ao passo que o lado esquerdo mostra somente a interface da porta,
ou seja, seus pinos de entrada e saída que são exibidos ao mundo exterior. A
implementação só é relevante para o designer da respectiva porta, uma vez que o nível
certo de detalhamento para outros designers é na forma de um componente abstrato
para a porta, sem se preocupar com os detalhes de sua estrutura interna.
Vamos considerar outro exemplo de design, que é a porta Xor. Como discutido
previamente, Xor(a,b) é 1 quando tanto a for 1 e b for 0, quanto a for 0 e b for 1. Dito
de outra forma, Xor(a,b) = Or(And(a,Not(b)), And(Not(a),b)). Esta definição leva ao
design lógico mostrado na Figura 3.
Figura 3 - Porta Xor, com sua possível implementação
Note que a interface da porta é única: só há um meio de descrevê-la, sendo isto
normalmente feito através de uma tabela verdade, uma expressão booleana, ou
alguma especificação verbal. Esta interface, no entanto, pode ser realizada usando
diferentes implementações, algumas dos quais serão melhores que outras em termos
de custo, velocidade e simplicidade. Por exemplo, a função Xor pode ser
implementada usando quatro ou mais portas And, Or e Not. Assim, do ponto de vista
funcional, o requerimento fundamental de um design lógico é que a implementação da
porta deve realizar sua interface especificada, de um jeito ou de outro. Do ponto de
vista da eficiência, a regra geral é fazer mais com menos, isto é, com o menor uso
possível de portas.
Resumindo, a arte do design lógico pode ser descrita como, a partir de uma
especificação de porta, conhecida por interface, deve se encontrar uma forma
eficiente de se implementá-la, usando outras portas previamente implementadas. Isto
sintetiza o que será feito no resto deste capítulo.
Construção do Hardware Atual
Tendo descrito a lógica da composição de portas complexas de outras mais simples, há
condições para discutir como as portas são construídas. Inicia-se com um exemplo
intencionalmente ingênuo.
Supondo a abertura de uma empresa de fabricação de chips em nossa garagem de
casa. O primeiro contrato é o fornecimento de cem portas xor. Usando o pagamento
da entrada, foram compradas uma estação de solda, rolo de fio de cobre e três
componentes rotulados de porta “and”, “or” e “not”, cada um contendo cópias
idênticas destas três portas lógicas elementares. Cada uma destas portas é
encapsulada em um invólucro plástico que expõe os pinos de entrada e saída, bem
como o de alimentação. Para iniciar, coloca-se na parede a Figura 3 e procede-se a
realização usando o hardware. Primeiramente, pega-se duas portas And, duas Not e
uma Or e monta-se em uma placa conforme o leiaute da figura. Depois, conecta-se os
chips com os fios de cobre e solda-se os terminais aos respectivos pinos de entrada e
saída. Agora, se foi seguido cuidadosamente o diagrama da porta, finaliza-se tendo-se
três terminais de fios expostos. Solda-se um pino a cada um destes terminais,
encapsulando-se posteriormente o dispositivo inteiro em um invólucro plástico, exceto
os três pinos terminais e finalmente rotula-se este com o nome “xor”. Este processo de
montagem é repetido muitas vezes seguidas. Ao final do dia, armazena-se o que foi
construído. A partir disto, viabiliza-se a construção de outros chips com o uso desta
nova construção elementar, na forma de um novo bloco disponível, assim como as
portas previamente usadas.
Como o leitor provavelmente notou, a abordagem de garagem da produção de chips
deixa muito a desejar. Para iniciantes, não há garantia de que o diagrama dado do chip
está correto. Embora este não seja o caso simples que é uma Xor, a prova de que está
correto não pode ser feita para muitos chips complexos. Assim, deve-se confiar em um
teste empírico: construir o chip, conectá-lo a um fonte, ativá-lo e desativá-lo e
diferentes formas, tendo a esperança que a saída estará de acordo com o especificado.
Se o chip falhar na entrega das saídas desejadas, tem-se que lidar com sua estrutura
física – uma questão bem complicada. Além disso, mesmo se o design correto foi feito,
replicar o processo de montagem muitas vezes seguidas consumirá muito tempo e não
será a prova de erros. Deve haver então um modo melhor de fazê-lo!
Linguagem de Descrição de Hardware (HDL)
Atualmente, projetistas de hardware não mais constroem algo fisicamente. Ao invés
disto, planejam e otimizam a arquitetura do chip em uma estação computacional,
usando formalismos de modelagem estruturada como a Linguagem de Descrição de
Hardware (HDL, de Hardware Description Language, também conhecido por VHDL,
onde V vem de virtual). O projetista especifica a estrutura do chip escrevendo um
programa HDL, que então é sujeito a uma rigorosa bateria de testes. Estes testes
também são conduzidos virtualmente, usando simulação computacional: uma
ferramenta de software especial, chamada Hardware Simulator, pega um programa
HDL como entrada e implementa uma imagem do chip modelado em memória. Após,
o projetista instrui o simulador a testar este chip virtual sobre diferentes configurações
de entrada, gerando uma saída simulada do chip. Estas saídas podem ser comparadas
com os resultados desejados, como imposto pelo cliente que contratou a construção
do chip.
Em adição ao teste de validação do chip, o projetista de hardware estará normalmente
interessado em uma variedade de parâmetros tais como velocidade de computação,
consumo de energia e custo geral envolvido no projeto do chip. Todos estes
parâmetros podem ser simulados e quantificados pelo hardware simulator, auxiliando
na otimização do design do chip até que o chip simulado alcance o desejado nível de
custo/ performance.
Assim, usando HDL, pode-se planejar, debugar e otimizar um chip inteiro antes de se
gastar um centavo na produção do mesmo. Quando o programa HDL é completado,
isto é, quando o desempenho do chip simulado satisfaz as especificações do cliente, o
programa HDL se torna o modelo partir do qual muitas cópias do chip físico podem ser
grafados em silício. O passo final no ciclo de vida do chip – de um programa otimizado
para a produção em massa – é normalmente terceirizado em empresas especializadas
na fabricação de chips, usando uma tecnologia de chaveamento ou outra.
Exemplo: construindo uma porta Xor como visto nas figuras 2 e 3, um modo de definir
este chip é Xor(a,b) = Or(And(a,Not(b)),And(Not(a),b)). Esta lógica pode ser expressa
também graficamente, como um diagrama de portas, ou textualmente, como um
programa HDL. Veja a figura 4 para os detalhes.
Explanação uma definição HDL de um chip consiste de uma seção de cabeçalho e uma
seção de partes. A seção de cabeçalho especifica a interface do chip, nomeando tanto
o chip quanto seus pinos de entrada e saída. A seção partes descreve nomes e a
topologia de todas as partes de mais baixo nível (outros chips) do qual este chip é
implementado. Cada parte é representada por uma declaração que especifica o nome
da parte e o modo em que é conectado a outras partes no design. Notar que em
ordem para escrever tais declarações legivelmente, o programador HDL deve ter uma
documentação completa das interfaces das partes primitivas. Por exemplo, a figura 4
assume que os pinos de entrada e saída de uma porta Not são rotuladas como in e out,
assim como ambas portas And e Or são rotuladas como a, b e out. Esta informação não
é óbvia e, portanto, deve ser acessada previamente às conexões a serem feitas entre
as partes no código corrente.
Conexões inter partes são descritas pela criação e conexão de pinos internos,
conforme necessário. Por exemplo, considere o fundo do diagrama da porta, onde a
saída de uma porta Not é introduzida na entrada de uma porta And subsequente. O
código HDL descreve esta conexão pelo par de declarações Not(..., out=nota) e
And(a=nota,...). A primeira declaração cria um pino interno com o nome nota,
alimentado pela saída da porta. A segunda declaração atribui o valor de nota na
entrada a de uma porta And. Notar que os pinos tem um fan out ilimitado. Por
exemplo, na figura 4 cada entrada simultaneamente alimenta duas portas. Nos
diagramas de porta, conexões múltiplas são descritas usando-se uma abordagem de
forks. Em HDL, a existência de forks está implícita no código.
Testando a garantia rigorosa da qualidade requer que o chip seja testado de um modo
específico, replicável e bem documentado. Com isto em mente, simuladores de
hardware são usualmente desenvolvidos para a execução de scripts de teste, escrito
em alguma linguagem de scripting. Por exemplo, o script de teste da figura 4 foi escrito
em uma linguagem compreendida pelo Hardware Simulator fornecido em conjunto
com esta publicação. Esta linguagem é descrita plenamente no apêndice B.
Segue uma breve descrição do script de teste da figura 4. As primeiras duas linhas do
script instruem o simulador a carregar o programa [Link] e se preparar para imprimir
os valores das variáveis selecionadas. Depois, lista uma série de cenários de teste,
designados para simular várias contingências sobre o qual o chip Xor terá de operar em
situações reais. Em cada cenário, o script instrui o simulador a atribuir nos pinos de
entrada certos valores, computando a saída resultante e guardando-a em um arquivo
de saída. No caso de portas simples como a Xor, pode-se escrever um script de teste
exaustivo que elenca todos os possíveis valores de entrada da porta. O arquivo
resultantes de saída pode então ser visto como uma prova completa de que o chip foi
bem projetado. Este luxo não é viável para chips mais complexos, como será visto mais
tarde.
Simulação do Hardware
Desde que a HDL é uma linguagem de construção de hardware, a escrita e depuração
de programas HDL é muito similar ao de desenvolvimento de software. A principal
diferença é que ao invés de codificar em uma linguagem como Java, escreve-se em
HDL, e no lugar de usar um compilador para traduzir e testar código, usa-se um
simulador de hardware. O simulador de hardware é um programa de computador que
sabe como decompor e interpretar código HDL, transformando-o em uma
representação executável, testando-o de acordo com as especificações atribuídas a um
certo script de teste. Existem muitos simuladores comerciais de hardware no mercado,
variando em custo, complexidade e facilidade de uso. Para o propósito desta
publicação, disponibiliza-se um simulador simples e livre, mas que é poderoso o
suficiente para suportar projetos de hardware sofisticados. Em particular, o simulador
provê todas as ferramentas necessárias para se implementar, testar e integrar todos os
chips apresentados neste livro, culminando com a construção de um computador de
aplicação geral. A figura ilustra uma típica sessão de simulação.
Especificação
Esta sessão especifica uma típica família de portas, cada qual designada para conduzir
uma operação booleana comum. Estas portas serão usadas nos capítulos que seguem
com o intuito de viabilizarem a implementação plena da arquitetura de um
computador de propósito geral. Nosso ponto de partida é uma simples porta primitiva
Nand, no qual todas as demais portas subsequentes serão derivadas recursivamente.
Note que apenas serão providas as especificações e interfaces das portas, sendo que
alguns detalhes de implementação serão explanados em sessão subsequente. Todas as
portas serão construídas e simuladas em um computador pessoal, usando o simulador
de hardware provido neste livro.
A Porta Nand
O ponto de partida de nossa arquitetura computacional é a porta Nand, do qual todas
as demais derivarão. Esta porta computa a seguinte função booleana:
Por todo o livro serão usadas as “caixas de API de chip” para se especificar este chip.
Para cada chip, a API especifica seu nome, o nome de seus pinos de entrada e saída, a
função ou operação que o chip efetua, além de um comentário adicional (opcional).
Portas Lógicas Básicas
Algumas das portas lógicas apresentadas aqui são referenciadas como “elementares”
ou “básicas”. Ao mesmo tempo, cada uma delas pode ser composta de portas Nand.
Por isso, não devem ser vistas como portas primitivas.
Not – porta de uma única entrada, também conhecida por inversor, converte sua
entrada de 0 para 1 e vice-versa. Sua API é:
And – a função and retorna 1 quando ambas entradas são 1, caso contrário, 0.
Or – a função or retorna 1 quando ao menos uma das entradas for 1.
Xor – a função xor, ou OU-EXCLUSIVO, retorna 1 somente quando suas entradas
possuem estados distintos.
Multiplexador – um multiplexador é uma porta de três entradas no qual uma delas,
denominada “bit de seleção” seleciona qual dentre as duas entradas, chamadas de bits
de dados, será colocada na saída. Assim, um outro nome para esta porta também pode
ser “seletor”. A origem do nome multiplexador vem dos sistemas de comunicação,
onde um componente similar é usado para colocar em série vários sinais de entrada a
serem transmitidos em uma única saída.
Demultiplexador – também conhecido por demultiplex, efetua a função oposta de um
multiplexador: de um único bit de entrada canaliza para uma de duas saídas possíveis,
de acordo com um bit seletor que especifica a saída escolhida.
Versões Multibit das Portas Básicas
Um hardware computacional é feito para operar sobre conjuntos multibit chamados
de barramentos ou “bus”. Por exemplo, um requisito básico de um computador de 32
bits é sua capacidade em computador uma função E lógica sobre dois barramentos de
32 bits disponíveis. Para implementar esta operação, pode-se construir um conjunto
de 32 portas and binárias, cada uma operando sobre um par de bits. Para se colocar
toda esta lógica em um único invólucro, pode-se encapsular este conjunto de portas
em uma única interface de chip com dois barramentos de 32 bits de entrada e um
barramento de 32 bits de saída.
Esta sessão descreve uma típica família de portas lógicas multibit, assim como o que é
necessário para a implementação de um computador de 16 bits.
Quando se refere a bits individuais de um certo barramento, é comum o uso da sintaxe
de vetores. Por exemplo, para se referenciar bits individuais de um dado barramento
denominado “data”, deve-se usar a notação data[0], data[1], ..., data[15].
Not multibit – aplica a operação booleana not a cada um dos bits de um barramento
de entrada.
And multibit – aplica a operação booleana and a cada par de bits individuais de
mesmo índice em dois barramentos de entrada.
Or multibit – aplica a operação booleana or a cada par de bits individuais de mesmo
índice em dois barramentos de entrada.
Multiplex multibit – é exatamente igual a um multiplexador binário, exceto que as
entradas são barramentos. O bit seletor é único.
Versões Multivias das Portas Básicas
São variantes das versões básicas com duas entradas que aceitam um numero
arbitrário de entradas. Esta sessão descreve uma família de portas multivias que serão
usadas na implementação de vários chips da arquitetura computacional proposta.
Generalizações similares podem ser desenvolvidas para outras arquiteturas, se
necessário.
Ou multivia – uma porta ou multivia apresentará em sua saída 1 caso ao menos uma
de suas entradas esteja em estado 1. Abaixo uma caixa para API de uma versão de 8
vias:
Multiplexador multivia/ multibit – um multiplexador de m-vias e n-bits seleciona um
dos m barramentos de n bits para o único barramento de saída de n bits. A seleção é
especificada por k bits de controle, onde k =log 2 m. A figura abaixo ilustra um exemplo
típico.
A plataforma computacional aqui proposta empregará duas variantes deste chip: o
multiplex de 16 bits e 4 vias e de 16 bits e 8 vias.
Demultiplexador multivia/multibit – canaliza uma única entrada de n bits em uma
dentre m saídas de n bits. A seleção é especificada por k bits de controle, onde
k =log 2 m.
A plataforma computacional aqui proposta empregará duas variantes deste chip: o
demultiplex de 1 bit e 4 vias e de 1 bit e 8 vias, como segue.
Implementação
Similar ao papel dos axiomas na matemática, portas primitivas provêm uma família de
blocos elementares sobre o qual todos os demais são construídos. Operacionalmente,
estas possuem uma implementação “off-the-shelf” que é suprida externamente. Desta
forma, pode ser usada na construção de outras portas e chips sem necessidade de se
preocupar com seu design interno. Na arquitetura computacional que se iniciará neste
capítulo, foi escolhida a base para todo o hardware em uma única primitiva: a porta
Nand. Passa-se então a listar o pontapé para a construção de cada projeto, uma porta
por vez.
Contudo, este guia é intencionalmente incompleto, uma vez que é a missão do leitor
descobrir a arquitetura de cada porta por si mesmo. Repete-se aqui que cada porta
pode ser implementada de mais de uma forma, porém, quanto mais simples, melhor.
Not: a implementação de uma porta not unária de uma port nand é simples.
And: mais uma vez, esta implementação é simples. Dica: pense neste porta como o
inverso da Nand.
Or/ Xor: demandam manipulações com álgebra booleana sobre representações destas
funções.
Multiplexador/ demultiplexador: implementada a partir das portas prévias.
Portas not/ and/ or multibit: uma vez implementada a versão elementar destas
portas, a construção das versões multibit é mera agregação destas em conjunto, cada
porta correspondendo a um certo bit indexado separadamente. Embora estas
construções sejam mais trabalhosas do que propriamente desafiantes na aplicação das
faculdades intelectuais, serão chips utilizados na concepção de chips mais complexos,
como serão vistos nos capítulos subsequentes.
Multiplexador multibit: sua implementação reside na simples aplicação do único bit
de seleção a um conjunto de multiplexadores de um bit. Novamente, uma tarefa
entediante para um chip de muita utilidade.
Portas multivias: pense sobre desvios.
Perspectiva
Este capítulo descreveu os primeiros passos aplicados a um projeto digital. Nos
próximos capítulos serão abordadas construções mais complicadas usando as portas
aqui desenvolvidas.
Embora a porta nand foi escolhida como o bloco de construção básico, outras
abordagens são possíveis. Por exemplo, pode-se construir uma plataforma
computacional completa usando portas nor, ou, alternativamente, uma combinação
de portas and, or e not. Estas abordagens construtivas para o desenho da lógica são
teoricamente equivalentes, assim como o são todos os teoremas da geometria obtidos
a partir de diferentes axiomas tomados como ponto de partida. A teoria e prática de
tais construções são cobertas em livros texto sobre design digital ou lógico.
Pelo capítulo inteiro, não se levou em conta considerações de eficiência tais como a
quantidade de portas elementares usadas na construção ou o número de cruzamento
de fios implicados pelo design. Tais considerações são criticamente importantes na
prática, sendo objeto de foco de um grande número de cientistas e engenheiros da
computação visando sua otimização. Outro ponto não endereçado aqui são as
questões físicas envolvidas na implementação de tais portas, relacionadas ao
funcionamento dos transistores encapsulados em silício. Há várias opções de
implementação disponíveis, cada qual com suas próprias características (velocidade,
consumo, custo de produção, etc.). A cobertura destas questões será deixada para
referências mais apropriadas ao aprofundamento do tema.
Projeto
Objetivo – implementar todas as portas lógicas apresentadas neste capítulo. O único
bloco básico disponível são portas nand primitivas e portas compostas que vão se
tornando disponíveis a medida que o leitor gradualmente faça as implementações
mais básicas, em direção as mais complexas.
Recursos – a única ferramenta necessária para este projeto é o simulador de hardware
provido. Todos os chips devem ser implementados em linguagem HDL especificada no
apêndice A. Para cada um dos chips mencionados no capítulo, será provido um arquivo
texto esqueleto .hdl sem a implementação realizada. Adicionalmente, para cada chip é
providenciado um script .tst que orienta o simulador de hardware em como testar o
respectivo chip, junto com o correto arquivo de saída que este script deve gerar,
chamado .cmp ou “arquivo de comparação”. Sua tarefa é completar a parte faltante
do arquivo .hdl suprido.
Contrato – quando carregado no simulador de hardware, o chip desenhado (arquivo
hdl modificado), testado com o arquivo tst, deve produzir a saída listada no arquivo
cmp fornecido. Se não for o caso, o simulador o avisará.
Dicas – a porta nand é considerada primitiva, sendo desnecessária sua implementação:
toda a vez que invocar Nand em seus arquivos hdl, simulador automaticamente
invocará sua implementação built-in em tools/builtIn/[Link]. Recomenda-se
implementar as portas na ordem em que aparecem no capítulo. Entretanto, desde que
o diretório builtIn tem as versões funcionais de todos os chips descritos no livro, é
possível usá-los sem construí-los inicialmente, pois o simulador automaticamente usa
estas versões.
Por exemplo, considere o esqueleto do programa [Link] fornecido neste projeto.
Suponha que por alguma razão ou outra não foi possível completar a implementação
deste, mas você ainda quer usá-lo como uma parte interna no projeto de outro chip.
Isto não será problema, graças ao que foi esclarecido anteriormente. Se o simulador
não encontra o arquivo [Link] no diretório corrente de trabalho do projeto, ele
automaticamente invoca a implementação built-in, que é uma classe Java depositada
no diretório builtIn e que possui a mesma interface e funcionalidade na porta Mux
descrita neste capítulo. Desta forma, se quiser que o simulador ignore alguma
implementação, basta mover o correspondente arquivo hdl do diretório corrente.
Passos – sugere-se proceder na seguinte ordem:
1. O simulador de hardware necessário para o projeto está disponível no diretório
tools da suíte fornecida;
2. Leia o apêndice A, seções A1 – A6;
3. Vá para o tutorial do simulador de hardware, restrito as partes I, II e III;
4. Construa e teste todos os chips especificados no diretório projects/01.