a post i laar quite tura

Curso de Sistemas de Informação

Disciplina de Arquitetura de Computadores

Esse material tem como objetivo servir de apoio a disciplina, facilitando o acesso ao

conhecimento por parte do aluno. Em hipótese alguma ele substitui a bibliografia adotada pela disciplina, não devendo jamais ser utilizado como única fonte de pesquisa e referência.

Prof. Arildo Sônego

_______________________________________________________________________________________________ Curso de Sistemas de Informação - 2 - Disciplina de Arquitetura de Computadores

Bibliografia

AHO, Alfred V. Compiladores: princípios, técnicas e ferramentas. Rio de Janeiro: Guanabara, 1995 CARDINALE, Roberto; D'UGO, Felipe. Dossiê hardware. 3.ed.. São Paulo : Digeri Books, 2003. 319 p. MONTEIRO, Mario Antonio. Introdução à organização de computadores. Rio de Janeiro: LTC, 1996. MURDOCA, Miles. Introdução à arquitetura de computadores. Rio de Janeiro: Campus, 2000. STALLINGS, William. Arquitetura e organização de computadores. São Paulo: Prentice Hall, 2002. TANENBAUM, Andrew S. Organização estruturada de computadores. 3.ed.. São Paulo : LTC, 2000. 460 p.



Índice 1- VISÃO GERAL ......................................................................................................................................................... 6

1.1 – UMA BREVE HISTÓRIA ...................................................................................................................................... 6

1.2 – A MÁQUINA DE VON NEUMANN ....................................................................................................................... 8 1.3 – O MODELO DE BARRAMENTO DO SISTEMA ....................................................................................................... 9

1.4 – COMPUTADORES COMERCIAIS ......................................................................................................................... 10 1.5 – A SEGUNDA GERAÇÃO DE COMPUTADORES .................................................................................................... 11

1.6 – A TERCEIRA GERAÇÃO DE COMPUTADORES ................................................................................................... 11

1.7 – QUARTA GERAÇÃO DE COMPUTADORES - VLSI ............................................................................................. 13

1.8 – EVOLUÇÃO DA INFORMÁTICA .......................................................................................................................... 15

2- REPRESENTAÇÃO DAS INFORMAÇÕES ....................................................................................................... 18

2.1 – BITS, CARACTERES, BYTES E PALAVRAS .......................................................................................................... 18 2.2 - NOTAÇÃO POSICIONAL ..................................................................................................................................... 20

2.3 - OUTRAS BASES DE NUMERAÇÃO ..................................................................................................................... 21 2.4 - CONVERSÃO DE BASES .................................................................................................................................... 22

2.4.1 – Conversão de Base Decimal para Base Binária .................................................................................... 22 2.4.2 – Conversão de Base Binária para Base Decimal .................................................................................... 22

3- CONCEITOS DA LÓGICA DIGITAL ....................... .......................................................................................... 24

3.1 – INTRODUÇÃO................................................................................................................................................... 24

3.2 – ÁLGEBRA BOOLEANA ...................................................................................................................................... 25

3.2.1 – Operação Lógica ou Porta AND (E) ...................................................................................................... 25

3.3 – OPERAÇÃO LÓGICA OU PORTA OR (OU) ......................................................................................................... 26 3.3.1 – Operação Lógica NOT (Inversor) .......................................................................................................... 26

3.3.2 – Operação Lógica NAND – NOT AND.................................................................................................... 26

3.3.3 – Operação Lógica NOR – NOT OR ......................................................................................................... 27

3.3.4 – Operação Lógica XOR – EXCLUSIVE OR ............................................................................................ 27 3.4 – EXPRESSÕES LÓGICAS ..................................................................................................................................... 27

3.5 - CIRCUITOS COMBINATÓRIOS ............................................................................................................................ 28 3.6 - CIRCUITOS INTEGRADOS .................................................................................................................................. 29

4- UNIDADE CENTRAL DE PROCESSAMENTO ................................................................................................ 32

4.1 - INTRODUÇÃO ................................................................................................................................................... 32

4.2 – FUNÇÕES BÁSICAS .......................................................................................................................................... 32

4.3 – COMPONENTES ................................................................................................................................................ 33

4.3.1 – Unidade de Controle .............................................................................................................................. 34

4.3.2 – Unidade Lógica e Aritmética (ULA) ...................................................................................................... 35

4.3.3 – Registradores ......................................................................................................................................... 35

4.4 – CLOCK ............................................................................................................................................................. 36 4.5 – CO-PROCESSADOR ARITMÉTICO ....................................................................................................................... 37 4.6 – SINAIS DE CONTROLE ...................................................................................................................................... 38

4.7 – ARQUITETURA DOS PROCESSADORES (RISC X CISC) .................................................................................... 39

4.8 – FAMÍLIA INTEL ................................................................................................................................................ 40

4.8.1 – 80286 ...................................................................................................................................................... 40 4.8.2 – 80386 ...................................................................................................................................................... 41 4.8.3 – 80486 ...................................................................................................................................................... 41 4.8.4 – Pentium .................................................................................................................................................. 42 4.8.5 – Pentium MMX ........................................................................................................................................ 43

4.8.6 – Pentium Pro ........................................................................................................................................... 43

4.8.7 – Pentium II ............................................................................................................................................... 44 4.8.8 – Pentium II Xeon ..................................................................................................................................... 44

4.8.9 – Pentium III ............................................................................................................................................. 44 4.8.10 – Pentium III Xeon .................................................................................................................................... 45



4.8.11 – Celeron ................................................................................................................................................... 45 4.8.12 – Pentium 4 ............................................................................................................................................... 45 4.8.13 – Itanium ................................................................................................................................................... 46

4.9 - FAMÍLIA AMD ................................................................................................................................................. 46

4.9.1 – AMD 286 A ............................................................................................................................................. 46

4.9.2 – AMD 386 ................................................................................................................................................ 47

4.9.3 – AMD 486 ................................................................................................................................................ 47

4.9.4 – AMD 586 ................................................................................................................................................ 47

4.9.5 – AMD K5 ................................................................................................................................................. 47

4.9.6 – AMD K6 ................................................................................................................................................. 48

4.9.7 – AMD K6-II ............................................................................................................................................. 48

4.9.8 – AMD K6-III ............................................................................................................................................ 48

4.9.9 – AMD Athlon ........................................................................................................................................... 49

4.9.10 – AMD Athlon Thunderbird ...................................................................................................................... 49

4.9.11 – AMD Duron ............................................................................................................................................ 49

4.10 - FAMÍLIA CYRIX ................................................................................................................................................ 50

4.10.1 – Cyrix Cx486 DX ..................................................................................................................................... 50

4.10.2 – Cyrix 5x86 .............................................................................................................................................. 50 4.10.3 – Cyrix 6x86 .............................................................................................................................................. 50 4.10.4 – Cyrix Media GX ..................................................................................................................................... 51

4.10.5 – Via Cyrix III ........................................................................................................................................... 51

5- SUBSISTEMAS DE MEMÓRIA ........................................................................................................................... 53

5.1 - INTRODUÇÃO ................................................................................................................................................... 53

5.2 - REPRESENTAÇÃO DAS INFORMAÇÕES .............................................................................................................. 53 5.3 - LOCALIZAÇÃO DAS INFORMAÇÕES ................................................................................................................... 54 5.4 - OPERAÇÕES REALIZADAS ................................................................................................................................ 54 5.5 - HIERARQUIA .................................................................................................................................................... 54

5.5.1 - Registradores .......................................................................................................................................... 56

5.5.2 - Memória Cache ....................................................................................................................................... 56

5.5.3 - Memória Principal .................................................................................................................................. 57

5.5.4 - Memória Secundária ............................................................................................................................... 58

5.6 – MÉTODOS DE ACESSO ..................................................................................................................................... 58

5.7 – CORREÇÃO DE ERROS ..................................................................................................................................... 59

5.8 – MEMÓRIA VIRTUAL ......................................................................................................................................... 59

5.9 - BANCO DE MEMÓRIAS ..................................................................................................................................... 60

5.9.1 - Módulo SIMM de 30 vias ........................................................................................................................ 61

5.9.2 - Módulo SIMM de 72 vias ........................................................................................................................ 62

5.9.3 - Módulo DIMM ........................................................................................................................................ 63

5.9.4 - Módulo RIMM......................................................................................................................................... 63

5.10 - MEMÓRIAS RAM ............................................................................................................................................. 64

5.10.1 – Fast Page Mode (FPM) .......................................................................................................................... 64

5.10.2 - Extended Data Out (EDO) ...................................................................................................................... 65

5.10.3 - Burst Extend Data Out (BEDO) .............................................................................................................. 65

5.10.4 - Synchronous Dynamic RAM (SDRAM) ................................................................................................... 65

5.10.5 - Double Data Rate SDRAM (DDR-SDRAM) ........................................................................................... 66 5.10.6 - Memória Rambus .................................................................................................................................... 66

5.11 - MEMÓRIAS ROM ............................................................................................................................................. 67

6- MEMÓRIA EXTERNA .......................................................................................................................................... 69

6.1 - INTRODUÇÃO ................................................................................................................................................... 69

6.2 - DISCOS MAGNÉTICOS ....................................................................................................................................... 69

6.2.1 - Organização e Formatação de Dados .................................................................................................... 69

6.2.2 – Características Físicas ........................................................................................................................... 70

6.2.3 – Parâmetros de desempenho de discos .................................................................................................... 71

6.3 - RAID ............................................................................................................................................................... 72



6.3.1 - RAID de Nível 0 ...................................................................................................................................... 74

6.3.2 - RAID de Nível 1 ...................................................................................................................................... 74

6.3.3 - RAID de Nível 2 ...................................................................................................................................... 75

6.3.4 - RAID de Nível 3 ...................................................................................................................................... 75

6.3.5 - RAID de Níveis 4, 5 e 6 ........................................................................................................................... 76

6.4 - INTERFACES ..................................................................................................................................................... 77

6.4.1 - IDE .......................................................................................................................................................... 77 6.4.2 - SCSI ........................................................................................................................................................ 78

6.4.2.1 - SCSI 1 .................................................................................................................................................................. 78 6.4.2.2 - SCSI 2 .................................................................................................................................................................. 78 6.4.2.3 - SCSI 3 .................................................................................................................................................................. 79

6.4.3 - Serial ATA ............................................................................................................................................... 79 6.5 - MEMÓRIA ÓPTICA ............................................................................................................................................ 80

6.5.1 - CD ........................................................................................................................................................... 80 6.5.2 - DVD ........................................................................................................................................................ 81

7- EXECUÇÃO DE PROGRAMAS .......................................................................................................................... 83

7.1 - INTRODUÇÃO ................................................................................................................................................... 83

7.2 - LINGUAGENS DE PROGRAMAÇÃO ..................................................................................................................... 83 7.3 - MONTAGEM E COMPILAÇÃO ............................................................................................................................ 85

7.3.1 - Montagem ............................................................................................................................................... 85

7.3.2 - Compilação ............................................................................................................................................. 86

7.3.3 - Ligação ou Linkedição............................................................................................................................ 87

7.4 - INTERPRETAÇÃO .............................................................................................................................................. 88

7.4.1 - Compilação x Interpretação ................................................................................................................... 88

7.5 – LINGUAGEM ASSEMBLY .................................................................................................................................. 89

7.5.1 - Registradores .......................................................................................................................................... 90

7.5.1.1 - Registradores Gerais............................................................................................................................................. 90 7.5.1.2 - Registradores de Segmento .................................................................................................................................. 91 7.5.1.3 - Registradores de Deslocamento ........................................................................................................................... 91 7.5.1.4 - Registrador de Estado .......................................................................................................................................... 92

7.5.2 – Assembly 8086 ........................................................................................................................................ 92

7.5.2.1 – Exemplos de Programas em Assembly ................................................................................................................ 93

8- GRAMÁTICAS ....................................................................................................................................................... 95

8.1 - LINGUAGENS FORMAIS ..................................................................................................................................... 95

8.2 - LINGUAGEM ..................................................................................................................................................... 95

8.3 - COMPONENTES DE UMA LINGUAGEM ............................................................................................................... 95 8.4 - REPRESENTAÇÕES DE UMA LINGUAGEM .......................................................................................................... 96 8.5 - GRAMÁTICAS ................................................................................................................................................... 96

8.6 - DERIVAÇÃO E REDUÇÃO .................................................................................................................................. 98

8.7 - BACKUS NAUR FORM ...................................................................................................................................... 98

8.8 - LINGUAGENS DEFINIDAS POR GRAMÁTICAS ..................................................................................................... 99

8.9 - GRAMÁTICAS EQUIVALENTES .......................................................................................................................... 99 8.10 - TIPOS DE GRAMÁTICAS .................................................................................................................................. 100

8.11 - EXPRESSÕES REGULARES .............................................................................................................................. 101

9- AUTÔMATOS FINITOS ..................................................................................................................................... 103

9.1 - INTRODUÇÃO ................................................................................................................................................. 103

9.2 - DEFINIÇÃO FORMAL ....................................................................................................................................... 103

9.3 – REPRESENTAÇÃO GRÁFICA DE AUTÔMATOS FINITOS .................................................................................... 104

9.4 - TABELA DE TRANSIÇÃO DE ESTADOS ............................................................................................................. 104 9.5 - AUTÔMATOS FINITOS DETERMINÍSTICOS & NÃO DETERMINÍSTICOS .............................................................. 105 9.6 - CONVERSÃO PARA AUTÔMATO FINITO DETERMINÍSTICO ............................................................................... 106

9.7 - RECONHECIMENTO DE SENTENÇAS ................................................................................................................ 108 9.8 - APLICAÇÕES DE AUTÔMATOS FINITOS ........................................................................................................... 108



1- Visão Geral

1.1 – Uma Breve História

O conceito de efetuar cálculos com algum tipo de equipamento data, pelo menos, do século V a.C. com os babilônios e sua invenção do ábaco. Este dispositivo permitia a contagem de valores, tornando possível aos comerciantes babilônicos registrar dados numéricos sobre suas colheitas. Também os romanos se serviram muito dos ábacos, para efetuar cálculos aritméticos simples, registrando valores de outra forma. Ainda hoje há quem use tal tipo de dispositivo, ainda popular na China, por exemplo.

Dispositivos mecânicos para controlar operações complexas têm sido usados desde o século XVI, quando cilindros rotativos eram usados em caixas de música de forma muito semelhante a que são usados ainda hoje. Máquinas que calculam, ao contrário de simplesmente repetir uma melodia predeterminada, se tornaram realidade no século seguinte.

Blaise Pascal (1623-1662)

desenvolveu uma calculadora mecânica (figura ao lado) para auxiliar na preparação dos impostos de seu pai. A calculadora de Pascal contém oito discos conectados a um tambor, com uma ligação inovadora que faz com que o disco rode uma posição enquanto um excedente é produzido de um disco em uma posição inferior. Uma janela é colocada sobre o disco permitir que sua posição atual seja observada, de forma semelhante a um odômetro de carro, com a exceção de que os discos são posicionados. Horizontalmente, como um disco de telefone rotativo. Algumas das máquinas de adição de Pascal,

que começaram a ser produzidas em 1642 existem até hoje. Seria necessário esperar até o século XIX, para que alguém juntasse os conceitos de controle e cálculo mecânico em uma máquina que hoje reconhecemos ter as partes básicas de um computador digital. Essa pessoa foi Charles Babbage (1791-1871).

Babbage viveu na Inglaterra em uma época em que tabelas matemáticas eram usadas em

navegação e trabalho científico. As tabelas eram calculadas manualmente e os resultados continham inúmeros erros.



Frustrado com as imprecisões, ele projetou um máquina que podia calcular tabelas simplesmente marcando e girando engrenagens. A máquina projetada poderia até mesmo produzir um disco que poderia ser usado em uma impressora, eliminando assim erros que poderiam ser introduzidos no processo de digitação.

Demorou mais de um século, até o início da Segunda Guerra Mundial, antes que o próximo

avanço tenha sido alcançado em computação. Na Inglaterra, submarinos alemães U-boat infligiam pesadas perdas nos transportes navais aliados. Os U-boats recebiam comunicação de suas bases na Alemanha usando um código criptográfico implementado por uma máquina fabricada pela Siemens AG conhecida como ENIGMA (figura ao lado). O processo de codificar informação era conhecido há um longo tempo, e até mesmo o presidente dos Estados Unidos, Thomas Jefferson (1743-1826) projetou um predecessor da ENIGMA, muito embora ele não tenha construído a máquina.

O processo de decodificar a informação era

significamente mais complexo. Foi esse problema que gerou os esforços de Alan Turing (1912-1954) e outros cientistas na Inglaterra para criar máquinas capazes de quebrar a codificação. Durante a Segunda Guerra, Turing foi o mais proeminente especialista em criptografia da Inglaterra e estava entre aqueles que transformaram a criptografia, que era um assunto para pessoas que se interessavam por línguas antigas, em um assunto para matemáticos.

Aproximadamente no

mesmo período do trabalho de Turing, J.Presper Eckert e John Mauchly projetaram uma máquina que poderia ser usada para calcular tabelas de trajetórias balísticas para o exército dos Estados Unidos. Os americanos queriam saber como deveriam posicionar seus canhões para acertar o alvo. Esses cálculos exigiam grande esforço humano. O resultado do trabalho de Eckert-Mauchly foi o ENIAC (Electronic Numerical Integrator and Computer). O ENIAC consistia em 18.000 tubos de vácuo que eram a seção computacional da máquina. Programas e dados eram introduzidos por meio de interruptores e

troca de cabos. Não existia um conceito de um programa armazenado, e não existia também uma unidade central de memória, mas essas não eram limitações sérias porque tudo que o ENIAC precisava fazer era calcular trajetórias balísticas. Apesar de não se tornar operacional até 1946, após o fim da guerra foi considerado um sucesso e utilizado por nove anos. A operação dessa máquina consumia 140 quilowatts de energia elétrica. Ela era muito mais rápida do que qualquer computador eletromecânico, sendo capaz de executar 5 mil adições por segundo. O ENIAC era uma máquina decimal e não uma máquina binária, ou seja, a representação era feita na base decimal, a qual era utilizada também para a realização das operações aritméticas. A memória consistia de 20 acumuladores, cada um dos quais capaz de armazenar um número decimal de dez dígitos.



Cada dígito era representado por um anel de dez válvulas. A cada instante, apenas uma válvula ficava no estado ON (ligado), representando um dos dez dígitos.

O ENIAC foi o primeiro computador desenvolvido nos Estados Unidos em um projeto bem

sucedido e predecessor de computadores importantes para a evolução dessas máquinas. O projeto inicial previa o investimento de US$ 150 mil, mas acabou custando US$ 400 mil. De acordo com o Computer History Museum, localizado na Califórnia, Estados Unidos, em uma década ele fez mais contas do que a humanidade inteira tinha feito até então. Hoje, qualquer calculadora de engenharia é mais rápida que ele.

1.2 – A Máquina de Von Neumann

A tarefa de carregar e de modificar um programa no ENIAC era extremamente tediosa. O processo de programação poderia ser facilitado se um programa pudesse ser representado de maneira adequada, de modo que fosse armazenado na memória, juntamente com os dados. Assim, o computador poderia obter as informações diretamente, a partir da memória, e um programa poderia ser carregado ou modificado simplesmente atribuindo valores à posições de memória.

Essa idéia, conhecido como conceito

de programa armazenado, geralmente é atribuída aos projetistas do ENIAC, principalmente ao matemático John Von Neumann, que era um dos consultores no projeto. Ela foi simultaneamente concebida por Alan Turing. A primeira publicação da idéia, concretizada em uma proposta formulada por Von Neumann, ocorreu em 1945 para um novo computador, o EDVAC (Eletrocnic Discrete Variable Computer).

Em 1946, Von Neumann e seus colegas começaram o projeto de um novo computdaor de programa armazenado, conhecido como IAS, no Instituto de Estudos Avançado de Princeton. O IAS, embora concluído somente em 1952, constitui o protótipo de todos os computadores de propósito geral subseqüentes.

No modelo de Von Neumann o dispositivo de entrada fornece instruções e dados ao sistema que são subsequentemente armazenados na unidade de memória. As instruções e os dados são processados pela unidade aritmética e lógica (ULA) sob a supervisão da unidade de controle. Os resultados são enviados para o dispositivo de saída. A ULA e a unidade de controle são frequentemente chamadas, de forma coletiva, de unidade central de processamento (central processing unit – CPU). A maioria dos computadores comerciais funciona desta forma.

O programa armazenado é o aspecto mais importante deste modelo. Um programa é armazenado na memória do computador junto com os dados a serem processados. Muito embora hoje seja considerado normal, antes do desenvolvimento do programa de computador armazenado os programas eram armazenados em memória externa, tais como placas de conexão de fios, cartões perfurados ou fita. No computador de programa armazenado, o programa pode ser manipulado como se fosse um dado. Isso possibilitou o desenvolvimento de compiladores e sistemas operacionais, e tornou possível a grande versatilidade dos computadores modernos. Com raras exceções, todos os computadores atuais possuem essas mesmas funções e estrutura geral e assim são conhecidos como máquinas com arquitetura de Von Neumann.



1.3 – O Modelo de Barramento do Sistema

Muito embora o modelo de Von Neumann esteja presente em computadores modernos, esse modelo foi modernizado (observe a figura). O modelo de barramento do sistema particiona um sistema computacional em três sub-unidades: CPU, memória e entrada/saída (E/S). O refinamento do modelo de Von Neumann combina a ULA e a unidade de controle em uma unidade funcional, a CPU. Os dispositivos de entrada e saída são combinados em uma única unidade de E/S.

O mais importante no modelo de barramento é a comunicação entre os componentes, usando

um caminho compartilhado chamado barramento do sistema, que é composto pelo barramento de dados (que transporta a informação sendo transmitida), o barramento de endereços (que identifica para onde a informação está sendo enviada) e o barramento de controle (que descreve os aspectos sobre como a informação está sendo transmitida, e de que forma). Existe também um barramento de energia para levar alimentação elétrica aos componentes. Esse barramento não é mostrado, mas sua presença é assumida. Algumas arquiteturas possuem os barramentos de entrada e de saída separados.

Fisicamente barramentos são feitos

de coleções de fios que são agrupados por função. Um barramento de dados de 32 bits tem 32 fios individuais, cada um dos quais transporta um bit de dados (ao contrário de endereços ou informação de controle). Nesse sentido, o barramento do sistema é na verdade um grupo de barramentos individuais classificados por sua função.

O barramento de dados move dados

entre os componentes do sistema. Alguns sistemas têm barramentos de dados separados para mover informação para a ou da CPU, e neste caso existem um barramento de entrada de dados e outra de saída de dados. Frequentemente, contudo, um único barramento de dados move os dados em ambas as direções, muito embora nunca nas duas direções ao mesmo tempo.

Se o barramento for compartilhado por todas as unidades que se comunicam, então elas têm

de possuir identidades individuais: endereços. Em alguns computadores presume-se que todos os endereços são endereços de memória, tanto no caso de endereços de memória como no caso de dispositivos de E/S, enquanto em outros os dispositivos de E/S têm endereços separados.

Um endereço de memória identifica um lugar na memória onde os dados serão armazenados

de forma similar à dos endereços postais que identificam o lugar onde o recipiente recebe e envia correspondência. Durante uma operação de leitura ou escrita, o barramento de endereços contém o endereço da localização de memória onde os dados deverão ser lidos ou escritos. Note que os termos “leitura” e “escrita” dizem respeito à CPU: a CPU lê dados da memória e escreve dados na mesma. Se os dados forem lidos da memória então o barramento de dados contém o valor lido daquele endereço de memória. Se os dados forem escritos na memória, então o barramento de dados contém o valor de dados a ser escrito na memória. O barramento de controle pode ser visto como um dispositivo que coordena acesso aos barramentos de dados e endereço, e que direciona dados para componentes específicos.



1.4 – Computadores Comerciais

Os anos 50 viram o nascimento da indústria de computadores com duas companhias, a Sperry e a IBM dominando o mercado.

Em 1947, Eckert e Mauchly fundaram a Eckert-Mauchly Computer Corporation para

fabricar computadores comercialmente. Sua primeira máquina de sucesso foi o UNIVAC I (Universal Automatic Computer) que foi financiado pelo centro de recenseamento para o censo de 1950. A Eckert-Mauchly Computer Corporation tornou-se parte da divisão UNIVAC da Sperry Rand Corporation, que continuou a construir uma série de máquinas sucessoras.

O UNIVAC I foi o primeiro computador comercial de sucesso. Como o nome indica, ele tinha o propósito de servir tanto para aplicações científicas quanto para aplicações comerciais. O primeiro artigo que descreve esse sistema relatava como amostra das tarefas que ele era capaz de executar, computações algébricas sobre matrizes, resolução de problemas estatísticos, cálculo de prêmios de seguro para uma companhia seguradora e solução de problemas logísticos.

O UNIVAC II, que possuía maior

capacidade de memória e maior desempenho que o UNIVAC I, foi lançado no final dos anos 50 e ilustra tendências que permaneceram na indústria de

computadores. A primeira é que os avanços da tecnologia permitiram que as companhias continuassem a desenvolver cada vez mais poderosos e maiores. A segunda é que cada companhia procurava construir suas novas máquinas de modo que fossem compatíveis com as máquinas anteriores. Isso significa que os programas escritos para as máquinas mais antigas podiam ser executados nas máquinas mais novas. Essa estratégia é adotada na expectativa de manter os clientes; isto é, quando um cliente decidisse comprar uma nova máquina, provavelmente optaria por comprá-la do mesmo fabricante do seu antigo computador, para não perder o investimento já feito no desenvolvimento de programas.

A divisão UNIVAC iniciou também o desenvolvimento da série de computadores 1100, que

seria sua linha de computadores de uso mais comum. O desenvolvimento dessa série mostra a distinção, existente anteriormente, entre computadores. O primeiro modelo, o UNIVAC 1103, e seus sucessores foram voltados para aplicações científicas que envolviam cálculos longos e complexos. Outras companhias dispunham de computadores mais voltados para aplicações comerciais que envolviam o processamento de grandes quantidades de textos. Essa distinção tornou-se menos evidente hoje em dia, mas foi bastante clara por muitos anos.

A IBM, que ajudou a construir o Mark I e era então a maior fabricante de dispositivos de

processamento de cartões perfurados, lançou seu primeiro computador eletrônico programável, o 701, em 1953. O 701 foi, inicialmente, voltado para aplicações científicas (Bashe e outros, 1981). Em 1955, a IBM introduziu o modelo 702, que possuía características de hardware que o tornavam adequado para aplicações comerciais. Esses foram os primeiros uma longa série de computadores 700/7000, que estabeleceram a IBM como o maior fabricante de computadores do mercado.



1.5 – A Segunda Geração de Computadores

A primeira grande mudança nos computadores eletrônicos veio com a substituição da válvula pelo transistor. O transistor é menor, mais barato e dissipa menos calor do que a válvula e, assim como a válvula, também pode ser utilizado para a construção de computadores. Ao contrário da válvula, que requer uso de fios, placas de metal, cápsula de vidro e vácuo. O transistor é um dispositivo de estado sólido, feito de silício.

O transistor foi inventado na Bell Laboratories em 1947

e iniciou uma revolução na indústria eletrônica nos anos 50. Entretanto, apenas no final da década de 50, computadores totalmente transistorizados tornaram-se comercialmente disponíveis. Mais uma vez, a IBM não foi a primeira companhia a lançar esta nova tecnologia. A NCR e, com maior sucesso, a RCA foram as pioneiras com o lançamento de pequenas máquinas transistorizadas. A IBM as seguiu de perto, com a série 7000.

O uso de transistores criou a segunda geração de computadores. É comum classificar os

computadores em gerações, de acordo com a tecnologia básica de hardware empregada. Cada nova geração é caracterizada por computadores com maior velocidade, maior capacidade de memória e menor tamanho que os computadores da geração anterior.

Ocorreram também outras mudanças. Nos computadores da segunda geração, tanto a

unidade lógica e aritmética quanto a unidade de controle eram mais complexas e os computadores já utilizavam linguagens de programação de alto nível e incluíam software de sistema.

Também merece destaque na segunda geração, o surgimento da Digital Equipment

Corporation (DEC). A DEC foi fundada em 1957 e lançou, nesse mesmo ano, seu primeiro computador, o PDP-1. Esse computador, juntamente com seu fabricante, deu início ao fenômeno do minicomputador, que se tornaria tão importante na terceira geração.

A partir da introdução da série 700, em 1952, até o lançamento do último modelo da série

7000, em 1964, essa linha de produtos da IBM passou por uma evolução típica dos produtos de computação. Os sucessivos membros da linha possuíam maior desempenho e capacidade e/ou custo mais baixo. Outra característica nova é o multiplexador, que constitui o ponto central de conexão entre os canais de dados, a CPU e a memória. O multiplexador seleciona qual dispositivo, entre a CPU e os canais de dados, pode fazer acesso à memória. Isso permite que esses dispositivos executem de maneira independente.

1.6 – A Terceira Geração de Computadores

Um único transistor autônomo é denominado um componente discreto. Durante a década de 50 e início dos anos 60, os equipamentos eletrônicos eram compostos basicamente de componentes discretos – transistores, resistores, capacitores e assim por diante. Esses componentes eram fabricados separadamente, encapsulados em seus próprios recipientes e soldados ou ligados com fios, por meio de uma técnica conhecida como wire up, as placas de circuito, que eram então instaladas nos computadores, osciloscópios e outros equipamentos eletrônicos. Quando um dispositivo eletrônico requeria um transistor, um pequeno tubo de metal com uma peça de silício do tamanho de uma cabeça de alfinete tinha de ser soldado a uma placa de circuito.



O processo completo de fabricação, desde o transistor até a placa de circuito, era caro e incômodo.Isso começava a criar problemas na indústria de computadores. Os computadores do início da segunda geração continham cerca de 10 mil transistores. Esse número cresceu até centenas de milhares, tornando cada vez difícil a fabricação de máquinas novas, mais poderosas.

Em 1958, foi desenvolvida uma nova técnica que

revolucionou os equipamentos eletrônicos e iniciou a era da microeletrônica: a invenção do circuito integrado. Esse circuito caracteriza a terceira geração de computadores. O desenvolvimento da tecnologia de circuitos integrados surgiu devido à necessidade de se encontrar uma solução para os problemas de acomodação dos componentes eletrônicos (transistores, capacitores e resistores) nos equipamentos à medida que sua quantidade ia crescendo com o aumento da capacidade das máquinas. Das tentativas de encontrar solução para tais problemas é que se idealizou a possibilidade de acomodá-los em um único invólucro.

O ponto importante no conceito de circuitos integrados é que pode formar múltiplos

transistores em um único elemento de silício, de modo que, um circuito lógico que antes ocupava uma placa de circuito impresso completa pode ser, com esta tecnologia, acomodado em uma só pastilha (chip) de silício. E mais ainda, como se pode conectar vários transistores diretamente na pastilha, eles podem ser incrivelmente menores em tamanho, necessitando, assim, menos energia e dissipando menos calor.

Em outubro de 1958, Jack Kilby, da Texas Instruments

Co, colocou dois circuitos em uma peça de germânio. O dispositivo resultante era rudimentar e as interconexões tinham que ser realizadas por fios externos, mas esse dispositivo é, em geral, reconhecido como o primeiro circuito integrado fabricado no mundo. Logo em seguida, Robert Noyce, da Fairchild Semiconductor Inc., utilizou-se de técnicas recém criadas na mesma companhia e integrou múltiplos componentes em um substrato de silício. Os dispositivos comerciais que se sucederam mostraram a vantagem do silício sobre o germânio e permitiram o surgimento de uma nova geração de máquinas, mais poderoras e menores, devido à integração em larga escala (LSI – Large Scale Integration) que os circuitos integrados proporcionaram.

Em 1964, a IBM se utilizou das recentes inovações tecnológicas na área da microeletrônica

(os circuitos integrados) e lançou a sua família de computadores, a série 360. Este sistema incorporou diversas inovações, que se tornaram um marco histórico em termos de computação e consolidaram a posição já obtida pela IBM, como a primeira fabricante de computadores no mundo.

Entre essas inovações, podemos citar:

� O conceito de família de computadores, em vez de máquina individual, como até então. Este

conceito permite que o fabricante ofereça o mesmo tipo de máquina com diferentes capacidades e preços, o que garante uma maior quantidade de clientes.

� A utilização de unidade de controle com microprogramação em vez das tradicionais unidades de

controle no hardware.



� O emprego de uma técnica chamada de multiprogramação, pela qual vários programas compartilham a mesma memória principal e dividem o uso da CPU, dando a impressão ao usuário de que estão sendo executados simultaneamente.

� A elevada capacidade de processamento (para a época), com palavra de 32 bits e ciclo de instrução

de até 250 nanosegundos, bem como a grande capacidade de armazenamento na memória principal de 16 Mbytes.

Além da família 360, esta época de LSI presenciou também o lançamento de outro

minicomputador DEC com circuitos integrados, memória principal orientada a byte e palavra de 16 bits, o PDP 11, uma das máquinas mais famosas em sua categoria. Seu sucessor, o sistema VAX-11, também teve o mesmo sucesso, especialmente no ambiente universitário.

Microeletrônica significa literalmente “eletrônica pequena”. Desde o início da eletrônica

digital e da indústria de computadores, houve uma tendência persistente e consistente da redução do tamanho dos circuitos eletrônicos e digitais. Inicialmente era possível fabricar e empacotar em uma única pastilha apenas um pequeno número de portas lógicas ou células de memória. Com o passar do tempo, foi possível empacotar mais e mais componentes em uma mesma pastilha. Esta é uma das mais notáveis tendências tecnológicas registradas e reflete a famosa Lei de Moore, proposta por Gordon Moore, um dos fundadores da Intel. Moore observou que o número de transistores que podiam ser impressos em uma única pastilha dobrava a cada ano e previu, corretamente, que esse crescimento permaneceria em um futuro próximo. Para a surpresa de muitos, inclusive de Moore, esse crescimento continuou, ano após ano e década após década. Nos anos 70, a taxa de crescimento diminuiu, com a duplicação ocorrendo a cada 18 meses, mas estabilizou-se desde então.

1.7 – Quarta Geração de Computadores - VLSI

O termo VLSI (Very Large Scale Integration), integração em larga escala, caracteriza uma classe de dispositivos eletrônicos capazes de armazenar, em um único invólucro, milhares e até milhões de diminutos componentes. Este dispositivo, já anteriormente mencionado e denominado pastilha vem constituindo a base da estrutura de todos os principais sistemas de computação modernos.

A técnica de miniaturização de componentes eletrônicos

ou microeletrônica conduziu, por volta de 1970, ao desenvolvimento de um outro tipo de computadores até então inexistente no mercado, os computadores pessoais ou microcomputadores.

A evolução dos microcomputadores, decorrente

principalmente do avanço da miniaturização dos processadores e demais elementos, vem sendo de tal forma rápida e eficiente que os computadores de maior porte foram sendo progressivamente substituídos nas empresas, restando hoje um nicho de mercado bem pequeno e específico para aquelas máquinas. Atualmente, pode-se afirmar que a maioria dos sistemas de computação utilizados no mundo comercial e governamental é baseada em microcomputadores, assim como o imenso universo dos computadores pessoais.

Em 1971, a Intel produziu a primeira CPU em uma só pastilha de circuito integrado,

denominada INTEL-4004. Esta CPU que se destinava à uma calculadora, possuía palavra de 4 bits e tinha cerca de 2300 transistores na pastilha. Logo em seguida, a Intel lançou um novo microprocessador, desta vez com 8 bits de palavra e 16 K de memória, o INTEL 8008.



Tanto o 4004 quanto o 8008 eram CPU destinadas a uma aplicação específica (o 8008 destinava-se à Display Terminals Corporation, para servir de controlador de um monitor de vídeo). Embora

a empresa solicitante da pastilha nunca tivesse usado o 8008, a Intel vendeu uma quantidade não esperada dessa pastilha, mesmo com os problemas de pouca memória e pequeno conjunto de instruções. Então em 1973, a Intel lançou o seu grande sucesso da época, o primeiro microprocessador de emprego geral do mundo, o Intel 8080. O 8008 possuía cerca de 3500 transistores encapsulados na pastilha, enquanto o 8080 tinha em torno de 5000 transistores. Este último possuía também 8 bits de tamanho de palavra, capacidade maior de memória e um grande conjunto de instruções. O 8080 vendeu aos milhões e desde então a Intel não parou mais de crescer e desenvolver novos produtos (o processador pentium tem cerca de 3,5

milhões de transistores) Na realidade, os computadores pessoais surgiram com o lançamento do Altair, que pode ser

considerado o primeiro computador pessoal oferecido com fins comerciais, auxiliando sobremodo o início da revolução que os microcomputadores realizaram desde então. Esse microcomputador, construído pela empresa MITS, baseava-se no microprocessador INTEL 8080 e utilizava um interpretador da linguagem Basic, desenvolvido por Bill Gates e Paul Allen, que fundaram nessa ocasião a Microsoft, tornando-se o gigante atual. O Altair foi um verdadeiro sucesso comercial.

Desde o surgimento dos primeiros

microprocessadores fabricados pela Intel até os dias atuais a evolução da microeletrônica e da tecnologia de fabricação e montagem de componentes e equipamentos completos tem sido constantemente e extraordinariamente rápida. A quantidade de inovações e marcos nesse desenvolvimento é enorme, conteúdo de livros inteiros.

Para encerrar este texto, devemos

mencionar algumas observações sobre outros fabricantes, além da Intel, que têm contribuído sobremaneira para o aperfeiçoamento e crescimento do mercado da microcomputação.

A Motorola é um desses fabricantes que a partir do lançamento de seu processador MC6800

de 8 bits, em 1974, também não parou de evoluir. Em 1979 a Motorola inovou, lançando o microprocessador MC68000, já de 32 bits de palavra (a Intel lançou seu primeiro processador de 32 bits, o Intel 80386, somente em 1985, seis anos depois), mas não conquistou o mercado, como era esperado.

Outro fabricante de processadores e demais componentes para o mercado de

microcomputadores é a AMD (Advanced Micro Devices) criada em 1974 para concorrer diretamente com a Intel. Além da AMD, pode-se mencionar como empresas relevantes na área de equipamentos de computação a Sun MicroSystems, a Compaq, a Dell e a Gateway. Acompanhe na próxima seção um breve resumo contendo os fatos mais importantes na evolução dos sistemas de computação.



1.8 – Evolução da Informática

Período Evento 500 a.C. Invenção e utilização do ábaco 1642 d.C. Blaise Pascal cria sua máquina de somar 1670 Gottfried Leibniz cria uma máquina de calcular que realiza as quatro operações

matemáticas 1823 Charles Babbage cria a máquina de diferenças, por contrato com a Marinha Real

Inglesa 1842 O mesmo Babbage projeta uma máquina analítica para realizar cálculos 1889 Herman Hollerith inventa o cartão perfurado 1890 Hollerith desenvolve um sistema para registrar e processador os dados do censo 1924 Constituição da IBM 1946 Término da construção do ENIAC 1946 John von Neumann propõe que um programa seja armazenado no computador e

projetao IAS, implementando sua proposta 1951 Termina a construção do primeiro computador comercial de propósito geral, o

UNIVAC 1957 Uma equipe da IBM, liderada por John Bachus, desenvolve a primeira linguagem de

alto nível, Fortran, voltada para solucionar problemas matemáticos 1958 A IBM lança o IBM-7090 1958 Jack Kilby, na Texas Instruments, completa a construção do primeiro circuito

integrado, contendo cinco componentes 1962 Douglas Engelbart, no Standford Research Institute, inventa o mouse 1964 A IBM lança o IBM 360, o primeiro computador a utilizar circuitos integrados 1964 Thomas Kurtz desenvolve a linguagem Basic no Dartmouth College 1965 Criação da Lei de Moore 1965 A IBM fabrica o primeiro floppy disk 1967 Lançamento da primeira versão do sistema operacional UNIX 1970 A linguagem Pascal é projetada por Nicklaus Wirth 1971 A Intel lança o primeiro sistema de microcomputador, baseado no processador 4004 1971 Dennis Ritchie, do Bell Labs, desenvolve a linguagem C 1972 Gary Kildall escreve um sistema operacional na linguagem PL/M e o denomina CP/M 1973 A Intel lança o processador 8080 de 2Mhz 1975 Steve Wozniak e Steve Jobs formam a Apple Computer 1976 Surge a primeira planilha eletrônica, Visicalc 1977 A IBM anuncia o IBM-PC 1979 A Apple apresenta o seu primeiro computador do tipo Macintosh 1981 A Microsoft lança sua planilha Excel 1984 A Microsoft lança seu sistema operacional Windows para IBM-PCs 1987 Lançamento do Windows 3.0 1989 A AMD lança um clone do Intel 386 1992 Linus Torvalds desenvolve o Linux 1994 A Iomega lança o ZIP Drive 1995 Inicia-se o contencioso entre a Microsoft e o governo dos EUA, que dura até os dias

atuais 1998 A Compaq adquire a DEC.



Exercícios 01 – O século passado foi marcado por várias invenções que objetivavam auxiliar o homem na realização das mais diversas tarefas. Uma destas invenções é a chamada máquina ENIGMA. Qual o objetivo dos alemães ao criarem esta máquina? 02 – Sobre as afirmativas a seguir, é incorreto afirmar que: (assinale a alternativa incorreta) a) O conceito de efetuar cálculos com algum tipo de equipamento data, pelo menos, do século V a.C. com

os babilônios e sua invenção do ábaco. b) Blaise Pascal desenvolveu uma calculadora mecânica para auxiliar na preparação dos impostos de seu

pai. c) Charles Babbage viveu na Espanha em uma época em que tabelas matemáticas eram usadas em

navegação e trabalho científico. d) Durante a Segunda Guerra, Alan Turing foi o mais proeminente especialista em criptografia da

Inglaterra e) O ENIAC era capaz de executar 5 mil adições por segundo 03 – No modelo de Von Neumann, a unidade central de processamento (CPU) é composta pela unidade lógica e aritmética e pela unidade de controle. Explique a função destes dois dispositivos. 04 - O programa armazenado é o aspecto mais importante do modelo de Von Neumann. Um programa é armazenado na memória e pode ser manipulado como se fosse um dado. Isso possibilitou o desenvolvimento de compiladores e sistemas operacionais. Dentro de um sistema de computação, qual a função de um compilador e de um sistema operacional? 05 – O barramento do sistema é composto pelo barramento de dados, barramento de endereços e pelo barramento de controle. Explique a função de cada um destes barramentos. 06 - Por que o transistor representou uma evolução na tecnologia de construção dos computadores, quando comparado às válvulas? 07 – Considere as alternativas a seguir: I. O UNIVAC I foi o primeiro computador comercial de sucesso II. O transistor foi inventado na Microsoft Corporation em 1974 revolucionando a indústria eletrônica III. Os computadores da segunda geração utilizavam linguagens de programação de baixo nível IV. A Digital Equipment Corporation foi fundada em 1957 e lançou o computador PDP-1 Estão corretas as alternativas (assinale a alternativa correta) a) I e II b) I e III c) III e IV d) II e IV e) I e IV 08 – Em um sistema de computação, qual a função de um multiplexador?



09 – Em que consiste o conceito de LSI (Large Scale Integration)? 10 - Em 1964 a IBM se utilizou das inovações tecnológicas na área da microeletrônica e lançou a sua família de computadores, a série 360. Este sistema incorporou diversas novidades, como por exemplo, o emprego de uma técnica chamada de multiprogramação. Em que consiste esta técnica? 11- Os computadores pessoais surgiram com o lançamento do Altair, que construído pela empresa MITS e utilizava um interpretador da linguagem Basic. Em que um interpretador difere de um compilador? 12 – Qual o valor final para as alternativas a seguir, relacionadas à evolução dos sistemas de computação, considerando apenas as corretas? (01) Em 1670 Leibniz cria uma máquina de calcular que realiza as quatro operações matemáticas (02) Em 1889 Herman Hollerith inventa o cartão perfurado (04) A linguagem Fortran foi desenvolvida em 1971 (08) Em 1965 é criada a lei de Moore (16) O disquete é criado em 1985 (32) Steve Wozniak e Steve Jobs formam a Apple Computer em 1975 Soma: 13 – Cite exemplos de dispositivos de entrada e dispositivos de saída.



2- Representação das Informações

2.1 – Bits, caracteres, bytes e palavras

Toda informação introduzida em um computador (sejam dados que serão processados ou instruções de um programa) precisa ser entendida pela máquina, para que possa ser corretamente interpretada e processada.

O computador, sendo um equipamento eletrônico, armazena e movimenta as informações

internamente sob forma eletrônica; esta forma pode ser um valor de voltagem ou de corrente (sabemos também que na memória secundária as informações são armazenadas sob forma magnética ou óptica).

Para que esta máquina pudesse representar eletricamente todos os símbolos utilizados na

linguagem humana, seriam necessários mais de 100 diferentes valores de voltagem (ou de corrente). Tal máquina certamente seria difícil de ser construída para fins comerciais e, possivelmente, teria confiabilidade muito baixa (uma das grandes desvantagens do primeiro computador eletrônico construído, o ENIAC, foi justamente o fato de ser uma máquina decimal, o que foi imediatamente corrigido a partir da máquina seguinte, o IAS que já era um computador binário).

No caso do IAS, optou-se por uma máquina

binária já que Von Neumann e sua equipe consideraram que seria muito mais simples e confiável projetar um circuito capaz de gerar e manipular o menor número possível de valores distintos, isto é, capaz de entender apenas dois valores diferentes: 0 e 1. Além disso, com uma máquina binária, torna-se mais simples o emprego da lógica booleana.

Dessa forma, os computadores digitais (que

trabalham com valores discretos) são totalmente binários. Toda informação introduzida em um computador é convertida para a forma binária, através do emprego de um código qualquer de armazenamento.

As linguagens utilizadas pelos humanos, como o português, possuem uma estrutura de

informação criada para permitir a construção dos elementos necessários à comunicação entre pessoas, seja no formato falado seja no escrito. Assim é que nos comunicamos uns com os outros através de trechos do conjunto de elementos disponíveis na nossa linguagem, como os caracteres e as palavras, unindo-os de acordo com as regras de construção estabelecidas (léxica e de sintaxe).

A menor unidade de informação armazenável em um computador é o algarismo binário ou

dígito binário conhecido como bit (contração das palavras inglesas binary digit). O bit pode então assumir somente dois valores: 0 e 1.

Da mesma forma que na nossa linguagem a menor unidade de informação (o caractere)

pouco ou nada significa como informação útil, em computação, com possibilidades tão limitadas, o bit pouco pode representar isoladamente; por essa razão, as informações manipuladas por um computador são codificadas em grupos ordenados de bits, de modo a terem um significado útil.



O menor grupo ordenado de bits que pode representar uma informação em computador é o caractere da linguagem dos humanos, justamente a menor unidade de informação das nossas linguagens. Qualquer caractere a ser armazenado em um sistema de computação é convertido em um conjunto de bits previamente definido para o referido sistema (chama-se código de representação de caracteres).

A primeira definição formal atribuída a um grupo ordenado de bits, para efeito de

manipulação interna mais eficiente, foi instituída pela IBM e é, atualmente, utilizada por praticamente todos os fabricantes de computadores. Trata-se do byte, definido como um grupo ordenado de oito bits, tratados de forma individual, como unidade de armazenamento e transferência.

O byte foi definido para servir de elemento de referência para a construção e funcionamento

dos dispositivos de armazenamento e também como referência para os processos de transferência de dados entre periféricos. É importante observar que na utilização do termo byte em citações sobre a capacidade de memória, verificamos a inclusão dos termos K, M e G. Tais termos são letras indicativas de um valor numérico fixo, utilizado para reduzir a quantidade de algarismos representativos de um número. Nas grandezas métricas, usa-se o K para representar mil vezes.

Como os computadores são máquinas binárias, todas as indicações numéricas referem-se a

potências de 2 e não a potências de 10 como no sistema métrico e, por essa razão o K representa 1024 unidades (210), o M (abreviatura do termo mega) representa 1.048.576 unidades (210x210) e o giga, representado pelo caractere G, indica um valor igual a 1024 mega ou 1.073.741.824 unidades (210x210x210). Observe a tabela:

1 Kbyte 1024 bytes 210 1 Mbyte 1.048.576 bytes 210x210 1 Gbyte 1.073.741.824 bytes 210x210x210

Com o progressivo aumento da capacidade dos dispositivos de armazenamento dos

computadores, criaram-se mais dois elementos para abreviar valores mais elevados: trata-se do termo tera, para representar um valor igual à 240, ou 1024 Gbytes, e do peta para representar 250 ou 1024 teras (e certamente em um futuro próximo estaremos usando outras abreviaturas mais poderosas).

Também em computação criou-se o conceito de palavra. Assim além do bit e do byte, temos

o conceito relacionado como armazenamento e a transferência de informações entre a memória principal e a CPU. Inicialmente podemos definir a palavra como um conjunto de bits que representa uma informação útil para os computadores.

A palavra nos computadores é um valor fixo e constante para um processador (32 bits, por

exemplo, para os processadores Pentium), diferentemente das linguagens dos humanos onde as palavras têm quantidades variáveis de caracteres.

De um modo geral, usam-se dois valores diferentes: um relacionado à unidade de

armazenamento – o byte (oito bits é o valor mais comum) e outro para indicar a unidade de transferência de processamento – a palavra (que na quase totalidade de computadores possui um número de bits múltiplos de 1 byte – 16, 32 ou 64 bits). Em geral, a CPU processa valores representados por uma quantidade de bits igual à da palavra, indicando assim a capacidade de processamento do sistema.



2.2 - Notação Posicional

Desde os primórdios da civilização, o homem vem adotando formas e métodos específicos para representar números, tornando possível, com eles, contar objetos e efetuar operações aritméticas.

A forma mais empregada de representação numérica é a chamada notação posicional. Nela,

os algarismos componentes de um número assumem valores diferentes, dependendo de sua posição relativa no número. O valor total do número é a soma dos valores relativos de cada algarismo. Assim, é a posição do algarismo ou dígito que determinada o seu valor.

A formação de números e as operações com eles efetuadas dependem, nos sistemas

posicionais, da quantidade de algarismos diferentes disponíveis no referido sistema. Há muito tempo a cultura ocidental adotou um sistema de numeração que possui dez diferentes algarismos – 0,1,2,3,4,5,6,7,8,9 - e por essa razão foi chamado de sistema decimal.

A quantidade de algarismos disponíveis em um dado sistema de numeração é chamada de

base; a base serve para contarmos grandezas maiores, indicando a noção de grupamento. O sistema de dez algarismos mencionado anteriormente tem base 10; outro sistema que possua apenas dois algarismos diferentes (0 e 1) é de base 2, e assim por diante.

Vamos exemplificar o conceito de sistema posicional. Seja o número 1303, representado na

base 10, escrito da seguinte forma:

130310 Em base decimal, por ser mais usual, costuma-se dispensar o indicador da base, escrevendo-

se apenas o número: 1303. Note que neste exemplo o número é composto pelos algarismos 1,3,0 e 3, e cada algarismo possui um valor correspondente à sua posição no número.

Desta maneira, o primeiro 3 (algarismo mais à direita) representa 3 unidades. Neste caso, o

valor absoluto do algarismo é igual ao seu valor relativo por se tratar da 1a posição. Considerando-se o produto três vezes a potência de 0 da base 10 ou

3 x 100 = 3 enquanto o segundo 3 vale três vezes a potência 2 na base 10 ou 3 x 102 = 300 e o último à esquerda vale 1 vez a potência 3 na base 10 ou 1 x 103 = 1000 Desta maneira, o valor total do número seria então: 1000 + 300 + 0 + 3 = 130310 1 x 103 + 3 x 102 + 0 x 101 + 3 x 100



2.3 - Outras Bases de Numeração Entre as bases diferentes de 10, consideremos apenas as bases 2 e potências de 2, visto que

todo computador digital representa internamente as informações em algarismos binários, ou seja, trabalha na base 2. Como os números representados em base 2 são muito extensos (quanto menor a base de numeração, maior é a quantidade de algarismos necessários para indicar um dado valor) e, portanto, de difícil manipulação visual, costuma-se representar externamente os valores binários em outras bases de valor mais elevado. Isso permite maior compactação de algarismos e melhor visualização dos valores. Em geral, usam-se as bases octal ou hexadecimal.

A base do sistema binário é 2 e, consequentemente, qualquer número, quando representado

nesse sistema consiste exclusivamente em dígitos 0 e 1. O termo dígito binário é chamado bit, contração do termo inglês binary digit. Por exemplo, o número binário 11011 possui cinco dígitos ou algarismos binários. Diz-se que o referido número é constituído de 5 bits.

Em bases de valor superior a 10, usam-se letras do alfabeto para a representação de

algarismos maiores que 9. Uma dessas bases é especialmente importante em computação – trata-se da base 16 ou hexadecimal, por ser de valor potência de 2 (como a base 8). Nessa base, os “algarismos” A,B,C,D,E e F representam, respectivamente, os valores (da base 10): 10,11,12,13,14 e 15. Na base 16 (hexadecimal) dispomos de 16 algarismos (não números) diferentes:

0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F Um número nessa base é representado como 1A7B16. O seu valor na base 10 será obtido da

seguinte maneira: 1 x 163 + 10 x 162 + 7 x 161 + 11 x 160 = 4096 + 2560 + 112 + 11 = 677910 Em outras palavras, utilizamos valores e regras de aritmética da base 10 e, por isso, o

resultado encontrado é um valor decimal. A tabela a seguir mostra a representação de números nas bases 2, 8, 10 e 16.

Base 2 Base 8 Base 10 Base 16 0 0 0 0 1 1 1 1

10 2 2 2 11 3 3 3

100 4 4 4 101 5 5 5 110 6 6 6 111 7 7 7

1000 10 8 8 1001 11 9 9 1010 12 10 A 1011 13 11 B 1100 14 12 C 1101 15 13 D 1110 16 14 E 1111 17 15 F



2.4 - Conversão de Bases

Uma vez entendido como representar números em notação posicional, e como esta notação é aplicável em qualquer base inteira, podemos exercitar a conversão de números de uma base para outra. Neste item vamos dar ênfase à conversão entre as bases binária e decimal.

2.4.1 – Conversão de Base Decimal para Base Binária

A conversão é obtida dividindo-se o número decimal pelo valor da base desejada (no caso, base 2); o resto encontrado é o algarismo menos significativo do valor na base 2 (mais à direita). Em seguida, divide-se o quociente encontrado pela base 2; o resto é o algarismo seguinte (à esquerda); e assim sucessivamente, vão-se dividindo os quocientes pelo valor da base até se obter quociente de valor zero. Em cada divisão, o resto encontrado é um algarismo significativo do número na nova base; o primeiro resto encontrado é o valor do algarismo menos significativo (mais à direita), e o último resto será o algarismo mais significativo (mais à esquerda). Observe:

45 / 2 = 22 resto = 1 (algarismo menos significativo, mais à direita) 22 / 2 = 11 resto = 0 11 / 2 = 05 resto = 1 05 / 2 = 02 resto = 1 02 / 2 = 01 resto = 0 01 / 2 = 00 resto = 1 (algarismo mais significativo, mais à esquerda) Desta maneira, o número 45 na base decimal corresponde a 101101 em binário.

2.4.2 – Conversão de Base Binária para Base Decimal

O processo de conversão de uma base binária para decimal consiste em multiplicar cada dígito do número pelo valor de sua base elevada à posição que ocupa no próprio número. Acompanhe o processo inverso ao mostrado no item anterior:

101101 = 1 x 25 (32) + 0 x 24 (00) + 1 x 23 (08) + 1 x 22 (04) 0 x 21 (00) + 1 x 20 (01) =

45



Exercícios 01 – Converta para binário os seguintes números decimais: a) 120 b) 97 c) 234 d) 46 e) 39 f) 183 02 – Considerando os números binários a seguir, encontre qual o seu correspondente no sistema decimal. a) 10101010 b) 10001001 c) 11001100 d) 10000111 e) 11011101 f) 10011010 03 – Complete a tabela:

Decimal Binário Decimal Hexa Decimal 100 ( + ) ( = ) 130 ( - ) ( = ) 70

( x ) 110 ( = ) 90 ( + ) 19 ( = ) 50 ( : ) 11001 ( = ) ( + ) A ( = ) 73 ( - ) ( = ) 40 ( x ) 14 ( = )



3- Conceitos da Lógica Digital

3.1 – Introdução

Conforme já comentado anteriormente, um computador digital é uma máquina projetada para armazenar e manipular informações representadas apenas por algarismos ou dígitos e que só podem assumir dois valores distintos, 0 e 1, razão por que é chamado computador digital, sistema digital ou simplesmente máquina digital binária. Como na prática não há máquinas digitais não-binárias, como, por exemplo, máquinas digitais decimais, é mais usual simplificar-se o termo, usando apenas computador digital (a palavra binário fica implícita).

A informação binária é representada em um sistema digital por quantidades físicas, sinais

elétricos, os quais são gerados e mantidos internamente ou recebidos de elementos externos, em dois níveis de intensidade, cada um correspondente a um valor binário.

A figura abaixo mostra um exemplo de valores elétricos de sinais binários, sendo escolhido

um sinal de +3V para representar o bit 1 e + 0,5 V para representar o valor binário 0. Como se observa na figura, cada valor tem uma faixa de tolerância, tendo em vista que nenhum sinal é sempre absolutamente preciso em seu valor.

Internamente, um computador é constituído

de elementos eletrônicos, como resistores, capacitores e principalmente transistores. Nesses computadores, os transistores são, em geral, componentes de determinados circuitos eletrônicos que precisam armazenar os sinais binários e realizar certos tipos de operações com eles. Esses circuitos, chamados circuitos digitais, são formados de pequenos elementos capazes de manipular grandezas apenas binárias. Os pequenos elementos referidos são conhecidos como portas (gates) lógicas, por permitirem ou não a passagem desses sinais, e os circuitos que contêm as portas lógicas são conhecidos como circuitos lógicos.

Uma porta é então um elemento de hardware (é um circuito eletrônico) que recebe um ou mais sinais de entrada e produz um sinal de saída, cujo valor é dependente do tipo de regra lógica estabelecida para a construção do referido circuito.

Em resumo, um computador digital é construído contendo uma infinidade de circuitos

lógicos ou portas, convenientemente distribuídos e organizados, de modo que alguns servirão para armazenamento de valores, outros permitirão e controlarão o fluxo de sinais entre os componentes e outras, ainda, serão utilizadas para realizar operações matemáticas.

O projeto de circuitos digitais e a análise de seu comportamento em um computador podem

ser realizados através do emprego de conceitos e regras estabelecidas por uma disciplina conhecida como Álgebra de Chaveamentos (Switching Algebra), que é um ramo da álgebra booleana.



3.2 – Álgebra Booleana

Em 1854, George Boole publicou seu trabalho seminal sobre uma álgebra para representação lógica. Boole estava interessado em capturar a matemática do pensamento e desenvolveu uma representação para informação factual como, por exempo, “a porta está aberta” ou “a porta não está aberta”. A álgebra de Boole foi estendida por Shannon até a forma que usamos hoje. Em álgebra booleana consideramos a existência de um postulado básico, que uma variável binária recebe um valor único de 0 ou 1. Este valor corresponde às voltagens mencionadas anteriormente. Com o objetivo de se entender o comportamento de circuitos digitais, podemos abstrair da correspondência física as voltagens e considerar somente os valores simbólicos de 0 e 1.

Uma contribuição importante de Boole é o desenvolvimento de tabelas-verdade que

capturam os relacionamentos lógicos em uma forma tabular. Em uma tabela verdade, todas as possíveis combinações de variáveis binárias são enumeradas e um valor de saída correspondente a 0 ou 1 é atribuído para cada combinação das entradas.

Entradas Saída

A B Z 0 0 1 0 1 0 1 0 0 1 1 1

Cada operação lógica possui sua própria tabela verdade, estabelecida de acordo com a regra

que define a respectiva operação lógica. Uma tabela verdade tem tantas linhas de informação quantas são as possíveis combinações de valores de entrada, o que pode variar conforme a quantidade de diferentes valores de entrada que se tenha. Assim se tivermos apenas um valor de entrada, então a saída só pode assumir dois valores (já que a variável de entrada só pode assumir dois valores distintos, 0 ou 1) e, nesse caso, a tabela verdade teria duas linhas, uma para a entrada igual a 0 e outra para a entrada igual a 1. Se, por outro lado, fosse definidas duas entradas, então haveria quatro possíveis combinações dos valores de entrada (00,01,10 e 11), pois 22 = 4 e a tabela verdade possuiria quatro linhas e assim por diante.

3.2.1 – Operação Lógica ou Porta AND (E)

A porta AND é definida como o elemento (ou operação lógica) que produz um resultado verdade na saída, se e somente se todas as entradas forem verdade. Essa definição por ser expressa pela tabela verdade e símbolos mostrados na figura a seguir.

Entradas Saída (A . B)

A B Z 0 0 0 0 1 0 1 0 0 1 1 1

Operações lógicas AND podem ser realizadas para satisfazer um determinado requisito de hardware ou para atender a uma especificação de um programador em um programa. Para tanto, a maioria dos processadores possui uma instrução de máquina AND em seu conjunto de instruções.



3.3 – Operação Lógica ou Porta OR (OU)

A porta OR é definida para produzir um resultado verdade na sua saída, se pelo menos uma das entradas for verdade. Esta definição pode ser expressa pela tabela verdade e símbolos mostrados na figura a seguir.

Entradas Saída (A + B)

A B Z 0 0 0 0 1 1 1 0 1 1 1 1

Operações lógicas OR também são largamente utilizadas em lógica digital ou na definição

de condições em comandos de decisão de certas linguagens de programação.

3.3.1 – Operação Lógica NOT (Inversor)

A operação lógica NOT é também chamada de inversor ou função complemento. Ela inverte o valor de um sinal binário colocado em sua entrada, produzindo na saída o valor oposto. É um circuito lógico que requer apenas um valor na entrada. A figura a seguir mostra um circuito inversor, bem como os símbolos utilizados e a respectiva tabela verdade.

Entrada Saída (A)

A Z 0 1 1 0

É interessante observar que a conexão de dois circuitos inversores em série produz na saída

um resultado de valor igual ao da entrada. Ou seja, um duplo complemento restaura o valor original. Uma das aplicações mais comuns do circuito inversor é justamente em operações aritméticas em ponto fixo, quando se usa aritmética de complemento.

3.3.2 – Operação Lógica NAND – NOT AND

A operação lógica ou porta NAND é definida como o complemento da porta AND, isto é, a saída de um circuito lógico NAND é obtida ao se aplicar a regra da operação lógica AND e inverter o resultado.

Entradas Saída (A . B)

A B Z 0 0 1 0 1 1 1 0 1 1 1 0



A porta NAND produzirá uma saída falsa se e somente se todas as entradas forem verdade. Do contrário, a saída será verdade se, pelo menos, uma entrada for falsa. É muito comum encontrar esta porta em complexos circuitos lógicos, visto que é possível simplificar a fabricação de circuitos lógicos e reduzir a quantidade de componentes eletrônicos se usarmos apenas circuitos NAND.

3.3.3 – Operação Lógica NOR – NOT OR

Assim como a porta NAND, a porta NOR é o complemento ou o inverso da porta OR. A saída de um circuito lógico NOR é obtida ao se efetuar a operação lógica OR sobre as entradas e inverter o resultado. Também esta operação lógica (NOR) é realizada em dois passos: primeiro a operação OR e, em seguida, a inversão (ou operação NOT) do resultado.

Entradas Saída (A+ B)

A B Z 0 0 1 0 1 0 1 0 0 1 1 0

A porta NOR apresentará uma saída verdade se e somente se todas as entradas forem falsas.

Caso contrário, a saída será falsa. É possível projetar circuitos lógicos mais complexos utilizando apenas portas NOR, de modo semelhante ao que já foi mostrado para o caso de portas NAND.

3.3.4 – Operação Lógica XOR – EXCLUSIVE OR

A operação lógica XOR pode ser considerada um caso particular da função OR, ou seja, a saída será verdade se exclusivamente uma ou outra entrada for verdade.

Entradas Saída (A ⊕ B)

A B Z 0 0 0 0 1 1 1 0 1 1 1 0

O XOR é um elemento lógico bastante versátil, aparecendo em diversos locais e com

diferentes utilidades em circuitos digitais. Além disso, esta particularidade dos circuitos XOR permite que se fabrique um testador de igualdade entre valores, por exemplo, para testar de modo rápido se duas palavras de dados são iguais. Se as duas palavras forem iguais, as saídas do circuito XOR serão todas falsas.

3.4 – Expressões Lógicas

Uma expressão lógica ou função lógica pode ser definida como uma expressão algébrica formada por variáveis lógicas binárias, por símbolos representativos de uma operação lógica, por parênteses e por um sinal de igualdade. Por exemplo:

Z = X + Y.W



O valor do resultado de uma expressão lógica pode ser obtido, por uma tabela verdade construída com todas as possibilidades de entrada e as correspondentes saídas. Uma boa maneira de avaliar expressões lógicas consiste em construir a tabela verdade final da expressão através da obtenção de todas as possibilidades de forma progressiva, operando por operando até chegarmos ao valor da função para cada possibilidade. Observe:

Entradas Saída X Y W Z 0 0 0 0 0 0 1 0 0 1 0 0 0 1 1 1 1 0 0 1 1 0 1 1 1 1 0 1 1 1 1 1

Expressões lógicas podem ou não conter parênteses; quando contêm, eles têm a mesma

prioridade para o cálculo que parênteses de equações algébricas comuns. A prioridade de cálculo de uma operação AND é maior do que a do cálculo de uma operação OR, semelhante ao que temos na aritmética comum, em que a multiplicação tem prioridade sobre a adição.

Observe a seguir, o diagrama lógico da função Z

3.5 - Circuitos Combinatórios Após analisarmos cada porta individualmente (sua definição e os resultados obtidos com o

emprego da tabela verdade de cada uma) e termos conhecido as regras que servem de alicerce à álgebra booleana e seu emprego para simplificação de expressões lógicas, podemos verificar como é possível interligar as diversas portas, de modo a construir redes lógicas, também chamadas de circuitos combinatórios.

Um circuito combinatório consiste em uma interconexão de portas lógicas, cujo sinal de

saída é, em qualquer instante, função apenas de sinais de entrada naquele instante. Assim como em uma porta simples, a alteração de sinais de entrada é quase imediatamente seguida pela alteração correspondente no sinal de saída, apenas como retardo devido à transmissão de sinais por meio das portas do circuito.

Em termos gerais, um circuito combinatório consiste de n entradas binárias e m saídas

binárias. Assim como uma porta, um circuito combinatório pode ser definido de três formas:



� Tabela verdade: para cada uma das possíveis combinações dos n sinais de entrada, é listado o valor binário de cada um dos m sinais de saída.

� Símbolos gráficos: esquema de conexão das portas lógicas. � Equações booleanas: cada sinal de saída é expresso como uma função booleana dos sinais de

entrada.

Na verdade, se estivermos perante um circuito lógico combinatório, poderemos sempre fazer a sua tabela verdade, relacionando assim as suas entradas com as suas saídas. Sendo assim, todas as portas lógicas e funções lógicas que foram anteriormente estudadas são circuitos combinatórios. Note que a figura ao lado representa o circuito combinatório do diagrama lógico apresentado no item anterior.

A CPU de um computador é composta por vários circuitos combinatórios. Circuitos

combinatórios são a base para muitos dos componentes de um sistema de computação básico. Podemos construir circuitos para soma, subtração, comparação, multiplicação, divisão e muitas outras operações usando a lógica combinatória.

3.6 - Circuitos Integrados

Após a primeira parte do processo, o projeto de um circuito combinatório, completa-se esta tarefa com a implementação física do circuito através da fabricação dos elementos e integrando-os em um só dispositivo (encapsulando-o), com o propósito de redução de espaço e custo, isto é, construindo um circuito integrado.

Um circuito integrado é um pequeno dispositivo, denominado pastilha (chip) que contém em

seu interior centenas e atualmente milhares de componentes eletrônicos: transistores, diodos, resistores, capacitores e suas interligações. Estes componentes são os formadores das portas lógicas que, interligadas,

formam um determinado circuito combinatório. A pastilha é encapsulada em um

pacote de cerâmica ou plástico e as conexões com o exterior são soldadas aos pinos externos para completar o dispositivo.

É possível se construir pastilhas com

pequena quantidade de portas lógicas até pastilhas de uma CPU contendo milhões de transistores. Pastilhas de CI podem ser fabricadas com diferentes quantidades de pinos. Os fabricantes de CI costumam identificar cada um por um número, além da função à qual se destinam, e os fabricantes de sistemas de computação adquirem então estes CI de acordo com suas necessidades, para serem inseridos nas placas de circuito impresso. Este processo tira um pouco da flexibilidade do fabricante de sistemas de

computação, visto que ele deve projetar seu sistema usando as pastilhas que já existem no mercado e não fazendo, talvez tudo o que desejaria para o referido sistema.



No entanto, apesar deste inconveniente, isso ainda é mais vantajoso do que o próprio fabricante do computador ter que verticalizar, projetando e construindo todas as pastilhas necessárias.

É comum classificar pastilhas pela quantidade de integração que elas suportam, isto é, a

quantidade de portas lógicas. SSI (Small Scale Integration) – Integração em pequena escala constituída de 1 a 10 portas. Poucos pinos. MSI (Medium Scale Integration) – Integração em média escala constituída de até 100 portas. Tem também poucos pinos. Circuitos desse tipo costumam ser usados para a construção de pequenos dispositivos, como multiplicadores e contadores. LSI (Large Scale Integration) – Integração em larga escala, constituída de até 100.000 portas. Normalmente são processadores completos. VLSI (Very Large Scale Integration) – Integração em muito larga escala. É costume classificar pastilhas com até 100.000 portas como LSI e, acima desta quantidade, como VLSI. Para se ter uma idéia, o processador Intel 80486 possuía cerca de 1,2 milhão de transistores em uma única pastilha, com 168 pinos, enquanto o processador Pentium possuía cerca de 3,1 milhões de transistores. Note que este valor era para as primeiras versões do processador, pois os atuais modelos possuem muito mais transistores na pastilha com cerca de 273 pinos.

Exercícios 01 – Considerando as alternativas a seguir, assinale a alternativa incorreta: a) Um computador digital é uma máquina projetada para manipular informações representadas apenas por

dígitos que só podem assumir dois valores distintos 0 e 1 b) Internamente, um computador é constituído de resistores, capacitores e transistores c) A informação binária é representada em um sistema digital por sinais elétricos em dois níveis de

intensidade d) Um computador contém uma infinidade de circuitos lógicos ou portas, convenientemente distribuídos e

organizados e) Nenhuma das alternativas anteriores



02 – A saída de uma porta AND com quatro entradas será verdade apenas se: (assinale a alternativa correta) a) Pelo menos duas portas forem verdade b) Nenhuma porta for verdade c) Pelo menos uma porta for verdade d) Todas as portas forem verdade e) Três portas forem verdade e uma porta for falsa 03 – Considerando uma porta com duas entradas, sua saída será verdade apenas quando os valores de suas portas de entrada forem diferentes. Estamos falando da função: (assinale a alternativa correta) a) AND b) OR c) NAND d) XOR e) NOR 04 – Em que consiste um circuito integrado? 05 – Calcule a tabela verdade para as seguintes operações:

a) (A + B) . C

b) (A . B) ⊕ C

c) (A . B) . ( C + D)

d) ( ( A . B ) + C )

e) ( A ⊕ B ) . C

06 - Represente, através de desenho, as expressões algébricas do item anterior. 07 - Qual a função e sua respectiva tabela verdade que representam cada um dos diagramas a seguir?

08 – Em que consiste a tecnologia VLSI?



4- Unidade Central de Processamento

4.1 - Introdução

No capítulo 01 apresentamos uma visão global da estrutura sistêmica de um computador e uma breve descrição de cada um de seus principais componentes. Neste capítulo analisaremos o processador central ou Unidade Central de Processamento (CPU), que desempenha um papel crucial no funcionamento do sistema de computação. O processador é responsável pela atividade fim do sistema, isto é computar, calcular e processar. Como já mencionamos, os processadores atuais são fabricados de modo que em um único invólucro (pastilha, chip) são inseridos todos os elementos necessários à realização de suas funções. Cada vez mais, a tecnologia tem avançado nessa área, de modo a se fabricar processadores mais complexos e poderosos contendo milhões de transistores.

4.2 – Funções Básicas

O processador central é o componente vital do sistema de computação. Na realidade, a CPU é responsável pela realização de qualquer operação realizada por um computador. Isto quer dizer que a CPU comanda não somente as ações efetuadas internamente, como também, em decorrência da interpretação de uma determinada instrução, ela emite os sinais de controle para os demais componentes do computador agirem e realizarem alguma tarefa.

Um processador tem por propósito, realizar operações com os dados (chamadas de

processamento) normalmente numéricos. Para realizar essas operações, o processador necessita, em primeiro lugar interpretar que tipo de operação é a que ele irá executar (pode ser a soma de dois números, pode ser a subtração de dois valores e assim por diante). Em seguida, antes da realização propriamente dita da operação é necessário que os dados estejam armazenados no dispositivo que irá executar a operação.

Portanto a CPU não somente realiza o processamento (executa a operação com os dados),

como também controla todo o funcionamento do sistema (busca a descrição da operação a ser realizada – chamada instrução; interpreta que tipo de operação deverá ser realizada; localiza e busca os dados que serão processados e assim por diante).

Todo processador é construído de modo a ser capaz de

realizar algumas operações, denominadas primitivas, tais como: somar, subtrair, mover um dado de um local de armazenamento para outro, transferir um valor para um dispositivo de saída etc. Essas operações e a localização dos dados que elas manipulam têm que estar representadas na única forma compreensível pelo sistema, que é uma sequência de sinais elétricos, cuja intensidade corresponde a 0s e 1s (uma sequência de bits).

A sequência de 0s e 1s que formaliza uma determinada operação a ser realizada pelo

processador denomina-se instrução de máquina. Uma instrução de máquina é a identificação formal do tipo de operação a ser realizado,

contendo um grupo de bits que identifica a operação a ser realizada e outro grupo de bits que permite a localização e acesso aos dados que serão manipulados na referida operação. Ou seja, se a operação desejada é uma soma, a instrução de máquina correspondente deve conter os bits necessários para indicar que se trata de soma e onde estão armazenados os valores que deverão ser somados.



Um programa executável é constituído de um conjunto de instruções de máquina sequencialmente organizadas. Para que a execução do referido programa tenha início, é necessário que: 1. As instruções a serem executadas estejam armazenadas em células sucessivas na memória principal; 2. O endereço da primeira instrução do programa esteja armazenado na CPU para que o processador possa

buscar essa primeira instrução.

A função do processador consiste então em:

a) Buscar uma instrução na memória (operação de leitura) uma de cada vez, cujo endereço deve estar armazenado no registrador existente na CPU e específico para este fim

b) Interpretar que operação a instrução está explicitando (soma, subtração, divisão...)

c) Buscar os dados onde estiverem armazenados d) Executar efetivamente a operação com os dados, guardar o

resultado (se houver algum) no local definido na instrução; e finalmente,

e) Reiniciar o processo buscando uma nova instrução. Estas etapas compõem o que se denomina um ciclo de instrução. Este ciclo se repete

indefinidamente até que o sistema seja desligado, ou ocorra algum tipo de erro, ou ainda, que seja encontrada uma instrução de parada. Em outras palavras, a CPU é projetada e fabricada com o propósito único de executar sucessivamente pequenas operações matemáticas (ou outras manipulações simples com dados), na ordem e na sequência definida pela organização do programa.

Os sistemas de computação modernos são montados em torno de processadores que buscam

maior velocidade na realização de suas atividades. Um dos processos mais usados para o aumento de velocidade é o que conhecemos na indústria como linha de montagem (“pipeline”), no qual a CPU se divide em várias partes funcionais distintas (estágios), cada uma correspondendo a uma determinada atividade. Dessa forma, várias instruções são realizadas de forma simultânea, embora em estágios diferentes, exatamente como ocorre em uma linha de montagem de uma montadora de automóveis.

4.3 – Componentes

Uma CPU possui, pelo menos, duas partes básicas: a Unidade de Controle (UC) e a Unidade Lógica e Aritmética (ULA). A UC é responsável por gerenciar todos os recursos do sistema, de acordo com o solicitado pelos programas. É ela que vai buscar cada uma das instruções da memória e a passa para a ULA ou para as interfaces e circuitos externos. Quando a instrução terminar de ser interpretada, a UC busca a próxima na memória. Já a ULA é responsável pelos cálculos e operações simples, como a soma e a comparação de números.



A velocidade do processador, em termos de tarefas realizadas e em função do tempo, é medida em MIPS – milhões de instruções por segundo. Não há uma padronização, mas utiliza-se comumente MIPS ou MFLOPS (milhões de instruções de ponto flutuante por segundo). Veja por exemplo a tabela com alguns processadores antigos da Intel:

Processador Intel 386 Intel 486 Pentium Pentium Pro Velocidade 5 MIPS 20 MIPS 100 MIPS 250 MIPS

A medição de desempenho pretende verificar a quantidade de trabalho que um computador

consegue realizar por unidade de tempo. Assim, é possível comparar o desempenho de várias máquinas e selecionar a mais adequada para uma determinada função.

4.3.1 – Unidade de Controle

A Unidade de Controle é responsável pelo gerenciamento de todos os recursos do computador, coordenando todas as suas atividades. Imagine a unidade de controle como se fosse um guarda de trânsito, que orienta e organiza o fluxo das informações.

Essa unidade contém uma lista de todas as operações que a CPU pode executar. Tal lista é

chamada de conjunto de instruções e fica embutida nos circuitos da unidade de controle. Cada instrução contém tarefas simples (micro-códigos) que dizem à CPU como executar determinada instrução. Assim, quando um computador executa um programa, ele procura alguns comandos que devem ser executados, na ordem indicada, pelo conjunto de instruções da CPU.

As atividades da unidade de controle podem ser resumidas nas etapas:

1. Apanhar a instrução na memória primária 2. Estabelecer as operações a serem executadas 3. Se necessário, ir buscar dados na memória ou arquivo magnético para serem processados 4. Acessar os componentes apropriados do processador conforme solicita a instrução 5. Identificar o final da operação 6. Armazenar o resultado no local indicado (memória ou arquivo magnético) 7. Por meio do contador de instruções, determinar o endereço da próxima instrução.

A maioria das CPUs existentes executa os programas repetindo uma série de três ciclos: A. Ciclo de Busca – Identificação, recuperação e análise da próxima instrução do programa (itens 1,2 e 7) B. Ciclo de Memória – Localização, leitura ou escrita de operando na memória (itens 3 e 6) C. Ciclo de Execução – Processamento dos operandos (itens 4 e 5)

O tempo gasto em cada ciclo é muito variado e depende do tipo de operação que está sendo executada. Uma operação de adição, por exemplo, é mais rápida que uma multiplicação – a qual, no fundo, engloba várias adições encadeadas.

As CPUs são fabricadas por empresas diferentes, contendo, consequentemente, conjuntos de

instruções diferentes. Em uma única empresa podem ser fabricados também diversos modelos de CPU com variados conjuntos de instruções. Assim, as CPUs são divididas em “famílias”, cada uma possuindo um conjunto de instruções semelhantes, mas não idênticas. Quando uma nova CPU é desenvolvida, ela recebe todo o conjunto de instruções de sua antecessora, com adição de algumas instruções próprias.



Isso permite que programas para algumas CPUs antigas funcionem com processadores mais novos da mesma família. Dessa forma, os processadores, mesmo com toda a nova tecnologia incluída, quase sempre são compatíveis com hardwares e softwares antigos – o que se costuma chamar de legado.

4.3.2 – Unidade Lógica e Aritmética (ULA)

A ULA é responsável pela execução de uma instrução que envolve operações aritméticas (somas e subtrações) e lógicas (testes e comparações) entre valores. Ela possui um grupo de registradores – pequenas posições de memória dentro do próprio processador para o armazenamento dos dados sendo processados no momento. Para facilitar a sua compreensão imagine uma operação em que a unidade de controle carrega dois números na memória do computador para os registradores da ULA.

A unidade de controle pede a ULA

para dividir os dois números (operação aritmética) e verificar se o resto da divisão é igual a zero (operação lógica). Percebemos então, que a ULA é na verdade uma espécie de “grande calculadora eletrônica”.

Qualquer ULA é um aglomerado

de circuitos lógicos e componentes eletrônicos que integrados realizam as operações já mencionadas. Ela pode ser uma parte pequena da pastilha do processador, usada em pequenos sistemas, ou pode compreender um considerável conjunto de componentes lógicos de alta velocidade, sendo que os processadores mais modernos utilizam em sua arquitetura mais de uma ULA de modo a tornar a execução das instruções mais rápida.

4.3.3 – Registradores

Para que um dado possa ser manipulado pela ULA, é necessário que ele fique brevemente armazenado em um registrador. O registrador armazena, temporariamente, o resultado de uma operação lógica ou aritmética feita pela ULA para que essa informação possa ser utilizada e/ou transferida para a memória.

Os registradores a seguir pertencem à tecnologia Intel x86 (ou seja, estão presentes nos

processadores dos computadores PC) e são chamados de uso geral, pois são utilizados por praticamente todas as operações que envolvam dados do usuário. Para operações de aritmética ou de lógica, qualquer um desses registradores pode ser utilizado, mas existem certos tipos de instruções que os utilizam com funções especializadas: � Registrador Acumulador (Acumulation, AX): está envolvido com operações de entrada e saída de dados; tradução de códigos entre sistemas; operações de multiplicação ou divisão que necessitam de 32 bits; ajuste de decimais e operações com decimais codificados em binário. � Registrador Base (Base, BX): é frequentemente usado para referenciar posições de memória, tanto diretamente quanto por meio de tabelas ou vetores.



� Registrador Contador (Counter, CX): utilizado em operações de contagem ou em laços de repetição (como a rotação de um conteúdo do registrador por n bits) do número de bytes ou palavras de uma string, de controle de looping etc � Registrador de Dados (Data, DX): usado em operações de multiplicação para armazenar parte de um produto de 32 bits ou em operações de divisão para armazenar o resto da operação. É também usado nas operações de entrada e saída (I/O) para especificar o endereço da porta serial ou paralela.

Esses registradores são posições de memória armazenadas no processador e que comportam dados de 16 bits, sendo também chamados word. Dependendo da aplicação, eles podem ser divididos em duas partes iguais de um byte cada. Esses registradores possuem uma parte alta “H” (high) e uma parte baixa “L” (low). Por exemplo, o registrador BX (de 16 bits) é formado pelos registradores BH e BL, de 8 bits cada, sendo BH o byte mais significativo e BL o menos significativo. Se BH contiver o valor hexadecimal AF e BL contiver C3, o valor de BX será AFC3. Já a manipulação desses registradores ocorre por meio de uma linguagem de hardware chamada assembly, que será vista nos próximos capítulos.

Nos processadores Pentium os registradores podem ser de 32 bits. Seus nomes são os

mesmos com a adição da letra E, por exemplo: • BH e BL são registradores de 8 bits • BX é um registrador de 16 bits formado por BH e BL • EBX é um registrador de 32 bits formado por BX mais uma palavra de 16 bits de mais alta ordem

Há ainda os registradores de segmento: CS (registrador de segmento de código), DS (registrador de segmento de dados), ES, FS, GS (registradores de segmento extras) e SS (registrador de segmento de pilha); bem como os índices de ponteiros SI, DI, BP, IP e SP.

Os registradores e sua disposição afetam a velocidade geral do equipamento. Nos primórdios

da família x86, cada registrador podia armazenar dois bytes (16 bits). Atualmente sua capacidade de armazenamento mudou. O tamanho dos registradores determina a quantidade de dados que o computador pode processar informações. Assim, a rapidez do processamento depende do tamanho desses registradores, isso porque não será preciso quebrar dados de 32 bits em duas ou mais operações de 16 bits, sendo possível processar dois números de 16 bits (ou quatro de oito bits) simultaneamente. Acompanhando esse raciocínio, podemos deduzir que uma CPU com registradores de 32 bits é capaz de processar duas vezes mais rápido do que uma CPU com registradores de 16 bits.

4.4 – Clock

Em muitos equipamentos digitais, a ordem em que os eventos ocorrem é crítica. Às vezes, um evento deve preceder outro, às vezes dois eventos devem ocorrer simultaneamente. Para permitir que os projetistas consigam as relações de temporização requeridas, muitos circuitos digitais usam relógios para providenciar sincronização. Neste contexto, um relógio (clock) é um circuito que emite uma série de pulsos com uma largura de pulsos precisa e intervalos precisos entre pulsos consecutivos.

O clock é um dispositivo externo ao processador (observe que

alguns processadores já possuem clock interno), localizado normalmente na placa-mãe, gerador de pulsos elétricos de freqüência constante.



Para conseguir esta precisão, a freqüência do clock normalmente é controlada por um oscilador de cristal. A duração de um pulso é chamada de ciclo. A freqüência de saída desse cristal define a velocidade do processador e do sistema como um todo, além de sincronizar todos os componentes da máquina.

A freqüência do clock é medida em hertz (Hz) que significa ciclos por segundo. Como se

tratam de freqüências elevadas abrevia-se os valores usando milhões de hertz, ou de ciclos por segundo (gigahertz ou simplesmente GHz). Essa freqüência também é utilizada como uma espécie de parâmetro de desempenho entre diferentes processadores. E quanto maior a freqüência, maior a quantidade de instruções que uma CPU pode executar em um mesmo intervalo de tempo.

Por exemplo, se um processador trabalha com seu clock pulsando 50 milhões de vezes por

segundo, sua freqüência de operação é de 50 MHz. A duração de cada ciclo é o inverso da freqüência, então cada ciclo neste exemplo será igual ao inverso de 50.000.000:

1 / 50.000.000 = 0,00000002 ou 20 nano segundos. Outros fatores, como arquitetura do sistema, existência de cache, tamanho da memória são

também importantes para o desempenho do computador. Um computador com um clock duas vezes mais rápido não é necessariamente duas vezes mais veloz.

Muitos eventos podem ocorrer dentro de um computador durante um único ciclo de relógio.

Se esses eventos devem ocorrer em uma ordem específica, o ciclo de relógio deve ser dividido em subciclos. Uma maneira comum de prover resolução superior à do relógio básico é aproveitar a linha de relógio primária e inserir um circuito com um atraso conhecido, gerando assim um sinal secundário deslocado de certa fase em relação ao primeiro. Vinculando diferentes eventos às várias fases, pode-se conseguir a sequencia requerida. Se forem necessárias mais do que quatro referências de tempo dentro de um ciclo de relógio, podem-se puxar mais linhas da linha primária, com diferentes atrasos.

Além do processador, existem outros dispositivos que necessitarão do sinal de clock como

um sinal de entrada; outros não. Os que necessitam do sinal para trabalhar são chamados de dispositivos síncronos. Do contrário, eles são classificados como dispositivos assíncronos.

4.5 – Co-processador aritmético

É também chamado de Unidade de Ponto Flutuante (FPU – Floating Point Unit). Os processadores da família x86 eram processadores de número inteiro. Mas alguns aplicativos (como planilhas, CAD e jogos) tinham a necessidade de utilizar números fracionários e funções matemáticas complexas para realizar algumas tarefas, como o cálculo de seno, raiz cúbica, logaritmos etc. Era possível emular tais cálculos matemáticos via software, mas com baixo desempenho.

O co-processador aritmético é um componente essencial que tem como função auxiliar o

processador na realização de cálculos complexos. Por possuir instruções específicas para esse tipo de cálculo, consegue ser, em média, 50 vezes mais rápido que o processador principal executando o mesmo cálculo.



Até os PCs de 3ª geração (386), o co-processador era um circuito à parte e opcional. Considerado como um acessório era instalado em um soquete especial localizado na placa mãe. Na época da produção desses processadores, poucos usuários instalavam o co-processador em seus computadores e, como a produção era baixa, e o preço alto, alguns co-processadores ultrapassavam o preço dos processadores. A partir dos processadores de 4ª geração (486) esse circuito passou a estar internamente incorporado ao processador, resolvendo também o problema de seu custo.

4.6 – Sinais de Controle

Os processadores atuais possuem vários pinos (no mínimo, 400). Somente analisando friamente a arquitetura de cada tipo de processador existente é possível saber qual a função de cada um. Os processadores, no entanto, possuem algumas funções-padrão, ou seja, encontradas em praticamente todos os processadores, independente do fabricante. Estas são conhecidas como "sinais de controle" (ou "sinais digitais"), também correspondem a pinos no chip do processador e algumas delas são citadas abaixo:

� MIO: sinal para indicar se a operação em questão é de acesso a memória ou de E/S;

� RW: sinal para indicar se a operação em questão é de leitura ou gravação;

� INT: sinal para que dispositivos externos possam interromper o processador para que ele efetue uma operação que não pode esperar. Por exemplo, quando o HD interrompe o processador para avisar o término de uma operação de leitura. Como existe somente um sinal INT, o processador opera em conjunto com um mecanismo denominado "Controlador de Interrupções" (que trabalha com as conhecidas IRQs). Como vários dispositivos podem requisitar o processador num mesmo instante, através deste controlador é possível realizar todas as operações de forma organizada;

� NMI: sinal de interrupção especial, usado em emergências, onde a interrupção enviada por este sinal deve ser atendida prontamente. O NMI geralmente é usado informar erros relacionados a dados na memória;

� INT A: sinal usado para que o processador informe que aceitou uma interrupção e que está aguardando que o dispositivo que a gerou passe as instruções;

� VCC: entrada de corrente elétrica que alimenta os circuitos internos do processador (pode haver vários VCC no processador);

� GND: sinal usado para controle de energia (como se fosse um fio-terra). Também pode ser encontrados vários deste sinal no processador;

� RESET: sinal ligado ao botão RESET do gabinete do computador. Ao ser ativado, o processador pára o que está fazendo e inicia as operações novamente, como se o usuário tivesse acabado de ligar a máquina;

� CLOCK: este recebe um sinal digital usado internamente para sincronizar todo o funcionamento do processador.



4.7 – Arquitetura dos Processadores (RISC X CISC)

Desde os primeiros momentos da indústria de computadores que os cientistas dos principais fabricantes têm estudado métodos e técnicas que possam aperfeiçoar o desempenho e a capacidade dos sistemas de computação.

O nome CISC (Complex Instruction Set Computer) advém do fato de se considerar

complexo um conjunto constituído de grande quantidade de instruções, com múltiplos modos de endereçamento, entre outras críticas. Em uma época inicial da computação em que a memória era cara e pequena e, por isso, os códigos gerados pelos compiladores deveriam ser compactos e eficientes na execução. Dessa forma, os projetistas precisavam obter boa densidade do código de máquina, ou seja, cada instrução deveria fazer muito, de modo que o programa completo tivesse poucas instruções.O surgimento, em 1951, do conceito de micro-programação facilitou o trabalho de projetar instruções complexas, implementado-as em micro-código.

O primeiro sistema de computação lançado com micro-código e que originou, também, o

conceito de família de computadores foi introduzido pela IBM em 1964, o Sistema IBM/360. Posteriormente, a DEC (Digital Equipament Corporation) introduziu sua família de PDP, mais tarde substituída pelo sistema VAX, um dos melhores exemplos de máquina CISC.

Como é usual acontecer em qualquer área da atividade humana, é raro que algum conceito ou tecnologia importante, obtenha unanimidade entre pesquisadores, técnicos, projetistas e administradores. Este é o caso da arquitetura CISC, a qual sempre foi alvo de críticas e comentários sobre desvantagens e problemas.

Reduced Instruction Set Computer ou Computador com um Conjunto Reduzido de Instruções (RISC) é uma linha de arquitetura de processadores que favorece um conjunto simples e pequeno de instruções que levam aproximadamente a mesma quantidade de tempo para serem executadas. Os processadores baseados na computação de conjunto de instruções reduzidos não têm micro-programação, sendo que as instruções são executadas diretamente pelo hardware. Como característica, esta arquitetura, além de não ter micro-código, tem o conjunto de instruções reduzido, bem como baixo nível de complexidade.

A idéia foi inspirada pela descoberta de que muitas das características incluídas na arquitetura tradicional de processadores para ganho de desempenho foram ignoradas pelos programas que foram executados neles. Mas o desempenho do processador em relação à memória que ele acessava era crescente. Isto resultou num número de técnicas para otimização do processo dentro do processador, enquanto ao mesmo tempo tentando reduzir o número total de acessos à memória.

Exemplos de processadores que adotam a tecnologia RISC são o DEC Alpha, SPARC, MIPS, e PowerPC. O tipo de microprocessador mais largamente usado em desktops, o x86, é mais CISC do que RISC, embora chips mais novos traduzam instruções x86 baseadas em arquitetura CISC em formas baseadas em arquitetura RISC mais simples, utilizando prioridade de execução. RISC é também a arquitetura adotada para os processadores dos videogames modernos, que proporcionam um hardware extremamente dedicado somente à execução do jogo, tornando-o muito mais rápido em relação à micro computadores com mais recursos, embora com processador x86.



4.8 – Família Intel

A Intel surgiu da união de vários empresários e engenheiros provenientes de outras companhias, com idéias novas e dispostos, com a ajuda de alguns investidores, a iniciar uma nova era no mundo do circuito integrado.

Em 1969, a Intel foi escolhida para criar 12 circuitos

integrados (chips) para a construção de uma calculadora eletrônica para a empresa japonesa Busicom. A partir dessa idéia, o engenheiro Ted Hoff desenvolveu a criação de um único chip com a função dos 12 pretendidos. Logo, uma equipe de engenheiros apresentou o primeiro chip integrado bem sucedido com capacidade de cálculo; esse era o primogênito processador da Intel: o 4004. Esse circuito integrado continha as funções dos 12 circuitos encomendados, com uma precisão de quatro bits.

Com o sucesso dessas inovações, a Intel manteve a filosofia de integração apresentando

soluções muito importantes para o mercado mundial na área dos microprocessadores com a integração de circuitos simples. Isso fez com que a empresa conquistasse clientes de grande peso comercial, como a IBM, para a qual produziu processadores quase que por encomenda, pavimentando assim o caminho para o sólido futuro que a jovem empresa buscava.

Na área dos computadores pessoais, a Intel criou mais tarde o 8088, com precisão de oito

bits. Depois dele veio o 8080, com grande sucesso comercial. Nessa época, dissidentes da Intel criaram a empresa Zilog e o processador Z80 (um clone aprimorado e mais barato que o 8080) que fez sucesso nas décadas de 70 e 80, tendo sido considerado o coração dos computadores domésticos – marcas como a Sinclair (TRS-80) e MSX nos vêm à cabeça.

No início dos anos 80, a IBM precisava de um processador barato para um novo computador

doméstico que estava sendo desenvolvido. Pensou-se em usar o Intel 8086, de 16 bits, mas os periféricos da época eram todos de 8 bits. Sob encomenda, a Intel aprimorou o 8086 para que ele externamente trabalhasse a 8 bits, embora “em suas entranhas” o processamento fosse todo a 16 bits. Era criado assim o 8088, “cérebro” do IBM-PC original e das expansões PC-XT. Nessa época surgiu um clone para o 8088, sendo muito mais barato e rápido: o célebre NEC V20 – enquanto o 8088 era oferecido nas velocidades 4,77 e 8 MHz, o processador da Nippon Electric Company era vendido (mais barato) apenas para 12 MHz. Era a primeira vez que a Intel teria concorrência não de processadores apenas similares, mas de um componente compatível, intercambiável, mais barato e rápido.

4.8.1 – 80286 Sucessor do 8086/8088, o processador 80286 podia endereçar 16 MB de memória com 24 bits de endereçamento interno, com suporte à multitarefa e memória virtual. Ele vinha nas velocidades 6 MHz, 8MHz, 10 MHz e 12 MHz. Esse modelo possuía uma arquitetura com total suporte a 16 bits, e vinha com uma novidade: o modo protegido. Esse modo de proteção permitia que vários programas utilizassem a mesma memória sem ter a preocupação de invadir o quinhão de memória dos outros (travar o computador). Infelizmente, quando se utilizava o modo protegido, não havia volta – era impossível voltar ao modo normal. Isso

deu ao 286 o apelido de “cérebro morto”.



Quando o 80286 entrava em modo protegido, ele deixava de ser compatível com programas de modo real (como por exemplo, o MS-DOS), assim seu comportamento não era igual ao de um 8088. Quando um programador precisava criar um jogo simples que usasse o modo protegido do 80286, era necessário construir um sistema operacional praticamente novo. Isso porque havia a necessidade de incluir nesse jogo, várias rotinas para acessar os dispositivos do computador, como memória, HD etc.

Seis anos depois do lançamento, as vendas estimadas desse processador equivaliam a 15

milhões de máquinas em todo o mundo. Outro passo importante desse processador foi a introdução da filosofia de compatibilidade de software: uma vez que esse foi o primeiro processador a proporcionar compatibilidade com o software do modelo anterior.

4.8.2 – 80386

Este modelo de processador deu um salto significativo em relação ao desempenho, trazendo novas perspectivas aos servidores baseados na tecnologia Intel. Ele já contém todas as instruções do conjunto x86 utilizadas por programas atuais. Isso aconteceu porque uma novidade também havia sido introduzida nesse novo produto: o modo virtual. Esse modo permitia criar máquinas x86 virtuais, que fazia com que cada programa dividisse ciclo de processamento entre eles.

O processador já vinha com um sistema integrado de divisão de memória para multitarefa, o

que evitava o problema que ocorria com o 80286. Esse novo processador revolucionou toda família de processador Intel, criando novos

objetivos para o futuro. Esse foi o primeiro processador de 32 bits, com a capacidade de realizar tarefas de processamento múltiplo e com capacidade de acessar até 4 GB de memória RAM.

Introduzido em computadores de mesa, esse processador traz um

novo alento aos diversos fabricantes de software que vêem nele uma oportunidade de expandir o seu mercado de programas de características pesadas. No final da década de 80, com o decorrer dos meses, sua velocidade foi evoluindo de 20 MHz até 33 MHz.

A Intel resolveu também lançar no mercado uma versão

econômica, o 386 SX, com o objetivo de aumentar as vendas. O modelo SX utilizava os mesmos periféricos de 16 bits do 286, o que fazia com que os computadores ficassem mais baratos – diminuindo sua performance. Na época, os computadores com processador 386 SX custavam quase a metade do que os que vinham com o modelo 386 DX. Além do barramento “pela metade”, a diferença entre ambos os modelos é que o DX possuía o co-processador matemático integrado.

4.8.3 – 80486

O 80486 podia acessar até 4 GB de memória RAM e foi o primeiro a oferecer um co-processador aritmético construído parcialmente com funções matemáticas. Isso resultava em uma maior velocidade de processamento: havia acesso a complexas funções matemáticas a partir do processador central ambos dentro da mesma pastilha de silício.

O 486 introduzia pela primeira vez um co-processador matemático integrado. Isso eliminava

a necessidade de ter de comprá-lo separado. Quando o 486 apareceu, ele trabalhava a 25 MHz. O último deles chegou a ter 100 MHz de velocidade.



Na época, as placas-mãe não podiam trabalhar acima de 40 MHz, o que resultou na criação de um recurso que fez com que o processador trabalhasse a uma velocidade maior do que a placa-mãe. Esse recurso foi chamado de Multiplicação do Clock.

Processador Barramento da placa mãe Multiplicador 486 DX2 50 MHz 25 MHz 2 vezes 486 DX2 66 MHz 33 MHz 2 vezes 486 DX4 75 MHz 25 MHz 3 vezes 486 DX4 100 MHz 33 MHz 3 vezes

A partir do 80486 começou a surgir o problema de superaquecimento do processador. Com

isso, houve a necessidade de usar um ventilador (cooler) que, até hoje, é obrigatório em todos os processadores. Nessa época começou a onda do overclock: sendo que um DX4 100 podia ter seu clock multiplicado por três e meio ou por quatro, resultando em velocidades de 125 e 132 MHz. Quando o 486 não “fritava”, funcionava muito mais rápido. No entanto, era preciso ter muita sorte.

Também havia uma linha mais barata de 486: os “famigerados” 486 SX. Desprovidos de co-

processadores aritméticos, eles eram, na verdade, 486 DX completos com a unidade FPU (float point unit) queimada ou defeituosa. A Intel vendia co-processadores externos para o 486 SX, os chamados i487. Aí pôde ser percebida uma estratégia adotada pela Intel: os 487 eram, na verdade, 486DX completos, mas com a pinagem incompatível com o 486 DX original. Prova disso é que, com o 487 instalado na máquina, era possível retirar o 486 SX original sem que a máquina parasse de funcionar.

4.8.4 – Pentium

A Intel, ao lançar no mercado o Pentium, quebrou a seqüência dos processadores de nome x86 e deu início à corrida pelos MHz. Assim, logo o seu nome era intensamente divulgado até mesmo em publicações fora da área de informática, o que permitiu com que Pentium fosse uma palavra bastante conhecida em todos os lares logo após o seu lançamento.

Como o seu antecessor, o Pentium tinha também 32 bits, com capacidade de acessar até 4

GB de memória RAM e com algumas melhorias. Seu co-processador, por exemplo, passou a ser cinco vezes mais rápido que o 486.

Com essa nova designação, a Intel pretendia, entre outras coisas, obter uma exclusividade

quanto ao nome do seu processador. O baixo preço e alto desempenho do Pentium fizeram com que eles despontassem como novas opções para a implementação de sistemas empresariais. Muitas empresas trocaram as grandes plataformas baseadas em mainframes (computadores de grande porte), extremamente caras, por plataformas de menor preço, baseadas no Pentium.

O Pentium era composto por um conjunto de dois processadores de 32 bits trabalhando em

paralelo, o que permitia o acesso à memória de 64 bits e diminuía o problema de lentidão da memória. Por fazer um processamento paralelo, duas instruções podiam ser executadas simultaneamente.

Após o seu lançamento foram detectados inúmeros problemas, como o aquecimento

excessivo (uma vez que ele também utilizava a multiplicação de clock) e a dificuldade do cálculo aritmético com o ponto flutuante. Decorrente disso houve certo embaraço quando o erro foi descoberto, pois um engenheiro (prontamente demitido) da Intel chegou a afirmar que “o erro de arredondamento é desprezível para usuários não técnicos”.



Depois do vexame, a Intel, assumiu os custos efetuando trocas de processadores sem custo adicional aos consumidores.

4.8.5 – Pentium MMX

O que seria uma revolução anunciada acabou decepcionando. Notas divulgadas oficialmente para a imprensa especializada apontavam que a Intel estava desenvolvendo um processador que não precisava de chipsets externos – e que iria possuir todos os periféricos multimídia (na época, som e vídeo) internamente. O lançamento do novo processador, o Pentium MMX (MultiMedia eXtensions) provou não ser nada do anunciado.

Em vez de periféricos multimídia integrados, esse era

um processador com funções para manipulação direta de dados multimídia. Foi, sem dúvida, um avanço muito grande, pois com uma velocidade maior, o desempenho era impressionante. Porém, isso estava muito aquém do que se esperava em termos de integração.

A tecnologia MMX incorporada aos novos chips da linha Pentium, proporcionou ganhos de

velocidade que trouxeram para o computador pessoal capacidades inéditas na área de multimídia. Tecnicamente, esse salto MMX em direção à multimídia constitui a evolução mais importante da família Intel desde o lançamento do 80386. O processador Pentium MMX era internamente composto por 4.300.000 transistores. A aritmética de saturação, que é muito usada na manipulação de gráficos foi uma das maiores características da tecnologia MMX.

Na prática, observa-se que o paralelismo e a aritmética de saturação da tecnologia MMX são

usados em formas de transmissão de vídeo e compressão de dados. Todas as placas mãe que suportam o processador Pentium também suportam o MMX, para

isso, basta configurar os jumpers da placa, os quais determinam a tensão elétrica de operação. Posteriormente, a Intel abandonaria a fabricação do Pentium MMX com o lançamento do Pentium II – que já inclui todas as tecnologias MMX.

4.8.6 – Pentium Pro

Este processador foi lançado antes do Pentium MMX, e foi utilizado como arquitetura base para os demais processadores da Intel. Entretanto, diferentemente dos seus “descendentes”, o Pentium Pro não possui nenhuma instrução MMX.

Lançado no final de 1995, o Pentium Pro tem um desenho de 32 bits. Destinado

principalmente aos servidores, ele possuía um desempenho melhor que os modelos anteriores em aplicações e sistemas operacionais de 32 bits. Esse modelo possuía também suporte ao multiprocessamento, possibilitando a montagem de sistemas com até quatro processadores trabalhando em paralelo, encaixados na mesma placa mãe.

O processador Pentium Pro utilizava a tecnologia RISC com um conjunto de instruções

CISC, tendo internamente 5,5 milhões de transistores.



Esse processador funciona como se fosse três processadores em paralelo, sendo capaz de executar até três instruções por pulso de clock interno.

4.8.7 – Pentium II

O Pentium II foi considerado na época – e com razão – como uma continuidade do Pentium Pro, com algumas melhorias. Enquanto alguns recursos eram postos de lado – como o suporte ao multiprocessamento com quatro processadores, ele apresentava um novo formato de caixa, que era protegido por uma capa plástica e com um novo encaixe. Pela primeira vez, o clássico modelo quadrado de soquete havia sido abandonado.

A tecnologia RISC permitiu que os processadores Pentium II fossem mais rápidos, porém

incompatíveis com a tecnologia CISC (arquitetura utilizada até o Pentium), o que significa que não se poderia utilizar nenhum dos programas que tinham sido feitos para os processadores anteriores. A Intel, para solucionar este tipo de problema, introduziu internamente um decodificador CISC. Assim, quando um programa for executado, esse decodificador traduz as instruções CISC recebidas pelo processador em instruções RISC equivalentes para o processador. Sem isso, o próprio Windows deixaria de funcionar e a Microsoft teria de desenvolver uma versão especial para o Pentium II.

Graças aos 7,5 milhões de transistores

internos, o uso do decodificador CISC e de outras funcionalidades, o Pentium II conseguir chegar a velocidades de até 450 MHz.

Em termos de velocidade de barramento, as

versões do Pentium II de até 333 MHz utilizam o bus de 66 MHz, enquanto as versões a partir de 350 MHz usam bus de 100 MHz, o que acelera a troca de dados entre o processador e a memória RAM.

4.8.8 – Pentium II Xeon

Utilizando a mesma arquitetura do Pentium II, o Xeon é um processador desenhado para grandes servidores e estações de trabalho gráfico, substituindo o uso do Pentium Pro. Um outro motivo da preferência em trabalhar com servidores, é que além de suportar multiprocessamento com quatro processadores na mesma placa, ele permitia o uso de 8 processadores em sistemas cluster (grades de máquinas interligadas).

Este processador possui quatro funções de gestão inéditas, como um sensor de temperatura

interno, uma função ECC (error checking and correction), uma função de redundância e uma gestão integrada ao processador. Ele também utilizava um novo tipo de encaixe na placa mãe, chamado de slot 2.

4.8.9 – Pentium III

Com 70 novas instruções, o Pentium III introduzia tecnologias inovadoras desde os processos de produção em fábrica. Ele possui versões de encaixe para soquete 370 e slot 1, bem como barramento nas versões de 100 Mhz e 133 MHz.



As versões de 600 MHz e posteriores utilizavam uma arquitetura mais avançada: seus transistores eram menores, fazendo com que gerassem menos calor, e possibilitando, assim, o surgimento de processadores mais velozes.

As novas versões começaram a utilizar um barramento de 133 MHz que faz a ponte somente

entre a placa-mãe e o processador. Os demais dispositivos (HD, modem, vídeo) utilizavam barramentos entre 66 MHz e 100 MHz. Assim, para que a memória e a placa-mãe possam acompanhar a velocidade do Pentium III, é necessária uma placa-mãe que utilize barramento de 133 MHz e módulos de memória PC-133.

A Intel resolveu lançar versões do Pentium III para encaixar no formato PPGA (paralell pin

grid array, que encaixa no soquete 370) a fim de cortar alguns custos e resolver os problemas eternos de mau-contato e encaixe impreciso no slot 1. Para alguns usuários, isso foi muito ruim, pois obrigava a compra de um adaptador caso tenham um placa-mãe com slot 1.

Nesse processador há também a introdução de condições de baixo consumo de corrente

(lower power state) e instruções novas como autohalt, stop-grant, deep sleep, sleep, que criam situações de baixo consumo em períodos de inatividade ou programados pelo usuário.

4.8.10 – Pentium III Xeon

De características muito idênticas ao Pentium III, ele promove soluções para uma grande variedade de aplicações da internet e é perfeito para rodar aplicações pesadas destinadas a servidores de missão crítica, com necessidade de desempenho máximo. Fabricado com velocidades de clock a partir de 550 MHz, esse processador acabou saindo de linha muito cedo, pois a Intel tinha dificuldades em fabricar versões mais rápidas.

4.8.11 – Celeron

O Celeron pode ser visto como uma versão mais barata do Pentium II, que era praticamente um processador “pelado”, sem cache L2 integrado nem invólucro de plástico.

O fato desse processador não possuir um cache L2

afetava seu desempenho: sua performance diminuía em quase 40%. Um Celeron 266 MHz “apanhava feio” do Pentium Pro 233 MHz em certas aplicações.

Com isso, a partir do Celeron 300 MHz, a Intel resolveu

colocar um cache L2 (chamado de 300 A) de 128 KB no núcleo desse processador. Tal cache funcionava duas vezes mais rápido em algumas aplicações, chegando a empatar com o Pentium II. Uma outra vantagem foi em relação ao seu co-processador aritmético, idêntico ao do Pentium

II, proporcionando um ótimo desempenho gráfico.

4.8.12 – Pentium 4

Disponível com velocidades a partir de 1.3 GHz, o desenho interno totalmente novo desse chip inclui tecnologia “hyper pipelined”, que divide o processador em vários estágios. Cada um deles processa as informações simultaneamente em uma fração de segundos. Quanto mais estágios, menos processamento se exigirá de cada um e, com isso, o chip ganha em velocidade.



Além do hyper pipelined, o Pentium 4 possui um barramento equivalente a 400 MHz para proporcionar um alto desempenho para programas gráficos 3D – games, vídeo, áudio e multimídia. Na verdade, esse barramento é de 100 MHz, mas como o processador trabalha com quatro transferências por ciclo, então temos 4 x 100 MHz = 400 MHz. Ele também contém uma nova e avançada tecnologia de cache L1 e L2.

O processador Pentium 4 trabalha com dois canais de acesso à memória RAM, com taxa de

transferência de 3.2 GB por segundo. Esse canal duplo multiplica por dois o ganho de performance conseguido pela maior velocidade do processador.

Posteriormente a Intel apresentou uma tecnologia para o Pentium 4 chamada de HT – hyper

threading. Com isto, a Intel deu mais poder de fogo aos processadores com um barramento de sistema de 800 MHz, outras surpreendentes tecnologias como o suporte a RAM DDR 400 e discos IDE ATA seriais.

4.8.13 – Itanium

Itanium foi o nome dado a uma nova plataforma de construção de processadores da Intel. Baseado em um arquitetura de 64 bits, o Itanium trabalha com o processamento de dados no dobro da velocidade de seus antecessores de 32 bits, incluindo o Pentium 4. O processador Itanium usa a tecnologia EPIC (explicity paralell instruction computing) para alcançar novos níveis de performance, executando múltiplas instruções simultaneamente.

A EPIC também traz novas características, como a análise prévia e prevenção de problemas

de processamento, examinando anteriormente as instruções e prevendo o resultado. Além disso, o bus de dados de um Itanium é de 286 MHz, gerando uma largura de banda de 2.1 GB por segundo.

4.9 - Família AMD

Fundada em 1969, a AMD (Advanced Micro Devices), em seu início, chegou a produzir chips sob encomenda para a própria Intel, mas depois resolveu produzir seus próprios produtos. Para ganhar popularidade no mercado quase monopolista da Intel, a AMD ofereceu produtos de baixo custo, o que acabou se tornando a sua principal referência.

Sediada em Sunnyvale, Califórnia, hoje a AMD é fornecedora mundial de circuitos

integrados para os mercados de computadores pessoais e de rede, bem como para o mercado de comunicação, com fábricas nos Estados Unidos, Europa, Japão e Ásia. Tanto a Intel como a AMD tem uma história bem parecida em relação ao desenvolvimento tecnológico de seus produtos. Na verdade, seus primeiros chips sempre utilizavam tecnologias que a Intel já havia implementado meses antes. Isso deixou a AMD a um passo atrás de sua concorrente durante muito tempo.

4.9.1 – AMD 286 A

Em 1982, a AMD lançou no mercado um dos seus primeiros processadores, o 286A. Ele vinha nas velocidades 12 MHz e 16 MHz, e não representava um grande avanço tecnológico, porém tinha alguns recursos muito interessantes. Um deles era o emulador SEM, que possibilitava ao programa sair do modo de proteção, coisa que o Intel 286 não podia fazer.



4.9.2 – AMD 386

No início de 1985, a AMD lançou uma versão do antigo 286 com algumas melhorias, o processador 386. Assim como o 386 da Intel, esse novo processador possuía suporte de 32 bits e vinha com velocidades entre 16 MHz a 40 MHz. A exemplo da Intel, a AMD fez duas versões desse produto. Uma com o novo suporte de 32 bits (DX) e outra apenas com o antigo 16 bits (SX).

4.9.3 – AMD 486

Depois que a Intel lançou o modelo 80486, a AMD lançava sua versão desse processador, o que pode ser considerado o início da popularidade da AMD. Ele vinha nas velocidades de 22 MHz a 50 MHz e com co-processador matemático integrado.

Em uma grande variedade de testes realizados, o 486 da Intel perdia para o 486 da AMD.

Isso por causa do bus interno do 486 da AMD, que era de 40 MHz, enquanto o da Intel era de apenas 33 MHz. Posteriormente, a AMD lançou uma versão com o dobro da velocidade do bus interno de 80 MHz.

Em resposta (tardia), a Intel lançou a versão DX4 do 486. Com essa versão, que tinha o

triplo de barramento interno do 486 original, a Intel voltou a ser mais rápida, e o 486 da AMD ficou para trás. Entretanto, o mercado nunca mais seria o mesmo: as pessoas começaram a olhar a AMD como fabricante de circuitos rápidos e não só como alternativa barata à Intel.

4.9.4 – AMD 586

Após ter assistido ao lançamento e ao sucesso do novo processador Pentium da Intel, os executivos da AMD sabiam que deveriam lançar um produto à altura em breve.

Em assim o fizeram. O novo processador 5x86 da

AMD nada mais era que um 486 com barramento de 133 MHz, com a placa mãe funcionando a 33 MHz, usando multiplicador de quatro vezes. Ou seja: não passava de um 486 um pouquinho mais rápido. Como perdia feio para o Pentium, esse processador não foi bem aceito entre os consumidores e passou quase que despercebido.

4.9.5 – AMD K5

Sabendo que precisaria ter um produto que competisse com o Pentium, e em meio às duras críticas, a AMD lançou um projeto próprio de processador, o K5. Curiosidade: a letra K aludia à Kriptonita, a única arma eficaz contra o Super Homem da Intel. Ao contrário dos seus antecessores, não era um clone de sua contrapartida da Intel, mas um projeto novo. Sua estrutura interna era completamente diferente, sendo semelhante apenas nos pontos em que interfaceava com o software: conjunto de instruções, registradores e cache. Com isso a AMD conseguiu um produto próprio e 100% compatível com o software para PC produzido até então.

Esse processador deu um pouco de dor de cabeça a AMD, pois não se conseguia produzir

uma versão acima dos 116 MHz, enquanto o seu concorrente chegava fácil aos 150 MHz.



O mais engraçado dessa história ocorreu quando, depois de “queimar muitos neurônios”, a AMD conseguiu lançar uma versão de 133 MHz. Com isso, a Intel lançou também uma nova versão do seu processador, o Pentium 200 MHz. Parece que essa Kriptonita, em vez de derrotar a Intel, teve o mesmo efeito que o espinafre tem para o marinheiro Popeye.

4.9.6 – AMD K6

Os engenheiros e cientistas da AMD, com sérios problemas em relação a sua competição particular com os da Intel, acabaram encontrando uma empresa querendo vender sua tecnologia. Essa empresa era a Next-Gen, uma fabricante de processadores que possuía o projeto de um processador 6x86, mas com algumas melhorias. Muitos softwares de teste ainda hoje identificam os K6 como 6x86.

Todos os testes mostravam o K6 como sendo mais rápido que o Pentium, e chegando perto

do Pentium Pro (só que por um preço mais baixo). Ao saber do sucesso do K6, a Intel adiantou o lançamento do seu novo processador Pentium II e mais uma vez, e empresa retomava a frente na corrida tecnológica.

4.9.7 – AMD K6-II

Com o surgimento do Pentium MMX – cuja tecnologia era um fator importante para os consumidores – a AMD tentou encontrar um jeito de concorrer com essa nova tecnologia da Intel. A incorporação de 27 instruções ao seu K6-II, chamada tecnologia 3DNow! fazia com que o processamento de gráficos tridimensionais por meio de placas aceleradoras se tornasse mais rápido. Além disso, o novo K6-II vinha com velocidade a partir de 300 MHz e com um barramento de 100 MHz.

Essa nova tecnologia, quando suportada pelos programas/aplicativos, apresentava resultados

fantásticos até mesmo em comparação ao todo poderoso Pentium II. Isso tornou o K6-II o processador mais famoso e mais vendido da história da AMD.

A princípio, a nova tecnologia 3DNow! não foi muito

bem aceita pelos projetistas de softwares que aos poucos foram perdendo o interesse por ela, o que resultou na produção de poucos programas que a suportavam. Mas a Microsoft, querendo ampliar a base instalada do seu sistema operacional Windows, colocou suporte total ao 3DNow! nas extensões DirectX, juntamente com as instruções MMX do Pentium. Resultado: se o programa usasse DirectX, não importaria a tecnologia do processador, pois, qualquer que fosse, sua capacidade seria maximizada.

Pouco depois, a Intel aumentou o cache de seu

Pentium II,e a AMD mais uma vez não conseguiu acompanhar o desenvolvimento da rival.

4.9.8 – AMD K6-III

O K6-III foi uma resposta da AMD ao Pentium III da Intel. Lançado em 1999, ele foi produzido em velocidades a partir de 400 MHz. Na verdade, o K6-III não passava de uma versão do K6-II que trazia embutido um cache L2 de 256 KB.



Durante algum tempo, vários testes mostravam que o K6-III vencia facilmente um Pentium III de mesmo clock. Porém o método de fabricação adotado fazia com que o processador gerasse muito calor e também não apresentava um preço atrativo. Mais tarde, com o lançamento do Athlon, a AMD abandonou a produção do K6-III. O Athlon, além de ser um processador mais rápido, tinha menor custo de produção.

4.9.9 – AMD Athlon

No ano de 2000, a AMD mostraria ao mundo seu novo produto, que prometia revolucionar a indústria de processadores e virar a corrida tecnológica a seu favor. Seu nome: K7, mais conhecido popularmente como Athlon. Ele fez com que a AMD mostrasse que poderia se tornar líder no mercado com um processador simplesmente excepcional.

Os dois processadores concorrentes Athlon e

Pentium III eram de certa forma equivalentes, pois cada um apresentava algum tipo de vantagem sobre o outro. O Athlon foi fabricado também no formato Slot A, bem parecido fisicamente com o Slot 1 da Intel, porém incompatível logicamente. Um dos problemas do Athlon era seu superaquecimento, o que ocorria porque o processador ainda utilizava o antigo processo de fabricação de 0.25 mícron – uma desvantagem em relação ao Pentium III, que produzia menos calor. Em compensação era ligeiramente mais barato.

Assim, a AMD resolveu modificar o processo de fabricação desse processador, passando a

utilizar o 0.18 mícron, o que resolveu, então, esse problema. Isso fez com o Athlon alcançasse vendagens excelentes, impulsionadas pelo seu menor preço em comparação ao Pentium III e também por seu desempenho em alguns casos muito melhor que o Pentium III.

4.9.10 – AMD Athlon Thunderbird

Da mesma maneira que a Intel, a AMD também incorporou o cache L2 ao núcleo do seu processador, sob o nome de Athlon Thunderbird. Essa nova versão possuía menos cache (256 Kb) que o Athlon original. No entanto consumia bem menos energia e produzia menos calor.

O cache integrado ao processador oferece um grande ganho de performance, pois trabalha

na mesma velocidade. Assim, a AMD deixou de estar próxima da Intel, para finalmente igualar-se a ela. Logo, foi introduzido um novo soquete de encaixe chamado Soquete A (ou soquete 462).

Enquanto os modelos antigos do Athlon utilizavam o slot A, esse novo soquete era parecido com o soquete 370.

4.9.11 – AMD Duron

A AMD queria controlar ambos os mercados de alto e baixo custo. Simultaneamente ao lançamento do Athlon Thunderbird, foi lançado o processador Duron, que também veio para disputar o mercado de baixo custo com o seu principal concorrente, o Celeron. Descobriu-se depois que essa concorrência era muito fácil de ser vencida.



Na verdade, o Duron é uma versão do Thunderbird com menos cache L2. E enquanto um Athlon Thunderbird vem com cache L2 (full-speed) de 256 Kb, o Duron vem com cache L2 de apenas 64 Kb (também full-speed), mas apresentando um cache L1 de 128 KB, totalizando 192 Kb de cache, superando, com isso, o Celeron, seu processador rival.

4.10 - Família Cyrix

A Cyrix está no mercado de processador há muito tempo. Seus processadores sempre foram razoavelmente bons se comparados aos processadores da Intel e da AMD. Mesmo na época do Pentium, tanto a AMD como a Cyrix já trabalhavam em seu processador de 5ª geração com o objetivo de ultrapassar, ou simplesmente se igualar, ao Pentium. Apesar de ser uma empresa pequena, a Cyrix sempre desenvolveu processadores aritméticos de bom desempenho, mesmo sem possuir um parque fabril suficiente para atender à demanda.

4.10.1 – Cyrix Cx486 DX

Lançado em 1993, o processador Cx486DX foi a primeira investida da Cyrix no mercado. Com uma velocidade de até 100 MHz, diversos testes apontavam que esse processador era bastante rápido e chegava a ser superior ao modelo 80486 da Intel.

A exemplo da Intel, mais tarde seria lançada a versão

DX2 e DX4 do Cx486DX. O DX2 apresentava o dobro de velocidade interna do barramento em relação ao original, e o DX4 o triplo.

A Cyrix também possuía um 386 “turbinado”

chamado Cx486DLC. Ele era compatível pino a pino com o 80386 e apresentava um ganho de desempenho de aproximadamente 20%. Para substituir o 386XC, havia o 486SLC, que era um verdadeiro “frankenstein”, com barramentos do 286, circuitos do 386 e instruções do 486.

4.10.2 – Cyrix 5x86

Depois de uma boa vendagem do Cx486DX, a Cyrix lançou em 1995 o processador 5x86, ou apenas 586. Ele vinha com uma velocidade de até 133 MHz e com uma novidade, o dissipador embutido. Esse processador era uma mistura de 486 com Pentium, oferecendo um desempenho superior a um 486 padrão e mesmo ao 586 da AMD. Apesar de aceitável, seu desempenho geral era bem inferior ao do Pentium da Intel.

4.10.3 – Cyrix 6x86

Empolgada com os seus dois últimos processadores, a Cyrix anunciava um novo conceito em processadores, e em 1996 lançaria o 6x86. Este processador foi uma tentativa da empresa de concorrer com o MMX da Intel, prometendo que o 6x86 seria tão rápido quanto qualquer processador da Intel ou da AMD.

O mercado, no entanto, considerou o 6x86 medíocre, ignorando a lista de bons recursos

apresentada pelo processador com, por exemplo, suporte à tecnologia MMX, uma velocidade considerável e um preço mais acessível que os da concorrência.



Mais tarde, o lançamento da versão MX desse produto apresentava somente algumas mudanças, tais como a implantação de cache L1. Porém, isso não era o bastante, e a Cyrix deixara de ser uma ameaça à Intel ou à AMD.

4.10.4 – Cyrix Media GX Pouco depois de lançar o 6x86, a Cyrix tentava introduzir um produto que pudesse realizar o

controle de todas as funções controladoras no próprio processador (som, vídeo PCI e memória). A idéia era boa, mas não havia como um processador de apenas 200 MHz realizar tais funções sozinho.

4.10.5 – Via Cyrix III

Após ser comprada pela National Semiconductor, a Cyrix deixara de produzir qualquer produto que tivesse expressão. Porém, em 2000, ao ser comprada pela VIA, a Cyrix apresentou um novo processador: o VIA Cyrix III. Disponível a partir de 500 MHz. Ele consumia pouca eletricidade, o que o tornava atraente para o mercado de notebooks.

Apesar de parecer um bom concorrente, o VIA Cyrix III

simplesmente não consegue render tanto quanto os produtos da Intel e da AMD de mesmo clock.

Exercícios

01 – Considerando as funções de um processador, é incorreto afirmar que: a) O processador é o componente vital do sistema de computação b) Um processador tem por propósito realizar operações com os dados c) Todo processador é construído de modo a ser capaz de realizar algumas operações denominadas

primitivas d) A seqüência de 0s e 1s que formaliza uma determinada operação a ser realizada pelo processador

denomina-se instrução de máquina e) Todas as alternativas estão incorretas 02 – Explique o funcionamento dos ciclos de busca, memória e execução existentes na CPU. 03 – Qual a função do registrador CX? 04 – Explique qual a função do clock de um computador. 05 – Por que a utilização de um co-processador matemático aumenta a performance de um processador? 06 – Qual a diferença de funcionamento existente entre os processadores 8088 e 8086 da Intel? 07 – Em que consiste o modo protegido, implementado pela primeira vez nos processadores 80286? 08 – Em que o processador 80386 DX era diferente quando comparado ao processador 80386 SX?



09 – Explique o funcionamento da técnica denominada overclock (multiplicação de clock). Qual o inconveniente da utilização deste método? 10 – Por que existe a necessidade da utilização de um cooler nos processadores atuais? 11 – Explique o funcionamento da tecnologia MMX, implementada pela primeira vez nos processadores Pentium. 12 – Alguns processadores foram projetados para serem utilizados em sistemas de cluster. Em que consiste este sistema? 13 – O processador Pentium 4 introduziu a tecnologia denominada hyper pipelined. Explique como funciona esta tecnologia.



5- Subsistemas de Memória

5.1 - Introdução

A memória é o componente de um sistema de computação cuja função é armazenar as informações que são ou serão manipuladas por esse sistema, para que elas possam ser prontamente recuperadas, quando necessário.Conceitualmente, a memória é um componente muito simples: é um “depósito” onde são guardados certos elementos (as informações) para serem usados quando desejado.

No entanto, na prática, em um sistema de computação não é possível construir e utilizar

apenas um tipo de memória. Na verdade, a memória de um computador é também em si um sistema, ou melhor, um subsistema, tendo em vista que é constituída de vários componentes interligados e integrados, com o objetivo já definido acima: armazenar informações e permitir sua recuperação quando requerido.

A necessidade da existência de vários tipos de memória ocorre em virtude de vários fatores

concorrentes. Em primeiro lugar, o aumento sempre crescente, da velocidade da CPU, muito maior que o tempo de acesso da memória, ocasiona atrasos na transferência de bits entre memória e CPU. Outro fator relaciona-se com a capacidade de armazenamento de informações que os sistemas de computação precisam ter, cada vez maior, em face do aumento do tamanho dos programas, bem como do aumento do volume dos dados que devem ser armazenados e manipulados nos sistemas atuais. Se existisse apenas um tipo de memória, sua velocidade (tempo de acesso) deveria ser compatível com a da CPU, de modo que esta não ficasse esperando muito tempo por um dado que estivesse sendo transferido da memória.

Na realidade, o avanço da tecnologia na construção de processadores e memórias de

semicondutores não tem sido uniforme, isto é, o aumento da velocidade das CPUs tem sido bem maior que o aumento da velocidade de acesso das memórias. Enquanto a quantidade de instruções executadas por segundo por um processador tem dobrado a cada 18 meses mantendo o mesmo preço, a velocidade de acesso das memórias tem aumentado cerca de 10% ao ano, embora sua capacidade de armazenamento venha quadruplicando a cada 36 meses (mantendo o mesmo preço).

Em resumo, os dois fatores citados, velocidade e capacidade, indicam a necessidade de se

projetar não um único tipo de memória (com elevada velocidade e grande capacidade, mas com custo altíssimo), mas sim um conjunto de memórias com diferentes características, o que leva a uma hierarquia de funcionamento a que denominamos de subsistema de memória.

5.2 - Representação das Informações

A memória de um sistema de computação tem como elemento básico de armazenamento físico o bit. Ou seja, fisicamente ela é construída de modo a representar individualmente bit por bit. O modo pelo qual cada bit é identificado na memória é variado: pode ser um sinal elétrico, um campo magnético ou ainda pela presença/ausência de um ponto de luz.

Como um bit pode apenas indicar dois valores distintos, sua utilidade individual é bastante

restrita. Na prática, precisamos passar para o computador as informações que conhecemos na vida cotidiana, normalmente em forma de caracteres ou símbolos gráficos, que visualmente conseguimos distinguir. Assim, claramente distinguimos o caractere “a” do caractere “b”, porque todos eles têm formato visual diferente e o ser humano, através do sentido da visão, consegue distingui-los.



Como computadores não possuem esses sentidos, eles conseguem apenas distinguir sinais elétricos diferentes, isto é, se o valor representa 0 ou 1. Nesse caso, para introduzir todos os símbolos básicos que usamos em nosso dia a dia precisaríamos mais do que um bit, visto que com apenas um bit poderíamos apenas representar dois símbolos distintos.

Por isso, os sistemas de computação costumam agrupar uma determinada quantidade de bits,

identificando este grupo como uma unidade de armazenamento, denominada célula. Uma célula é um grupo de bits tratado em conjunto pelo sistema, isto é, esse grupo é movido

em bloco como se fosse um único elemento, sendo assim, identificado para efeitos de armazenamento e transferência, como uma unidade.

5.3 - Localização das Informações

Como uma memória é constituída de vários desses grupos de bits, é necessário que seja definido um método para identificar univocamente cada uma dessas células, de modo que possa ser

distintamente identificado o grupo de bits desejado para o processamento.

Em um sistema de computação as células são

identificadas por um número denominado endereço. A memória é organizada em grupos de bits seqüencialmente dispostos a partir do grupo de endereço 0 até o último grupo, de endereço (n –1). O sistema de controle das memórias é construído de modo a localizar certo grupo de bits a partir do seu endereço.

5.4 - Operações Realizadas

Já foi mencionado que uma memória é um dispositivo de armazenamento (depósito) de informações. Quando se organiza um depósito, tem-se por objetivo permitir que elementos possam ser armazenados de maneira organizada, que possibilite sua identificação e localização, quando se deseja recuperá-los. Desta maneira, na memória de um computador podemos realizar basicamente duas ações: � Escrita ou gravação � Leitura ou recuperação

Ambas as operações são possíveis graças à técnica utilizada para identificar cada elemento (ou grupo de bits) por um número, seu endereço, que permite identificar o local de armazenamento para escrita ou leitura.

A operação de escrita é naturalmente destrutiva, ou seja, ao armazenar-se um dado em uma

célula o conteúdo anterior é destruído, visto que os bits que chegam são gravados por cima dos que estavam no local. A operação de leitura não deve ser destrutiva. Ela é, na realidade, uma ação de copiar um valor em outro local, permanecendo o mesmo valor no local de origem.

5.5 - Hierarquia

No item anterior mencionamos a necessidade de se projetar sistemas de computação que adotassem uma memória constituída de um conjunto de diferentes tipos, organizados de forma hierárquica.



Na realidade há muitas memórias no computador, as quais se interligam de forma estruturada, constituindo um sistema em si, fazendo parte do sistema global de computação.

A pirâmide da figura anterior é projetada com uma base larga, que simboliza a elevada

capacidade, o tempo de uso e o custo do componente que a representa. A seguir serão definidos os principais parâmetros para análise das características de cada

tipo de memória que faz parte da pirâmide: � Tempo de acesso – indica quanto tempo a memória gasta para colocar uma informação no barramento

de dados após uma determinada posição ter sido endereçada. É um dos parâmetros que pode medir o desempenho da memória. O valor do tempo de acesso de uma memória é dependente da sua tecnologia de construção e da velocidade de seus circuitos. Ele varia bastante para cada tipo, de alguns poucos nanossegundos, no caso de memórias tipo RAM (DRAM, SRAM) até dezenas ou centenas de milissegundos, no caso de memória secundária (discos magnéticos).

� Capacidade – é a quantidade de informação que pode ser armazenada em uma memória. A unidade mais

comum é o byte, indicando sua capacidade total. � Volatilidade – uma memória não volátil é a que retém a informação armazenada quando a energia

elétrica é desligada. Memória volátil é aquela que perde a informação armazenada quando o equipamento é desligado.

� Custo - o custo de fabricação de uma memória é bastante variado em função de diversos fatores, entre os

quais se pode mencionar principalmente a tecnologia de fabricação, que redunda em maior ou menor tempo de acesso, ciclo de memória, quantidade de bits em certo espaço físico e outros.



5.5.1 - Registradores Em um sistema de computação, a destinação final do conteúdo de qualquer tipo de memória

é o processador. Assim, o objetivo final de cada uma das memórias é armazenar informações destinadas a serem utilizadas pelo processador. Ele é o responsável pela execução das instruções, pela manipulação dos dados e pela produção dos resultados das operações.

As ações do processador são realizadas nas suas unidades funcionais: na unidade aritmética

e lógica (ULA), na unidade de ponto flutuante (UFP) ou talvez em uma unidade de processamento vetorial. No entanto, antes que a instrução seja interpretada e os dispositivos da CPU sejam acionados, o processador necessita buscar a instrução de onde ela estiver armazenada e armazená-la em seu próprio interior, em um dispositivo de memória denominado registrador de instrução.

Em seguida a este armazenamento da instrução, o processador deverá, na maioria das vezes,

buscar dados da memória para serem manipulados na ULA. Esses dados também precisam ser armazenados em algum local na CPU até serem efetivamente utilizados. Os resultados de um processamento também precisam às vezes ser guardados temporariamente na CPU, ou para serem novamente manipulados na ULA por outra instrução, ou para serem transferidos para uma memória externa à CPU. Esses dados são armazenados na CPU em pequenas unidades de memória, denominadas registradores.

Um registrador é, portanto, o elemento superior da pirâmide de memória, por possuir a

maior velocidade de transferência dentro do sistema (menor tempo de acesso), menor capacidade de armazenamento e maior custo.

5.5.2 - Memória Cache

Na pirâmide de memória, encontra-se a memória cache. Em sistemas de computação mais antigos, a pirâmide não possuía memória cache e, desse modo, os registradores eram ligados diretamente à memória principal.

Em toda execução de uma instrução, CPU acessa a memória principal (sem cache), pelo menos uma vez, para buscar a instrução (uma cópia dela) e transferi-la para um dos registradores da CPU. Muitas instruções requerem outros acessos à memória, seja para transferência de dados para a CPU, seja para transferência do resultado de uma operação para a memória. Em resumo, para a realização do ciclo de uma instrução há sempre a necessidade de ser realizado um ou mais ciclos de memória.

Considerando-se que um ciclo de memória é atualmente bem mais demorado do que o

período de tempo que a CPU gasta para realizar uma operação na ULA, fica claro que a duração da execução de um ciclo de instrução é bastante afetada pela demora dos ciclos de memória. Desde há muito, então, esta interface entre o processador e a memória principal vem sendo um ponto frágil no que se refere à performance do sistema.

Na tentativa de melhorar o desempenho dos sistemas de computação, os projetistas das

CPU´s vêm constantemente obtendo velocidades cada vez maiores nas operações dessas unidade, o que não está acontecendo na mesma proporção com o aperfeiçoamento tecnológico das memórias utilizadas como memória principal. Assim, atualmente a diferença de velocidade entre a CPU e a memória principal é talvez maior do que já foi no passado.



Na busca de uma solução para este problema, foi desenvolvida uma técnica que consiste na inclusão de um dispositivo de memória entre a CPU e a memória principal, denominado memória cache, cuja função é acelerar a velocidade de transferência das informações e com isso aumentar o desempenho dos sistemas de computação.

Para tanto, este tipo de memória é fabricado com tecnologia semelhante à CPU e, em

conseqüência possui tempos de acesso compatíveis com a mesma, resultando em uma considerável redução de espera da CPU para receber dados e instruções da cache, ao contrário do que acontece em sistemas sem cache.

O conceito de “localidade” justifica a existência da cache por prever vários acessos à mesma

memória num breve espaço de tempo. Baseado neste conceito, a memória cache trabalha seguindo o seguinte algoritmo: 1. Sempre que a CPU vai buscar uma nova instrução, ela acessa a memória cache. 2. Se a instrução ou dado estiver na cache, ela é transferida em alta velocidade para a CPU. 3. Se a instrução ou dado não estiver na cache, então o sistema está programado para interromper a execução do programa e transferir a instrução desejada da memória principal para a CPU. A CPU entra em “estado de espera” (WAIT STATE) enquanto ocorre a demorada transferência do dado vindo da memória principal. Simultaneamente é transferida uma cópia da instrução desejada mais o conteúdo de alguns endereços de memória subseqüentes para a memória cachê prevendo novo acesso baseado no princípio da localidade.

Atualmente há diversos tipos de memória cache, utilizados em sistemas de computação

modernos: RAM cache ou cache para a memória principal e cache para disco. Além disso, é importante mencionar que as memórias RAM cache podem ser inseridas em dois níveis. O primeiro nível é denominado L1 e consiste de uma memória inserida internamente no processador, encapsulada na mesma pastilha, enquanto a de nível 2, L2 ou cache externa, consiste em um pastilha separada e própria, instalada na placa mãe do computador.

5.5.3 - Memória Principal

Uma das principais características definidas no projeto de arquitetura do sistema de Von Neumann, o qual se constitui na primeira geração dos computadores, consistia no fato de ser uma máquina “de programa armazenado”. O fato das instruções, uma após a outra, poderem ser imediatamente acessadas pela CPU é que garante o automatismo do sistema e aumenta a velocidade de execução dos programas.

A CPU pode acessar imediatamente uma instrução após a outra porque elas estão

armazenadas internamente no computador. Esta é a importância da memória. E, desde o princípio, a memória especificada para armazenar o programa (e seus dados) a ser executado é a memória que atualmente chamamos de principal (ou memória real), para distingui-la da memória de discos (memória secundária)

A memória principal é, então, a memória básica de um sistema de computação desde seus

primórdios. É o dispositivo onde o programa (e seus dados) que vai ser executado é armazenado para que a CPU busque instrução por instrução, para executá-las.



Atualmente a memória principal é fabricada com tecnologia de semicondutores, o que lhes permite elevada velocidade de acesso e transferência de bits, já que são circuitos apenas elétricos em funcionamento (não há partes mecânicas ou magnéticas). A velocidade de propagação de um sinal elétrico é cerca de 300.000 km/s (velocidade de luz).

A memória principal permite o acesso a qualquer uma das células de memória a qualquer

tempo, se diferenciando das memórias chamadas seqüenciais (como as fitas magnéticas), nas quais é necessário acesso a todos os registros até a identificação da célula desejada. Uma vez que esta memória é volátil há necessidade deste programa e seus dados estarem armazenados em alguma forma de memória secundária (HD, CD-ROM) antes de serem chamados para a memória principal (RAM).

Na realidade, o programa não precisa mais estar inteiro na memória RAM, bastando que o

mesmo seja dividido em “pedaços” chamados de páginas, executadas em seqüência. Assim sendo, a memória principal é composta por “locais” onde podem ser armazenados dados na forma de “bits”. Estes “locais” podem ser acessados pelo seu “endereço”.

5.5.4 - Memória Secundária

Na base da pirâmide que representa a hierarquia de memória em um sistema de computação encontra-se um tipo de memória com maior capacidade de armazenamento do que os outros tipos já descritos, menor custo por byte armazenado e com tempos de acesso também superiores aos outros tipos. Esta memória, denominada memória secundária, tem por objetivo garantir um armazenamento mais permanente aos dados e programas do usuário, razão por que deve naturalmente possuir maior capacidade que a memória principal.

A memória secundária de um sistema de computação pode ser constituída por diferentes

tipos de dispositivos, alguns diretamente ligados ao sistema para acesso imediato (discos rígidos, por exemplo) e outros que podem ser conectados quando desejados (DVD, pen drives) cuja informação armazenada se torna diretamente conectada e disponível quando o DVD ou pen drive estiver inserido no elemento de leitura/escrita.

Observe que uma das principais características destes dispositivos é sua não volatilidade,

podendo armazenar informações mesmo com a falta de energia. A memória secundária é mais barata e mais lenta, sendo utilizada para armazenar informação por longos períodos de tempo. Sua lentidão, quando comparada às demais memórias, advém do fato da mesma ser constituída de elementos eletro-mecânicos, além dos tradicionais componentes eletrônicos. Desta maneira, o tempo para localizar-se uma informação fica condicionado aos tempos de busca e posicionamento dos elementos mecânicos do dispositivo. Outro fator importante neste contexto diz respeito aos algoritmos utilizados pelo sistema operacional para recuperar e gravar as informações nestes dispositivos.

5.6 – Métodos de Acesso

� Acesso seqüencial: Os dados são organizados na memória em unidades chamadas de registros. O acesso é feito segundo uma seqüência específica. O tempo de acesso depende da posição relativa do registro, variando significativamente. Exemplo: Fita magnética.

� Acesso direto: Por meio de uma pesquisa seqüencial em uma vizinhança do registro é obtido o seu

endereço físico, sendo então possível a leitura ou gravação. O tempo de acesso também é variável. Exemplo: Disco magnético (HD).



� Acesso aleatório: Cada posição de memória possui mecanismo de endereçamento fisicamente conectado a ela. O tempo de acesso é o mesmo para todos os endereços. Exemplo: RAM.

� Acesso associativo: Um dado é buscado na memória com base em uma parte de seu conteúdo, e não

de acordo com seu endereço. Exemplo: Memória CACHE.

5.7 – Correção de Erros

Um sistema de memória semicondutora está sujeito a erros. Estes podem ser categorizados como falhas permanentes e erros não permanentes. Uma falha permanente é um defeito físico permanente, de modo que a célula ou células de memória afetadas não podem armazenar dados de modo confiável, mas ficam presas em 0 ou 1, ou alternam erroneamente entre 0 e 1. Os erros permanentes podem ser causados por uso intenso em ambiente impróprio, defeitos de fabricação ou desgaste. Um erro não permanente é um evento aleatório, não destrutivo, que altera o conteúdo de uma ou mais células de memória sem danificar a memória principal. Os erros permanentes podem ser causados por problemas de fonte de alimentação ou partículas alfa. Essas partículas resultam do declínio radioativo e são terrivelmente comuns, pois os núcleos radioativos são encontrados em pequenas quantidades em quase todos os materiais. Erros permanentes e não permanentes certamente são indesejáveis, e a maioria dos sistemas de memória modernos inclui lógica para detectar e corrigir erros.

Os códigos que operam nesse padrão são conhecidos como códigos de correção de erro. Um

código é caracterizado pelo número de erros de bit em uma palavra que ele pode corrigir e detectar. O mais simples dos códigos de correção de erro é o código de Hamming, criado por Richard Hamming. Está técnica consiste em adicionar um bloco de paridade a um bloco de dados, sendo possível detectar e corrigir erros que possam vir a ocorrer. Além de eficientes, estas técnicas devem ser implementadas de maneira que a sua utilização não comprometa o desempenho do sistema e influenciando a taxa de throughput.

5.8 – Memória Virtual

No início da história dos computadores, as memórias eram pequenas e caras. Naquela época o programador gastava muito tempo tentando comprimir programas na minúscula memória. Muitas vezes era necessário usar um algoritmo cuja execução era muito mais lenta do que a de outro algoritmo melhor, simplesmente porque o algoritmo melhor era muito grande – isto é, um programa que o utilizasse não poderia ser comprimido na memória do computador.

A solução tradicional para esse problema era usar uma memória secundária, como um disco

por exemplo. O programador dividia o programa em um certo número de porções, denominadas overlays; cada uma das quais podia caber na memória. O programador era responsável por fragmentar o programa em overlays, decidir em que lugar da memória secundária cada overlay seria mantida, resolver o transporte de overlays entre a memória principal e a memória secundária e, em geral, gerenciar todo o processo de sobreposição sem nenhum auxílio do computador.

Embora tenha sido muito utilizada durante anos, essa técnica envolvia muito trabalho para o

gerenciamento das overlays. Foi desenvolvido então um método para executar o processo de sobreposição automaticamente, sem que o programador soubesse o que estava acontecendo. Esse método, chamado de memória virtual, tinha a óbvia vantagem de livrar o programador de grande parte de uma irritante contabilidade.



A idéia básica da memória virtual é permitir que programas muito maiores que a memória disponível possam ser executados. Com o uso dessa memória o sistema operacional mantém as partes ativas do programa na memória e o restante em disco, sendo carregadas ou removidas da memória de acordo com as necessidades. Essa técnica não depende do tamanho da memória principal. A memória secundária (normalmente um disco rígido) passa a servir como uma espécie de extensão da memória principal, armazenando a maior parte dos programas e dados carregados para execução. À memória principal são transferidas por vez apenas algumas partes destes programas e dados, essenciais ao momento pontual da execução.

Este recurso é disponibilizado, principalmente graças ao suporte dado pelo processador que

contribui com o controle de acesso a memória, permitindo ao sistema operacional transportar temporariamente o conteúdo de blocos para o disco, liberando assim espaço na memória principal. Na família de processadores x86 da Intel, o recurso de memória virtual é suportado quando trabalhamos no modo chamado de "protegido" do processador. Este modo determina a utilização de uma tabela chamada de tabela de descritores, que armazena informações de como está sendo utilizada a memória do equipamento.

Um programa no ambiente de memória virtual não faz referência a endereços físicos de

memória (endereços reais), mas apenas a endereços virtuais. No momento da execução de uma instrução, o endereço virtual referenciado é traduzido para um endereço físico, pois o processador manipula apenas posições da memória principal. O mecanismo de tradução do endereço virtual para endereço físico é denominado mapeamento. Como o espaço de endereçamento virtual não tem nenhuma relação direta com os endereços no espaço real, um programa pode fazer a referência a endereços virtuais que estejam fora dos limites da memória principal, ou seja, os programas e suas estruturas de dados não estão mais limitados ao tamanho da memória física disponível. Para que isso seja possível, o sistema operacional utiliza a memória secundária como extensão da memória principal. Quando um programa é executado, somente uma parte do seu código fica residente na memória principal, permanecendo o restante na memória secundária até o momento de ser referenciado. No desenvolvimento de aplicações, a existência dos endereços virtuais é ignorada pelo programador. Os compiladores e linkers se encarregam de gerar o código executável em função do espaço de endereçamento virtual, e o sistema operacional cuida dos detalhes durante sua execução.

5.9 - Banco de Memórias

Nos PCs comuns, é a memória RAM que guarda toda e qualquer informação que o usuário esteja manipulando, bem como os programas que ele esteja usando para tal. As memórias normalmente são organizadas em pequenas placas de circuito impresso, com chips de memória e contatos. Essas placas são chamadas de módulos de memória ou em linguagem coloquial “pentes de memória”. Qualquer que seja a arquitetura ou o processador empregado, o PC acessa a memória organizada em bancos. Um banco pode possuir um ou mais módulos, dependendo da arquitetura do processador.

Para que os processadores possam trabalhar com qualquer quantidade de memória, é preciso

que exista um barramento de endereços com tamanho suficiente para atender à máxima capacidade de memória endereçável pelo processador. A largura desse barramento e sua divisão em grupos de chips são chamadas de banco de memória.

Antigamente, em processadores das linhas 386 e 486 era necessário um barramento de 32

bits para formar um banco de memória. Já em computadores da linha Pentium, o acesso ao banco é feito a 64 bits de dados por vez. Para formar um banco de memória nos 386, eram necessários 4 módulos SIMM de 30 vias (8 bits em cada módulo).



Dentro de um banco, todos os módulos são acessados ao mesmo tempo, como se fossem um só. Por isso, é necessário que todos os módulos sejam capazes de responder aos chamados do controlador de memória de maneira sincronizada, como uma orquestra. A mínima falta de sincronia entre os módulos irá causar instabilidade no sistema, que poderá levar a travamentos. Por isso, é altamente recomendável que sejam utilizados sempre módulos idênticos dentro de um mesmo banco (mesma marca, mesma capacidade, mesmo tempo de acesso, etc.), preferencialmente adquiridos juntos.

Memórias de computador podem cometer erros de vez em quando, devido a picos de tensão

na linha elétrica ou outras causas. Para se resguardar contra esses erros, algumas memórias usem códigos de detecção de erros ou códigos de correção de erros. Quando esses códigos são usados, bits extras são adicionados a cada palavra de memória de modo especial. Quando uma palavra é lida na memória, os bits extras são verificados para ver se ocorreu um erro.

5.9.1 - Módulo SIMM de 30 vias

Os módulos SIMM (Single In Line Memory Module) foram os primeiros a serem criados. Os contatos ficavam todos do mesmo lado da placa – daí seu nome – e no total eram 30, sendo chamados de vias. Cada módulo transferia 8 bits por ciclo. Naquela época, foram fabricados módulos de diversas capacidades, sendo que os mais comuns eram os módulos de 256 Kb, 1 Mb e 4 Mb, embora houvessem módulos de 512 Kb, 8 Mb e 16 Mb, também.

Esses módulos eram muito comuns em computadores 386 e 486. Seus processadores tinham

a necessidade de combinar quatro módulos de 30 vias para formar cada banco de memória, uma vez que o barramento de dados possuía uma largura de 32 bits. Os 386 SX e mesmo alguns 286, com seus barramentos de 16 bits, precisavam apenas de dois módulos SIMM para preencher um banco.

Os módulos SIMM de 30 vias eram bastante inconvenientes, já que era preciso usar 4

módulos idênticos para formar cada banco de memória. Eles foram desenvolvidos pensando mais na questão da simplicidade e economia de custos do que na praticidade.



5.9.2 - Módulo SIMM de 72 vias

Em computadores mais antigos, para formar cada banco de memória, era preciso usar quatro módulos SIMM de 30 vias idênticos. Para resolver esse inconveniente, os fabricantes desenvolveram um novo tipo de módulo de memória SIMM com, 72 vias e 32 bits.

Esses módulos eram bastante usados em alguns modelos de computadores 486. Assim, em

vez de quatro módulos, era necessário apenas um módulo SIMM de 72 vias para formar cada banco de memória. Era possível, inclusive, misturar memórias de tamanho e procedência diferentes, já que cada uma ocuparia um banco separado.

Os módulos SIMM de 72 vias eram o padrão nos primeiros computadores Pentium. Apesar

de o Pentium II e III, Celeron, Athlon, Duron e outros serem todos processadores de 32 bits, eles acessam 64 bits por vez na memória. Com isso, dobra-se virtualmente a taxa de transferência entre a CPU e a memória: em uma única requisição, carregam-se duas posições de memória.

Como o Pentium II e posteriores acessam a memória usando palavras de 64 bits, são

necessários 2 módulos em cada banco – o que acarreta a necessidade de se ter módulos idênticos em um mesmo banco para evitar problemas.

O acesso de 64 bits à memória foi introduzido para permitir que o processador conseguisse

acessar grandes quantidades de dados mais rapidamente. O processador é tão mais rápido que a memória RAM, que depois de esperar vários ciclos para poder acessá-la, o melhor a fazer é pegar a maior quantidade de dados possível e guardar tudo no cache. Naturalmente os dados serão processados em blocos de 32 bits, mas a economia ajuda bastante.

Dentro de um banco, todos os módulos são acessados ao mesmo tempo, como se fossem um

só, por isso era sempre recomendável usar dois módulos iguais. Ao usar quatro módulos, o importante era que cada par fosse composto por dois módulos iguais. Não existia problema em usar dois pares de módulos diferentes, como ao usar dois de 16 MB e mais dois de 8 MB para totalizar 48 MB, por exemplo.



5.9.3 - Módulo DIMM

Ao contrário dos módulos SIMM de 30 e 72 vias, os módulos DIMM possuem contatos em ambos os lados do pente, o que justifica seu nome, “Double In Line Memory Module” ou “módulo de memória com duas linhas de contato”. Como os módulos DIMM trabalham com palavras binárias de 64 bits, um único módulo é suficiente para preencher um banco de memória. Existem memórias DIMM de 168, 184 e de 240 vias. Sua utilização depende do padrão adotado pela placa mãe.

Apesar do número diferente de contatos (ou vias), os módulos de memória são todos no mesmo tamanho. Desta maneira, existem diferenças entre as arquiteturas no que diz respeito à posição do encaixe, evitando assim que módulos diferentes possam ser encaixados na placa mãe. Isto se faz necessário devido a vários motivos, entre eles as diferenças de tensão. Enquanto os módulos de 240 vias usam tensão de 1.8 v, os módulos de 184 vias trabalham com tensões em torno de 2.5 v. Com certeza, a instalação de um módulo de 240 vias, se assim fosse possível, em uma placa mãe que trabalha com módulos de 184 vias acabaria por queimar o módulo rapidamente.

5.9.4 - Módulo RIMM

Padronizado pela empresa Rambus, este módulo de memória (Rambus In Line Memory Module) foi desenvolvido para a utilização de memórias RDRAM (veremos os diferentes chips de memória mais adiante neste capítulo). O módulo RIMM é fisicamente muito parecido com o DIMM, mas os tipos de encaixes (soquetes) para memória são diferentes.

Os módulos de memória RIMM em geral vêm com uma proteção de metal, que objetiva

facilitar a dissipação de calor, uma vez que os mesmos aquecem bastante devido à alta freqüência de operação.

Cada módulo só é capaz de transferir 16 bits de cada vez, mas o controlador de memória

agrupa 4 acessos à memória antes de entregar os dados para a CPU, formando assim os 64 bits necessários. Desta forma os bancos de memória podem ser compostos de apenas 1 módulo.

Curiosamente, as memórias Rambus trabalham em pares com "módulos vazios" ou "pentes

cegos". Isso significa que, para cada módulo Rambus instalado, um "módulo vazio" tem que ser instalado em outro slot.



5.10 - Memórias RAM

Os módulos de memória que acabamos de ver nada mais são do que pequenas placas de circuito impresso com chips de memória RAM (Random Access Memory) soldados nos respectivos pentes. As memórias RAM sempre foram um componente muito importante na computação. O chip de memória armazena temporariamente a informação, perdendo todo o seu conteúdo quando o computador é desligado, porém enquanto o computador estiver ligado, a informação poderá ser escrita e lida novamente neste chip.

Este tipo de memória é utilizado em computadores para armazenamento temporário de

programas em execução e dados. Algumas delas podem ser alimentadas por baterias – a maioria consome pouca energia operando em standby. Um exemplo é a pequena RAM que guarda as informações e ajustes do computador (Bios Setup).

O sistema operacional, os programas em execução e os documentos abertos ficam

armazenados na memória RAM enquanto o computador está ligado, fazendo com que ela seja acessada pelo processador constantemente. Quando a memória RAM se esgota, o processador transfere o seu conteúdo para uma “memória virtual” – na verdade, um arquivo no disco rígido – liberando espaço na memória RAM “real”.

Há dois tipos principais de memória RAM: estáticos e dinâmicos. Cada um deles se

comporta de maneira diferente e presta-se a aplicações diferentes. As memórias dinâmicas (DRAM) são extremamente baratas e fisicamente pequenas,

viabilizando a construção de chips com grande capacidade de memória. Seu consumo de energia também é extremamente baixo, a ponto de ser alimentada por uma bateria durante anos.

Entretanto, as memórias dinâmicas precisam constantemente de um sinal, chamado refresh,

para manter o conteúdo em todas as células – daí seu nome “dinâmico”. Sem o refresh, a memória perde seu conteúdo em alguns milissegundos. É necessário usar, portanto um controlador de memória especial que providencie esse sinal de refresh. Devido a isto, as memórias dinâmicas são muito mais lentas do que as estáticas.

As memórias estáticas (Static RAM ou SRAM), por outro lado tem um tempo de acesso

muito pequeno, sendo mais rápidas. São empregadas em situações em que não pode haver atrasos no processamento. Elas têm ainda a vantagem de não precisarem do pulso de refresh, por isso mesmo são chamadas de estáticas. A seguir apresentamos algumas tecnologias de memórias RAM.

5.10.1 – Fast Page Mode (FPM)

A primeira melhora significativa na arquitetura das memórias veio com o FPM, ou “modo de acesso rápido”. A idéia é que, ao ler um arquivo qualquer gravado na memória, os dados estão na maioria das vezes gravados seqüencialmente. Desta forma, a memória FPM retém o valor da última linha acessada. Assim, nas próximas vezes em que essa linha for acessada, seu valor não precisará mais ser enviado para a memória pelo controlador de memória. O resultado disso é que o acesso fica mais rápido. As memórias FPM são de tecnologia mais antiga, apesar de serem encontradas nos 486 e nos primeiros Pentium. Possuem tempo de acesso de 80, 70 e 60 ns e suportam velocidades de barramento de até 66 MHz. É possível encontrá-las em forma de módulos SIMM de 30 ou 72 vias.



5.10.2 - Extended Data Out (EDO)

A memória EDO surgiu em meados de 1994 (época do Pentium), como resultado de uma pequena modificação na estrutura da memória FPM. Um acesso a dados pode ser iniciado antes que o anterior termine. Assim, o próximo endereço pode começar a ser enviado à memória enquanto os dados ainda estão em sua saída. O resultado acaba sendo exatamente o mesmo, mas passa a ser feito de forma mais rápida.

Os chips de memória EDO foram usados predominantemente na forma de módulos de 72 vias, usados nos micros 486 e Pentium fabricados a partir do ano de 1995. Existiram ainda alguns módulos DIMM de 168 com memória EDO. Eles foram bastante raros, pois foram logo substituídos pelos pentes de memória SDRAM (comentados no item 5.10.4). Basicamente, apenas as placas para processadores Pentium e algumas placas mãe para 486 aceitam trabalhar com memórias EDO.

O ganho de desempenho nominal da memória EDO sobre a FPM é de 20%. Na prática, esse

ganho é de 8% para as operações de leitura em memória. Sua utilização irá depender do chipset da placa-mãe, que deve suportar a tecnologia EDO.

5.10.3 - Burst Extend Data Out (BEDO)

Este tipo de memória é bastante raro. Na verdade, elas nunca foram utilizadas em larga escala. A única diferença entre as memórias BEDO e EDO é que a primeira possui controlador de endereços integrado, fazendo com que a própria memória coloque os próximos três dados automaticamente no barramento de dados. O desempenho para leitura de dados consecutivos aumenta drasticamente, embora, na escrita, seu desempenho seja idêntico ao da memória EDO.

As placas-mãe da Intel na época não ofereciam suporte à memória BEDO, sendo este o

provável motivo pelo qual esta tecnologia não se popularizou. Foi ofuscada pelo lançamento das memórias SDRAM, que apesar de um pouco mais caras, ofereciam uma performance levemente superior às BEDO e desfrutavam de compatibilidade com todos os chipsets modernos.

5.10.4 - Synchronous Dynamic RAM (SDRAM)

As tecnologias apresentadas até agora são chamadas assíncronas, pois não dependem da freqüência de clock da máquina para trabalhar. Assim, a CPU tem de “ficar esperando” enquanto a memória não resolve entregar o dado solicitado. Por isso mesmo, as assíncronas não permitem funcionamento acima de 66 MHz sem o uso de overclock.

Ao contrário dessas tecnologias, a memória SDRAM como o nome diz é síncrona: utiliza o

clock do barramento local para comandar os seus circuitos internos. Por isso, é capaz de trabalhar em sincronia com a freqüência da placa mãe. Como a memória SDRAM é comandada pelo clock do sistema, o processador pode se programar para buscar dados após uma determinada quantidade de pulsos de seu próprio clock.

A partir da memória SDRAM, tornou-se desnecessário falar em tempos de acesso, já que a

memória trabalha de forma sincronizada em relação aos ciclos da placa-mãe. As memórias passaram então a ser rotuladas de acordo com a freqüência em que são capazes de operar. (PC-66, PC-100, PC-133 etc.). A velocidade do acesso à memória foi aumentada conforme a evolução dos processadores.



Outra característica importante da SDRAM diz respeito ao registrador de modo e a lógica associada. O registrador de modo especifica o tamanho da seqüência de dados, ou seja, o número de unidades de dados a serem transferidas sincronamente por meio do barramento. Esse registrador também permite ao programador ajustar o tempo de latência entre o recebimento de um requisito de leitura e o início da transferência de dados.

5.10.5 - Double Data Rate SDRAM (DDR-SDRAM)

As memórias DDR-SDRAM conseguem obter o dobro do desempenho das memórias SDRAM tradicionais, operando com o mesmo clock. Em vez de transferirem um dado por pulso de clock, como é usual, elas transferem dois dados por pulso de clock.

Note que o fato da memória DDR-SDRAM possuir o dobro do desempenho da memória

SDRAM não significa que um micro equipado com memória DDR-SDRAM terá o dobro do desempenho de um micro com mesma configuração usando memórias SDRAM tradicionais. Afinal, a tecnologia de memória RAM utilizada é somente um dos fatores que influenciam no desempenho geral da máquina.

As memórias DDR são vendidas em módulos DDR-DIMM, oficialmente conhecidos como

DIMM/184. Esses módulos possuem um desenho diferenciado, justamente para impedir que os módulos DDR sejam encaixados em bancos SDRAM. Note que o módulo SDRAM possui dois encaixes horizontais, ao contrário do DDR, que possui apenas um.

Embora muito parecidas com as memórias SDR SDRAM, as memórias DDR possuem um

diferencial considerável: trabalham com 2,5 V, contra 3,3 V da primeira. Assim sendo, reduzem o consumo de energia, aspecto especialmente importante em dispositivos portáteis, como notebooks.

5.10.6 - Memória Rambus

Os módulos de memórias Rambus são chamados de "Rambus Inline Memory Modules" ou RIMMs. Os módulos RIMM são bem semelhantes aos módulos DIMM, mas em geral eles vêm com uma proteção de metal sobre os chips de memória, que também serve para facilitar a dissipação de calor, já que os módulos RIMM aquecem bastante devido à alta freqüência de operação.

Esta memória usa um barramento próprio, desenvolvido pela empresa, que lhe permite

altíssimas velocidades de transferência de dados. Entretanto, ele transfere 16 bits de cada vez, o que não chega a ser um problema em razão das elevadas taxas de transferência, que suprem a diferença de largura de bits do barramento.

Por possuir uma tecnologia proprietária da empresa Rambus, fabricantes de memórias e

chips que queiram utilizar a memória Rambus são obrigados a pagar direitos autorais à empresa. As placas-mãe que aceitam este tipo de memória são mais caras; em compensação, essas memórias conseguem “conversar” na mesma velocidade externa do processador – com um desempenho superior ao das DDR.

Diferentemente das memórias DDR SDRAM, que são apenas evoluções das memórias SDR

SDRAM, as memórias Rambus trazem uma arquitetura completamente nova, que exige modificações muito maiores nos chipsets destinados a suportá-la, significando maiores custos de desenvolvimento e produção. Por este motivo que o padrão DDR SDRAM "venceu" a batalha e tornou-se padrão desde o ano 2000.



5.11 - Memórias ROM

A ROM (Read Only Memory ou memória somente de leitura) armazena permanentemente as informações gravadas, mesmo que o computador seja desligado. Mesmo memórias que foram retiradas de seus equipamentos ainda mantêm os dados armazenados. Por outro lado, esse tipo de memória é apenas de leitura, não permitindo que os dados sejam alterados ou sobrescritos.

As memórias ROM recebem esse nome porque os dados são gravados nelas apenas uma vez.

Depois disso, essas informações não podem ser apagadas ou alteradas, apenas lidas pelo computador exceto por meio de procedimentos especiais. Outra característica das memórias ROM é que elas são do tipo não volátil, isto é, os dados gravados não são perdidos na ausência de energia elétrica ao dispositivo.

Em computadores, as ROMs são usadas para armazenar programas que devem ser lidos no momento em que a máquina for ligada. No caso do PC, o programa de que a CPU precisa para funcionar e algumas rotinas de sistema freqüentemente usadas são gravadas em uma ROM. O nome desse programa é BIOS – Basic Input/Output System.

Os circuitos de memória ROM podem ser construídos utilizando-se uma das seguintes

tecnologias básicas: � Mask-ROM: uma ROM cujos programas ou dados já vêm gravados de fábrica. Não há a possibilidade

de apagar ou regravar o seu conteúdo. � PROM (Programmable ROM): é vendida “limpa”; o usuário se encarrega de fazer a gravação do seu

conteúdo. Uma vez gravada, não há como apagar ou alterar seu conteúdo. Enquanto a ROM é gravada durante a fabricação, a PROM é gravada pelo fabricante do equipamento que a utilizará.

� EPROM (Erasable Programable ROM): da mesma forma que a PROM, a EPROM também é vendida

virgem, devendo ser gravada pelo comprador. Esta memória possui uma “janela” transparente que apaga o que está gravado mediante exposição a raios ultravioleta. A programação pode ser feita com o auxílio de um equipamento especial, o programador de EPROM. Apesar de, em uso normal, o dispositivo ser apenas de leitura, a EPROM pode ser regravada inúmeras vezes.

� EEPROM (Electronic Erasable Programable ROM): a EEPROM é uma EPROM sem a “janela”

transparente. O apagamento é feito por impulsos elétricos. A vantagem é a de permitir a reprogramação de circuitos sem a necessidade de removê-los

� FlashROM: a memória Flash é o resultado da evolução das memórias EEPROM. Este tipo de memória

utiliza baixas tensões de apagamento e apresenta um tempo de reprogramação bem mais curto. É usada com sucesso em substituição a discos rígidos em sistemas embarcados.



Exercícios 01 – Considere as afirmativas a seguir:

I. A memória é o componente de um sistema de computação cuja função é armazenar informações. II. Um sistema de computação normalmente possui apenas um tipo de memória. III. O aumento da velocidade das CPUs tem sido bem maior que o aumento da velocidade de acesso das

memórias Estão corretas as afirmativas:

a) Todas as alternativas estão erradas. b) I e II c) I e III d) II e III e) Todas as alternativas estão corretas

02 - A necessidade da existência de vários tipos de memória ocorre em virtude de vários fatores concorrentes. Explique um destes fatores. 03 – Um dos parâmetros utilizados para analisar as características de um tipo de memória é sua volatilidade. Em que consiste este parâmetro? 04 – Qual a função da memória cache? A mesma pode ser classificada como L1 e L2. Explique essa classificação. 05 – Por que se indica a utilização de módulos idênticos na composição de um banco de memórias? 06 – Em quê os módulos de memória DIMM diferem dos módulos de memória SIMM? 07 - Os programas em execução ficam armazenados na memória principal. Quando ela se esgota, o processador transfere o seu conteúdo para a memória virtual. Em que consiste o conceito de memória virtual? 08 – Existem dois tipos principais de memória RAM: estáticos e dinâmicos. Cada um deles se comporta de maneira diferente e presta-se a aplicações distintas. Explique o funcionamento destes dois tipos. 09 – A memória Flash substitui com sucesso discos rígidos em sistemas embarcados. O que é um sistema embarcado? Exemplifique.



6- Memória Externa

6.1 - Introdução

Este capítulo aborda uma variedade de dispositivos e sistemas de memória externa. Começamos pelo dispositivo mais importante, o disco magnético. Os discos magnéticos constituem a base da memória externa de quase todos os sistemas de computação. Em seguida, discutimos o uso de vários discos para obtenção de maior desempenho, tratando especificamente da família conhecida como RAID (redundant array of independent disks). Um componente de importância crescente em muitos sistemas de computação é a memória externa óptica, que é abordada na terceira seção. A seção final trata das fitas magnéticas.

6.2 - Discos Magnéticos

Somos uma sociedade dependente da informação. Consumimos cada vez mais espaço para armazenar nossos dados. A demanda por capacidade de armazenamento vem crescendo exponencialmente, dando origem a muitas novas tecnologias e dispositivos. E, sem dúvida alguma, o dispositivo mais usado atualmente para armazenamento de informações é o disco rígido, que possui inúmeros “apelidos”, como winchester, hard disk ou simplesmente HD.

O termo winchester foi originalmente usado pela IBM como um codinome para o modelo de

disco 3340, antes do seu lançamento no mercado. O 3340 era composto de um pacote de discos removíveis, com cabeçotes lacrados dentro da cápsula. O termo é empregado atualmente para qualquer unidade de discos lacrada, que utiliza cabeçote aerodinâmico.

O disco magnético é constituído de um prato circular de metal ou de plástico, coberto com

um material que pode ser magnetizado. Os dados são gravados e posteriormente lidos do disco por meio de uma bobina condutora denominada cabeçote, conhecida também como cabeça de leitura/gravação. Durante uma operação de escrita ou de leitura, o cabeçote permanece estático, enquanto o prato gira embaixo dele.

O mecanismo de escrita é baseado no fato de que o fluxo de corrente elétrica por meio de

uma bobina produz um campo magnético. São enviados pulsos de corrente para o cabeçote, que resultam na gravação de padrões magnéticos na superfície abaixo dele; correntes positivas e negativas geram padrões magnéticos distintos. O mecanismo de leitura é baseado no fato de que um campo magnético que se move em relação a uma bobina produz uma corrente elétrica nessa bobina. Quando a superfície do disco passa sob o cabeçote, ela gera uma corrente de polaridade igual à da corrente utilizada na gravação.

6.2.1 - Organização e Formatação de Dados

O cabeçote é um dispositivo relativamente pequeno, capaz de ler ou escrever sobre uma região do prato que gira embaixo dele. Isso resulta em uma organização dos dados no prato em forma de anéis concêntricos, denominados trilhas. Cada trilha tem a mesma largura do cabeçote. Existem tipicamente, 500 a 2000 trilhas por superfície.

Trilhas adjacentes são separadas por espaços (gaps). Isso evita, ou pelo menos diminui, a

ocorrência de erros devido à falta de alinhamento do cabeçote ou à interferência de campos magnéticos.



Para simplificar o circuito eletrônico envolvido, um mesmo número de bits é armazenado em cada trilha. Desta maneira, a densidade, em número de bits por centímetro linear, aumenta a partir da trilha mais externa para a mais interna.

Os dados são transferidos em blocos. Normalmente

um bloco tem tamanho menor do que a capacidade de uma trilha. Os dados são armazenados em regiões do mesmo tamanho de um bloco, denominadas setores. Existem tipicamente, entre 10 e 100 setores por trilha, que podem ser de tamanho fixo ou variável. Para evitar impor requisitos de precisão exagerados ao sistema, setores adjacentes são separados por espaços internos à trilha (ou espaço entre setores).

O sistema requer a existência de algum mecanismo

para localizar um setor dentro de uma trilha. Naturalmente, devem existir um ponto de início da trilha e uma maneira de identificar o início e o fim de cada setor. Essas informações são fornecidas por dados de controle gravados no disco. Desse modo, um disco é formatado com alguns dados extras, usados apenas pela unidade de disco e são invisíveis para o usuário.

A geometria de um disco significa a forma como ele está dividido (em trilhas, setores etc) e

somente pode ser definida durante a formatação física de um disco. No que diz respeito à sua formatação lógica, esta somente poderá ser feita pelo sistema operacional, possibilitando criar um “ambiente” no disco, para armazenar tabelas de diretórios, arquivos etc.

6.2.2 – Características Físicas

Abaixo são listadas as características mais importantes que diferenciam os diversos tipos de discos magnéticos: Movimento do Cabeçote Pratos Cabeçote fixo (um por trilha) Prato único Cabeçote móvel (um por superfície) Múltiplos pratos Transportabilidade do disco Mecanismo do cabeçote Disco não removível Contato Disco removível Espaço fixo Espaço aerodinâmico Lados Lado único Duplo lado

Primeiramente, o cabeçote pode ser fixo ou móvel em relação à radial do prato. Em um disco de cabeçote fixo existe um cabeçote de leitura e escrita para cada trilha. Os cabeçotes são montados em um braço rígido que se estende por todas as trilhas. Em um disco de cabeçote móvel existe apenas um cabeçote de leitura e escrita. Esse cabeçote é também montado em um braço. Como o cabeçote deve poder ser posicionado sobre qualquer trilha, o braço pode ser estendido ou retraído.



O disco propriamente dito é montado em uma unidade de disco, que consiste em um braço, um eixo para girar o disco e circuitos eletrônicos para a entrada e saída de dados binários. Um disco não removível é montado permanentemente na unidade de disco. Um disco removível pode ser removido e substituído por outro disco. A vantagem dos discos removíveis é possibilitar o armazenamento de uma quantidade ilimitada de dados usando um número limitado de unidades de disco e um número ilimitado de discos. Além disso, esse disco pode ser transportado de um computador para outro.

Na maioria dos discos, a

cobertura magnetizável é aplicada nos dois lados do prato, sendo assim denominado de duplo lado. Alguns sistemas de disco mais baratos usam discos de um único lado.

Algumas unidades de

disco acomodam múltiplos pratos, empilhados verticalmente e separados por cerca de 2,5 cm. São usados braços múltiplos. Os pratos são agrupados em unidades denominadas pacotes de disco.

Os discos são classificados em três tipos de acordo com o mecanismo de cabeçote utilizado.

Tradicionalmente, o cabeçote de leitura e escrita é posicionado a uma distância fixa acima do prato, existindo uma fina camada de ar entre o cabeçote e o prato. Outro mecanismo utiliza cabeçotes que de fato tocam o prato durante uma operação de leitura ou escrita. Esse tipo de mecanismo é utilizado no disquete.

Para entender o terceiro tipo de disco, é necessário conhecer a relação entre a densidade dos

dados e a altura da camada de ar entre o cabeçote e o prato. Para ler ou escrever um dado, o cabeçote tem de gerar ou sentir um campo eletromagnético de magnitude suficiente. Quanto mais estreito é o cabeçote, mais próximo ele deve estar da superfície do prato para funcionar corretamente. Um cabeçote mais estreito possibilita trilhas mais estreitas e, portanto, maior densidade de dados, o que é desejável. Entretanto, quanto mais próximo o cabeçote estiver do disco, maior será o risco de ocorrência de erros devido a impurezas ou imperfeições. Um avanço na tecnologia de discos foi obtido com o desenvolvimento dos discos Winchester. Os cabeçotes do winchester são montados em unidades de disco lacradas, quase livres de contaminações. São projetados para operar mais perto da superfície do disco do que os cabeçotes dos discos rígidos convencionais, possibilitando assim maior densidade de dados. São, de fato, uma lâmina aerodinâmica que descansa levemente sobre a superfície do prato quando o disco está imóvel. A pressão do ar gerada pelo disco ao girar é suficiente para fazer a lâmina erguer-se acima da superfície. O sistema sem contato resultante pode ser projetado para usar cabeçotes mais estreitos, que podem operar mis próximos da superfície do prato do que os cabeçotes dos discos rígidos convencionais.

6.2.3 – Parâmetros de desempenho de discos

Os detalhes de uma operação de E/S em um disco dependem do sistema de computação, do sistema operacional e do hardware usado no canal de E/S e no controlador de disco.

Quando uma unidade de disco está em operação, o disco gira a uma velocidade constante.



Para ler ou escrever um valor, o cabeçote deve ser posicionado sobre a trilha desejada e no início do setor desejado da trilha. A seleção da trilha requer a movimentação do cabeçote, em um sistema de cabeçote móvel, ou a seleção eletrônica de um dos cabeçotes, em um sistema de cabeçote fixo. Em um sistema de cabeçote móvel, o tempo para posicionar o cabeçote na trilha é denominado tempo de busca (seek time). Em ambos os sistemas, uma vez selecionada a trilha, o controlador de disco espera que o disco gire até que o setor desejado esteja alinhado com o cabeçote. O tempo decorrido até que o início do setor esteja sob o cabeçote é denominado atraso rotacional ou latência rotacional. A soma do tempo de busca se houver, com o atraso rotacional é denominada tempo de acesso, isto é, o tempo requerido para atingir a posição em que deve ser feita a leitura ou a escrita. Uma vez que o cabeçote esteja na posição correta, a operação de leitura ou escrita é feita à medida que o setor se move sob o cabeçote; essa parte da operação corresponde à transferência de dados.

Além do tempo de acesso e do tempo de transferência, existem normalmente vários atrasos

associados a uma operação de E/S em um disco. Quando um processo faz uma requisição de E/S, ela deve primeiro esperar em uma fila até que o dispositivo esteja disponível. O dispositivo é então alocado para o processo. Se o dispositivo compartilha um canal de E/S ou um conjunto de canais de E/S com outras unidades de disco, pode haver uma espera adicional para que o canal fique disponível. Quando isso ocorre, a operação de busca da trilha pode ser iniciada.

Em alguns sistemas de grande porte, é usada uma técnica conhecida como detecção de

posição de rotação (rotational positional sensing – RPS). Quando uma operação de busca no disco é iniciada, o canal é liberado para atender a outras operações de E/S. Ao finalizar a busca, o dispositivo determina quando os dados estarão posicionados sob o cabeçote. Assim que o setor requerido se aproxima do cabeçote, o dispositivo tenta restabelecer a comunicação com o sistema. Se a unidade de controle ou o canal estiverem ocupados com outra operação de E/S, a tentativa de conexão falhará e o dispositivo terá de girar um ciclo inteiro antes de tentar uma nova conexão.

6.3 - RAID

Como foi discutido anteriormente, a melhoria no desempenho de memórias secundárias tem sido consideravelmente menor do que a de processadores e da memória principal. Essa diferença fez dos sistemas de armazenamento em discos o principal foco de preocupação para melhoria do desempenho global de sistemas de computação.

Assim, como em outras áreas, os projetistas de armazenamento de disco sabem que, se um

dispositivo pode ser melhorado apenas até certo ponto, ganhos adicionais de desempenho podem ser obtidos utilizando vários componentes em paralelo. No caso de armazenamento de disco, essa idéia levou ao desenvolvimento de um agrupamento de discos que operam independentemente e em paralelo, desde que os dados requeridos residam em discos separados. Mais do que isso, uma única requisição de E/S poderá também ser executada em paralelo, se o bloco de dados a ser acessado for distribuído em vários discos.

Com o uso de múltiplos discos, os dados podem ser organizados de diversas maneiras,

podendo ser empregada alguma redundância para melhorar a confiabilidade. A possibilidade de organizar os dados de vários modos poderia tornar difícil o desenvolvimento de bancos de dados compatíveis com diferentes plataformas e sistemas operacionais. Felizmente, a indústria decidiu adotar um padrão para o projeto de banco de dados de vários discos conhecido como RAID (agrupamento redundante de discos independentes).



O esquema RAID consiste em sete níveis (níveis adicionais de RAID foram definidos por alguns pesquisadores e algumas companhias, mas os sete níveis descritos nesta seção são os únicos aceitos universalmente), de zero a seis. Esses níveis não implicam em uma relação hierárquica, mas designam diferentes arquiteturas de projeto que compartilham três características comuns:

1. O RAID consiste em um agrupamento de unidades de discos físicos, visto pelo sistema operacional como uma única unidade de disco lógico.

2. Os dados são distribuídos pelas unidades de discos físicos do agrupamento.

3. A capacidade de armazenamento redundante é utilizada para armazenar informação de paridade,

garantindo a recuperação dos dados em casa de falha de algum disco.

Os detalhes da segunda e da terceira características diferem para os diferentes níveis de RAID. O RAID 0 não oferece a terceira característica.

O termo RAID foi originalmente empregado em um artigo de um grupo de pesquisadores da

Universidade da Califórnia, em Berkeley. Esse artigo esboçava várias configurações e aplicações de RAID e introduzia as definições dos níveis de RAID usados até hoje. A estratégia RAID substitui as unidades de disco de grande capacidade por várias unidades de capacidade menor, distribuindo os dados para possibilitar acessos simultâneos nas várias unidades e, desse modo, melhorar o desempenho de E/S e facilitar o aumento significativo de capacidade da memória secundária.

Uma característica única da tecnologia RAID se refere ao uso eficaz de redundância de

dados. Embora o uso simultâneo de vários cabeçotes e discos possibilitem obter taxas de transferência de E/S mais altas, isso aumenta também a probabilidade de falhas. Para compensar essa diminuição de confiabilidade, o RAID usa a informação de paridade armazenada que possibilita a recuperação dos dados perdidos devido a uma falha de disco.



6.3.1 - RAID de Nível 0

O RAID de nível 0 não constitui de fato um membro da família RAID, uma vez que não inclui redundância para a melhoria do desempenho. Contudo, ele é utilizado em poucas aplicações, como em supercomputadores, nos quais o desempenho e a capacidade constituem requisitos primordiais e o baixo custo é mais importante do que maior confiabilidade.

No RAID 0, os dados de usuário e de sistema são distribuídos em todos os discos do

agrupamento. Essa distribuição dos dados tem enorme vantagem em relação ao uso de um único disco grande:se existirem duas requisições de E/S pendentes para dois blocos de dados distintos, haverá grande probabilidade de que esses blocos estejam em discos diferentes. Portanto, as duas requisições podem ser atendidas em paralelo, reduzindo o tempo de espera na fila de E/S.

Assim como os demais níveis de RAID, o RAID 0 não

se limita a distribuir os dados pelo agrupamento de discos. Os dados são intercalados em tiras (strips) por meio dos discos disponíveis.

Em qualquer dos níveis RAID, o desempenho

depende fundamentalmente do padrão das requisições de E/S e da organização dos dados. Essas questões são tratadas mais facilmente no RAID 0, onde a análise não sofre interferência da redundância dos dados.


O RAID 1 difere dos RAIDs de nível 2 a 6 pela maneira como a redundância é obtida. Nesses outros níveis, é utilizado algum tipo de cálculo de paridade para introduzir redundância. No RAID 1, a redundância é obtida pela simples duplicação dos dados. Os dados são intercalados em tiras, como no RAID 0, entretanto, nesse caso, cada tira lógica é mapeada em dois discos físicos separados, de modo que cada disco do agrupamento tenha como espelho um outro disco que contém os mesmos dados.

A organização RAID 1 tem diversos aspectos positivos:

1. Uma requisição de leitura pode ser servida por qualquer dos dois discos que contenha os dados

requeridos, preferencialmente por aquele no qual o tempo de busca somado à latência rotacional seja menor.

2. Uma requisição de escrita requer a atualização das duas

tiras correspondentes, mas isso pode ser feito em paralelo. Dessa maneira, o desempenho da requisição de escrita é determinado pela operação de escrita mais lenta.

3. A recuperação de uma falha é simples. Quando ocorre

uma falha em uma unidade de disco, os dados ainda podem ser obtidos a partir da segunda unidade.



A principal desvantagem do RAID 1 é o custo; ele requer uma espaço de disco físico igual a duas vezes o do disco rígido. Por isso, uma configuração RAID 1 geralmente é utilizada apenas em unidades de disco que armazenem software e dados do sistema e outros arquivos altamente críticos. Nesses casos, o RAID 1 oferece uma cópia de segurança de todos os dados em tempo real, de modo que, mesmo ocorrendo uma falha em um disco, todos os dados críticos permaneçam disponíveis.


Os RAIDs de nível 2 e 3 usam a técnica de acesso paralelo. Em um agrupamento com acesso paralelo, todos os discos participam da execução de qualquer requisição de E/S. Tipicamente os eixos das unidades de disco são sincronizados, de modo que, em qualquer instante, os cabeçotes de todos os discos estejam na mesma posição.

Assim como nos demais esquemas RAID, é usada intercalação de dados em tiras. Nos RAIDs de níveis 2 e 3, as tiras são muito pequenas, freqüentemente do tamanho de um byte ou uma palavra. No RAID 2, um código de correção de erros é calculado para os bits correspondentes de cada disco de dados e os bits do código são armazenados em posições de bit correspondentes nos vários discos de paridade.

Embora o RAID 2 exija um número de discos menor que o RAID 1, ele ainda é muito caro.

O número de discos redundantes necessários é proporcional ao logaritmo do número de discos de dados. Em uma requisição de leitura ou escrita , todos os discos são acessados simultaneamente.

Ele constitui uma boa escolha apenas em ambientes nos quais podem ocorrer muitos erros

de disco. Dada a alta confiabilidade de discos individuais e de controladores de disco, o esquema RAID 2 é excessivo e por isso não é implementado.


O RAID 3 é organizado de maneira similar ao RAID 2. A diferença é que o RAID 3 requer apenas um disco redundante, independentemente do tamanho do agrupamento de discos. O RAID 3 emprega acesso paralelo, com os dados distribuídos em pequenas tiras. Em vez de um código de correção de erros, apenas um bit de paridade simples é utilizado para cada conjunto de bits localizados na mesma posição em todos os discos de dados.



No caso de falha de uma unidade de disco, o disco de paridade é acesso e os dados são reconstruídos a partir dos dados dos dispositivos restantes. Quando a unidade defeituosa for substituída, os dados que faltam podem ser restaurados no disco e a nova unidade pode entrar em operação.

Como os dados são distribuídos em tiras bem pequenas, o RAID 3 pode alcançar taxas de

transferência de dados bastante altas. Qualquer requisição de E/S envolve a transferência paralela de dados de todos os discos de dados. A melhora de desempenho pode ser especialmente notada no caso de grandes transferências de dados. Por outro lado, apenas uma requisição pode ser executada a cada vez. Dessa maneira, em um ambiente orientado para transações, o desempenho é relativamente baixo.

6.3.5 - RAID de Níveis 4, 5 e 6

Os RAIDs de nível 4 a 6 usam a técnica de acesso independente. Em um agrupamento com acesso independente, cada disco opera independentemente, permitindo que requisições de E/S distintas possam ser satisfeitas em paralelo. Por isso, agrupamentos com acesso independente são mais adequados para aplicações que requerem altas taxas de requisições de E/S, não sendo apropriados para aplicações que necessitam de altas taxas de transferência de dados.

Como nos demais esquemas RAID, é usada a intercalação de dados em tiras. Nos RAIDs de

nível 4 a 6, as tiras são relativamente grandes. No RAID 4, uma tira de paridade é calculada bit a bit sobre as tiras correspondentes em cada disco de dados e os bits de paridade são armazenados na tira correspondente do disco de paridade.

No RAID 4, a escrita de pequenas quantidades de dados envolve certa penalidade. Para cada

escrita, o software de gerenciamento do agrupamento tem de atualizar não apenas os dados de usuário, mas também os bits de paridade correspondentes.

O RAID 5 é organizado de modo semelhante ao RAID 4. A diferença é que o RAID 5

distribui as tiras de paridade por todos os discos. Uma alocação típica consiste em um esquema circular. Para um agrupamento de n discos, a tira de paridade das n primeiras tiras de dados é armazenada em um disco diferente e esse padrão então se repete. A distribuição das tiras de paridade em todos os discos evita a possibilidade de formação de gargalos no desempenho do sistema existentes no RAID 4.

No RAID 6, são usados dois cálculos de paridade diferentes e os resultados são

armazenados em blocos separados em discos distintos. Dessa maneira, um agrupamento de RAID 6 no qual os dados de usuário requerem N discos é constituído de N + 2 discos. A vantagem do RAID 6 é que apresenta uma disponibilidade de dados extremamente alta, reduzindo-se assim a possibilidade de os dados armazenados serem perdidos. No entanto, o RAID 6 envolve uma penalidade substancial em operações de escrita, pois cada área escrita afeta dois blocos de paridade.



6.4 - Interfaces

Um disco magnético é um dispositivo para armazenar informação que possui uma grande densidade e um tempo de acesso relativamente rápido. De nada adianta um disco rígido muito rápido, se a interface não permite que ele se comunique com o restante do sistema usando toda a sua velocidade. Entende-se por interface a conexão física e funcional entre dois aparelhos ou sistemas independentes. No nosso caso os discos interagem com o equipamento ao qual estão conectados por diferentes sistemas. Utilizar um ou outro dependerá da aplicação para a qual está destinado tal disco. Há dois grandes padrões que normalizam as interfaces dos discos; o padrão IDE/ATA e o Standard SCSI. Vamos falar um pouco sobre estas tecnologias.

6.4.1 - IDE A tecnologia IDE surgiu quando a Compaq, projetando o seu Compaq/385, decidiu criar um

tipo de disco rígido que, além de ser mais barato que o padrão SCSI, também tivesse uma capacidade de armazenamento superior à dos padrões dos discos rígidos existentes na época. Mas o aumento da capacidade acarretava problemas de ruído entre o disco rígido e a interface controladora, o que impedia algumas transmissões por causa da divergência do sinal, e fazia com que o disco rígido solicitasse novamente a retransmissão dos dados à controladora.

No ano de 1986, a empresa Westem Digital e a Compaq apresentaram uma solução para eliminar os problemas ocasionados pelos ruídos. Foi criado um disco rígido que possuía uma interface controladora integrada na placa de circuitos de controle do próprio disco, eliminando o cabo de comunicação entre o disco e a interface. Dessa forma, os ruídos foram eliminados, e esse tipo de tecnologia passou a ser chamado de IDE (Integrated Drive Electronics), já que a interface controladora estava integrada no próprio disco rígido. Também chamada de ATA (Advanced Technology Attachment).

Embora a tecnologia IDE demonstrasse melhorias, a tecnologia do motor de passo responsável pela movimentação das cabeças de leitura continuava imprecisa e lenta. Seria necessário um motor inteligente o suficiente para auxiliar no sistema de localização de dados no disco.Com o surgimento dos discos rígidos IDE, passou a ser utilizado um tipo de motor para as cabeças de leitura denominado voice coil. O desenvolvimento do atuador voice coil foi muito importante para o desenvolvimento de discos rígidos cada vez mais rápidos. Com o uso desse tipo de atuador, houve um grande ganho de desempenho, pois ele demora entre 10 e 40 ms entre uma trilha e outra, enquanto que em motores antigos, este tempo variava entre 65 e 100 ms.

Outra novidade foi que, para agilizar o processo de movimentação das cabeças de leitura,

acrescentou-se, entre um cilindro e outro do disco, um sinal analógico denominado servo, que orientava as cabeças de leitura a localizar um determinado cilindro no IDE. Nos discos antigos, quando uma cabeça de leitura estava no cilindro 0 e precisava movimentar-se até o cilindro 3, eram necessários 3 comandos, pois a cabeça de leitura pulava de cilindro em cilindro a cada comando, um passo por vez.



Já nos discos IDE, quando um cabeça de leitura está no cilindro 0 e precisa acessar um dado que está no cilindro 3, é necessária apenas uma instrução inteligente do tipo “acesse o cilindro 3”. Isso acontece porque o sinal de servo, que está localizado na face do disco, é responsável por localizar um dado e mandar o sinal para que o atuador acesse imediatamente o cilindro com o dado desejado.

6.4.2 - SCSI

O padrão SCSI foi criado nos anos 80 pela Apple Computer, para uso nos Macintosh. O nome SCSI significa Small Computer System Interface, sendo uma interface controladora de alta tecnologia, usada para conectar dispositivos como discos rígidos, scanners, unidade de CD/RW, unidades de fitas magnéticas e outros dispositivos sem a utilização de portas especiais. Esse padrão define as características físicas e elétricas de uma interface de entrada e saída projetada para se conectar e se comunicar com dispositivos periféricos. Ele foi pensado originalmente como uma porta de comunicação universal – é possível, em um conector SCSI, conectar indistintamente um disco rígido ou um scanner. A grande vantagem do SCSI é a sua velocidade de transferência de dados, superior à dos outros métodos de conexão de periféricos. O SCSI possui diversas vantagens sobre o IDE:

� Os discos rígidos SCSI são mais velozes e oferecem maior capacidade de armazenamento. � Possui capacidade de controlar 7,15 ou 30 dispositivos usando uma IRQ. (interrupção) � Os dispositivos SCSI externos possuem sua própria fonte de alimentação. � Os dispositivos SCSI permitem acessos simultâneos

Outro fato interessante é que cada um dos dispositivos SCSI interligados necessita de um número de unidade lógica, um identificador para distinguir os dispositivos. Para que estes dispositivos sejam conectados em conjunto em uma única porta SCSI, é necessário definir números entre 0 e 7, 15 ou 30, que devem ser configurados com um valor diferente para cada dispositivos do barramento. Entre os padrões mais conhecidos estão:

6.4.2.1 - SCSI 1

Esse foi o primeiro padrão SCSI, aprovado em 1986. Suporta taxas de transferência de baixo desempenho (5Mbit/s) e tem capacidade de conectar até 7 dispositivos SCSI em um barramento de 8 bits. Essa interface nada mais é do que uma interface ISA de 8 bits, com uma taxa de transferência de 5 Mbit/s. A comunicação SCSI com outros dispositivos é feita a 8 bits por um conector de 50 pinos. Em sua primeira versão, havia problemas quanto à comunicação entre periféricos SCSI, por causa da falta de padronização, ou seja, a incompatibilidade entre periféricos de fabricantes diferentes.

6.4.2.2 - SCSI 2

Quando foi aprovado, esse padrão trouxe novas taxas de transferência, consideradas “opcionais”. Para aumentar o desempenho, foram introduzidos dois novos padrões: Fast SCSI e Wire SCSI.



� Fast SCSI: permite que a taxa padrão de transferência dobre de 5 para 10 Mbits/s, usando a mesma comunicação de 8 bits e um conector SCSI padrão de 50 pinos. Ele também pode ser facilmente combinado com o Wire SCSI de 16 bits para dobrar seu desempenho;

� Wire SCSI: permite a transferência usando 16 ou 32 bits entre placas e periféricos SCSI – embora a

comunicação a 32 bits nunca tenha sido usada realmente. Com esse novo padrão, a taxa de transferência também passou de 5 para 10 Mbit/s. O Wire SCSI utiliza um conector de 68 pinos, diferentemente do conector de 50 pinos do SCSI padrão

6.4.2.3 - SCSI 3

Para padronizar os conectores SCSI, foi lançado o padrão SCSI 3, permitindo a comunicação de até 15 dispositivos por porta. Essa padronização utiliza uma forma de comunicação serial e se baseia no padrão IEEE 1394. Na verdade, o SCSI 3 utiliza quatro tipos diferentes de padrão: � SCSI Parallel Interface (SPI): padroniza as comunicações paralelas, conhecidas como Ultra SCSI; � P1394: utiliza um novo conceito de barramento, denominado FireWire, com a idéia principal de

futuramente substituir o padrão SCSI; � Serial Storage Architecture (SSA): criado pela IBM possui taxa de transferência de 20 Mbit/s. Por

utilizar quatro canais de comunicação, faz com que essa taxa chegue a 80 Mbit/s (denominado SSA 80). � Fiber Channel Arbitrated Loop (FC-AL): com taxa de até 100 Mbit/s, esse padrão utiliza, como meio de

comunicação, um cabo de fibra óptica de até 10 km, ou um cabo coaxial de até 24 metros de comprimento.

6.4.3 - Serial ATA

O padrão Serial ATA (ou simplesmente SATA) surgiu em 1997, a partir de um consórcio entre a Intel e mais de 70 empresas de computação. O nome não surgiu por acaso – o padrão deriva das tecnologias ATA usadas nos drives IDE, mas com comunicação serial em vez de paralela.

A idéia nasceu da previsão de que

as próximas arquiteturas de computadores – por motivos ecológicos, de desempenho e de custo – não serão compatíveis com os atuais padrões de comunicação e consumo de energia.

O Serial ATA, teoricamente,

permitiria transferência de dados de até 800 Mbit/s, muitos mais do que o necessário para qualquer disco rígido que venha a ser lançado nos próximos anos. Além disso, essa nova interface seria muito mais barata que as interfaces SCSI e IDE.

As verdadeiras razões para o

desenvolvimento do padrão serial ATA podem ser resumidas em dois pontos:



� A necessidade de criar um padrão que acompanhasse a evolução do computador, para que o disco rígido deixasse de ser um limitador, um gargalo.

� A produção do disco rígido Serial ATA, segundo seu fabricante, é mais barata, possibilitando um

maior lucro e fazendo com que no futuro, os preços desses discos rígidos possam ser menores do que os discos IDE.

O Serial ATA, como o próprio nome diz, traz novamente à tona a tecnologia de

transferência serial. O estranho é que conexões baseadas nesta tecnologia, como as portas seriais comuns, normalmente são lentas em comparação com as interfaces paralelas. Entretanto, como a interferência entre vias (crosstalk) aumenta à medida que a velocidade sobre, a partir de certo limite as interfaces seriais são a única alternativa. Depois do lançamento do USB (Universal Serial Bus), a nova tecnologia serial começou a ganhar força, mostrando que a estrutura era eficiente – só não estava sendo utilizada como deveria.

6.5 - Memória Óptica

O lançamento do CD (Compact Disc) causou uma revolução na indústria do entretenimento e da computação. Finalmente seria possível o armazenamento de uma enorme quantidade de dados e músicas em um tipo de mídia confiável e de baixo custo. Com o passar do tempo, o CD foi se tornando obsoleto por causa da necessidade crescente de espaço de armazenamento. Os cerca de 74 minutos de áudio, equivalentes a 650 MB de dados, que antes pareciam algo gigantesco, tornaram-se insuficientes.

O DVD (Digital Versatile Disc) ficou em fase de desenvolvimento por um longo tempo.

Projetado para conter áudio e vídeo de alta resolução digital, o DVD pode ser visto como um CD-ROM que armazena pelo menos 4,7 GB de informação, o que resulta em várias horas de música ou quase três horas de vídeo de alta qualidade.

O surgimento de gravadores, tanto para CD como para DVD, foi outra revolução

tecnológica, permitindo ao usuário fazer sua própria seleção de músicas, dados e programas.

6.5.1 - CD

Tudo começou por volta de 1978, quando duas empresas, a Sony e a Philips se uniram para produzir o CD. A Sony fazia pesquisas em gravação digital havia uma década e aPhilips já havia desenvolvido reprodutores de discos a laser comerciais. Ambas acabaram chegando a um acordo para a formulação de uma única tecnologia de áudio.

No ano de 1982, elas anunciaram o seu padrão de CD, com 5 ¼ polegadas (12 centímetros)

de diâmetro. Esse tamanho foi escolhido por ser capaz de armazenar a Nona Sinfonia de Beethoven – cerca de 70 minutos de música.

Ao longo dos anos 80, com a cooperação entre a Sony e a Philips, foram anunciadas

especificações na tecnologia dos CDs para dados computacionais. Isso levou ao surgimento dos drives de CD-ROM. Enquanto os engenheiros estavam preocupados em conseguir fazer com que o CD pudesse suportar uma maior capacidade de armazenamento, os fabricantes de software estavam abarrotando esses discos com dados e programas. Até então, era possível armazenar apenas 1.44 MB em disquetes; de repente, o usuário passou a ter acesso a mais de 640 MB de informação. Foi uma febre, alavancando o surgimento de programas, games, músicas e vídeos.



Antigamente, quando existia apenas o CD de áudio, o desempenho não era considerado tão importante. Um aparelho de som costuma trabalhar a uma taxa de transferência de 172,27 Kb/s aproximadamente. Mas para o CD-ROM, a unidade de leitura acabou mostrando-se muito lenta. O surgimento de novas aplicações multimídia trouxe a necessidade de elevar essa taxa. Geralmente, a taxa de transferência é informada pelo fabricante, estampada na frente da unidade leitora.

Os gravadores de CD foram inventados em 1984, mas só se tornaram acessíveis à população

em geral por volta de 1990. Além de caros, os gravadores eram complicados de usar, necessitavam de placas especiais e computadores isolados de qualquer tipo de vibração para gravarem corretamente. A gravação de um CD demorava mais de uma hora, e o sucesso não era garantido. Atualmente esse processo é bem mais barato, fácil e rápido.

6.5.2 - DVD

O DVD pode ser visto como uma nova e fantástica tecnologia, pela qual o setor de home vídeo esperava desde o surgimento do VHS, no final dos anos 70. Projetado para conter áudio e vídeo de alta resolução, ele é verdadeiramente digital, além de oferecer uma série de recursos extras. O DVD pode ser visto como um CD-ROM que armazena no mínimo 4.7 GB de informações – o suficiente para um filme de longa metragem normal. Uma das vantagens do DVD é sua compatibilidade com o CD-ROM. Isso significa que um leitor de DVD lê CD comuns (musicais ou de dados).

A capacidade de armazenamento deve-se à variedade de tipos de estrutura para DVDs. Há

cinco formatos diferentes, variando conforme a quantidade de lados que podem ser gravados e a quantidade de camadas presentes. Assim, um disco de duas camadas e dupla face pode atingir algo em torno de 17 GB de capacidade. Um DVD é muito semelhante ao CD; além de ambos possuírem o mesmo diâmetro, também usam os mesmos materiais. Um DVD possui 1,2 milímetros de espessura, e é composto por diversas camadas de plástico. Cada uma delas é criada pela injeção de plástico de policarbonato em moldes. Forma-se assim, um disco com minúsculos degraus, reunidos em uma longa trilha espiral de dados.

Exercícios 01 – O disco magnético é constituído de um prato circular de metal ou plástico. Ele é organizado em regiões formadas por anéis concêntricos, denominados trilhas. O número de trilhas por superfície do disco varia de: a) 8000 a 10000 b) 500 a 2000 c) 12000 a 15000 d) 35 a 438 e) 20000 a 30000 f) Nenhuma das alternativas anteriores 02 - Em que consiste a geometria de um disco rígido? 03 – Explique o que é a latência rotacional de um disco rígido. 04 – O padrão RAID utiliza os conceitos de espelhamento e stripping. Em que consistem estas técnicas? 05 – Por que a criação dos CD´s e DVD´s revolucionou a indústria do entretenimento?



06 – Considere as afirmativas sobre o padrão RAID:

I. O RAID consiste em um agrupamento de unidades de discos lógicos e virtuais II. Os dados são distribuídos pelas unidades de discos físicos do agrupamento

III. A capacidade de armazenamento redundante é utilizada para armazenar informação de paridade Estão corretas: a) I e II b) I e III c) II e III d) Somente a I e) Todas estão corretas f) Nenhuma está correta 07 – O padrão que consiste de uma interface controladora de alta tecnologia e que foi criado para conectar discos rígidos e outros dispositivos sem a utilização de portas especiais denomina-se: a) RAID b) ATA c) SATA d) SCSI e) IDE f) Nenhuma das alternativas anteriores



7- Execução de Programas

7.1 - Introdução

Conforme já foi mencionado nos capítulos anteriores, um computador, para realizar uma tarefa específica, precisa ser instruído, passo a passo, para efetivamente realizar a tarefa. Necessita que seja projetado com a capacidade de realizar (interpretar e executar) um determinado conjunto de operações, cada uma sendo constituída de uma instrução específica (instrução de máquina).

Atualmente, é raro escrever-se um programa diretamente na linguagem da máquina em

virtude da enorme dificuldade de se organizar as instruções sem erros e dos problemas de entendimento e manutenção do programa tanto por parte de outros programadores como até mesmo por quem criou o referido programa.

Vamos apresentar um resumo das etapas que definem o processo de execução de um

programa escrito em uma linguagem qualquer, de nível acima da linguagem de máquina, descrevendo cada uma dessas etapas. Ao final, apresentam-se alguns exemplos de programas feito em linguagem de montagem Assembly.

7.2 - Linguagens de Programação

Uma linguagem de programação é uma linguagem criada para instruir um computador a realizar suas tarefas. Um programa completo, escrito em uma linguagem de programação, é frequentemente denominado código. Deste modo, codificar um algoritmo significa converter suas declarações em um comando ou instrução específica de certa linguagem de programação.

O tipo mais primitivo de linguagem de programação é a linguagem que o computador

entende diretamente, ou seja, as instruções que podem ser diretamente executadas pelo hardware. É a chamada linguagem de máquina, que foi utilizada pela primeira geração de programadores.

Uma instrução de máquina é um conjunto de bits, dividido em subconjuntos ou campos, com

funções determinadas: um subconjunto estabelece o código de operação e o outro define a localização dos dados. Um programa em linguagem de máquina é, em consequência, uma longa sequência de algarismos binários, alguns dos quais representam instruções e outros os dados a serem manipulados pelas instruções.

0010 0100 1001 0001 0100 0100 1001 1111 0100 0100 1001 0011 1111 0100 1001 1010 0000 0000 0000 0000 Para criar um programa em linguagem de máquina, o programador deve conhecer todas as

instruções disponíveis para àquela máquina e seus respectivos códigos de operação e formatos, assim como os registradores disponíveis e os endereços das células de memória onde serão armazenadas as instruções e os dados. Um programa real, em linguagem de máquina, pode conter milhares de instruções, o que é uma tarefa extremamente tediosa e difícil, pelos detalhes que precisam ser observados pelo programador.



Para tentar minimizar esta dificuldade de entendimento do significado dos números, foi desenvolvida, ainda para a primeira geração de computadores, uma linguagem que representasse as instruções por símbolos e não por números. Esta linguagem simbólica foi denominada Linguagem de Montagem (Assembly Language), popularmente conhecida como assembly.

Códigos de operação, como 0101, são mais fáceis de serem lembrados se representados

como ADD (somar) do que pelo número 0101. Além disso, o programador ao escrever um programa em linguagem de montagem, não precisa guardar os endereços reais de memória onde dados e instruções estarão armazenados. Ele pode usar símbolos como MATRICULA, NOME, SALARIO para indicar os dados que são usados em um programa. Uma instrução em linguagem de máquina do tipo

1110 0100 1001 1001

pode ser mais facilmente entendida se representada na forma simbólica: ADD SALARIO

Para se usar linguagem de montagem em um computador é necessário que haja um meio de converter os símbolos alfabéticos utilizados no programa em código de máquina, de modo a poder ser compreendido pela CPU. O processo de conversão é chamado de montagem e é realizado por um programa denominado montador. O montador lê cada instrução em linguagem de montagem e cria uma instrução equivalente em linguagem de máquina. Observe a seguir um exemplo de um programa em linguagem de montagem:

ORG ORIGEM LDA SALARIO-1 ADD SALARIO-2 ADD SALARIO-3 SUB ENCARGO STA TOTAL HLT DAD SALARIO-1 DAD SALARIO-2 DAD SALARIO-3 Um passo mais significativo no sentido de criar uma linguagem de comunicação com o

computador, mais simples e com menos instruções do que a linguagem de montagem foi o desenvolvimento de linguagens que refletissem mais os procedimentos utilizados na solução de um problema, sem a preocupação com o tipo de CPU ou de memória onde o programa será executado. Tais linguagens por serem estruturadas de acordo com a compreensão e a intenção do programador, são usualmente denominadas linguagens de alto nível, nível afastado da máquina.

Uma linguagem de alto nível, ou orientada ao problema, permite que o programador

especifique a realização de ações do computador com muito menos instruções. Desde o aparecimento de linguagens como FORTRAN e ALGOL, na década de 50, dezenas de outras linguagens de alto nível foram desenvolvidas, seja para uso geral seja para resolver tipos mais específicos de problemas. A tabela a seguir apresenta algumas das mais conhecidas linguagens de programação de alto nível, indicando-se a época de seu surgimento no mercado.



Linguagem Data Observações FORTRAN 1957 FORmula TRANslation – primeira linguagem de alto

nível. Desenvolvida para a realização de cálculos numéricos

ALGOL 1958 ALGOrithm Language – linguagem desenvolvida para uso em pesquisa e desenvolvimento, possuindo uma estrutura algorítmica

COBOL 1959 Common Business Oriented Language – primeira linguagem desenvolvida para fins comerciais

LISP 1960 Linguagem par manipulação de símbolos e listas PL/I 1964 Linguagem desenvolvida com o propósito de servir para

emprego geral (comercial e científico). Fora de uso BASIC 1964 Desenvolvida em Universidade, tornou-se conhecida

quando do lançamento do IBM-PC, que veio com um interpretador da linguagem, escrito po Bill Gates e Paul Allen

PASCAL 1968 Primeira linguagem estruturada – designação em homenagem ao matemático francês Blaise Pascal

C 1967 Linguagem para programação de sistemas operacionais e compiladores

ADA 1980 Desenvolvida para o departamento de defesa dos EUA DELPHI 1994 Baseada na linguagem Object Pascal, uma versão do

Pascal orientada a objetos JAVA 1996 Desenvolvida pela Sun, sendo independente da

plataforma onde é executada. Muito usada para sistemas Web

7.3 - Montagem e Compilação

No item anterior verificamos que programas de computador não são escritos na linguagem que a máquina entende, mas sim em outras formas simbólicas de representar as instruções que o programador deseja que sejam realizadas. No entanto, verificamos que as máquinas continuam entendendo somente em binário e, por isso, sempre há a necessidade de conversão ou tradução de um programa em linguagem simbólica para outro equivalente, em linguagem numérica binária.

7.3.1 - Montagem

A tradução mais rápida e simples que existe denomina-se montagem e é realizada por um programa denominado montador (Assembler). Como o nome já explica, a montagem é realizada para traduzir um programa em linguagem de montagem para seu equivalente em linguagem binária executável. Basicamente, as funções de um montador são: � Substituir códigos de operação simbólicos por valores numéricos � Substituir nomes simbólicos de endereços por valores numéricos dos endereços � Reservar espaço de memória para o armazenamento das instruções e dados � Converter valores de constantes para código binário � Examinar a correção de cada instrução



Em um montador de dois passos, o programa é examinado, instrução por instrução, duas vezes. Na primeira vez, o montador verifica a correção da instrução, ou seja, se ela está corretamente escrita e se possui os campos definidos na estrutura da linguagem de montagem. Se encontrar incorreção, o montador registra, de modo a poder relacionar os erros no final da verificação, interrompendo o processo.

Se o código fonte da instrução estiver correto, ele inicia a descrição de uma tabela,

denominada tabela de símbolos, em que cada entrada corresponde a um símbolo. Em geral, temos uma tabela de símbolos de códigos de operação e uma tabela de símbolos de endereços.

No segundo passo, o montador realiza a criação do código objeto, completando todas as

entradas das tabelas. Para tanto, ele passa novamente por cada instrução e a localizará na tabela correspondente. Esta tarefa requer procedimentos otimizados de busca nas tabelas para que o processo de montagem seja rápido.

O montador de dois passos é o mais usado atualmente, visto que apesar de consumir certo

tempo devido ao fato de que o montador precisa examinar duas vezes todo o programa, ele produz um código de máquina direto no final da montagem, sendo, portanto conceitualmente mais simples. Por essa razão, ele permite que possam ser criados vários programas independentes, sendo todos finalmente interligados para constituir um único programa executável.

7.3.2 - Compilação

Quando se pretende converter para linguagem de máquina um programa escrito em linguagem de alto nível, então se usa um processo chamado compilação. Compilação é o processo de análise de um programa escrito em linguagem de alto nível, o programa-fonte e sua conversão em um programa equivalente, porém descrito em linguagem binária de máquina, denominado programa-objeto. O programa que realiza esta tarefa é denominado compilador.

A compilação é um processo semelhante ao de montagem, porém mais complexo e

demorado. Na montagem, há uma relação de 1:1 entre as instruções de linguagem de montagem e as instruções de máquina, enquanto na compilação isto não acontece, pois um único comando em Pascal, por exemplo, pode gerar várias instruções de máquina.

Durante a compilação, o código-fonte é analisado, comando por comando; o programa

compilador realiza várias tarefas, dependendo do tipo de comando que ele esteja analisando. Se, por exemplo, ele estiver analisando um comando que esteja declarando uma variável, ele criará a respectiva entrada em sua tabela de símbolos.

Inicialmente, o compilador realizará uma análise do código-fonte, dividido em três partes

distintas: � Análise léxica � Análise sintática � Análise semântica

Após esta tripla análise, é gerado um código intermediário e são construídas várias tabelas, como a tabela de símbolos, que auxiliará a realização da segunda fase, que é a fase de efetiva criação do código binário de máquina, o código objeto. Nesta segunda fase, o compilador aloca memória para as variáveis e realiza a atribuição dos registradores a serem utilizados, além da geração do código-objeto final.



A função de análise léxica do compilador consiste em decompor o programa-fonte em seus elementos individuais distintos (comandos, operadores, variáveis etc.), os quais são verificados de acordo com as regras da linguagem, gerando mensagem de erro se for encontrada alguma incorreção. Cada operador ou palavra-chave é identificado com um número pelo analisador léxico.

A função do analisador sintático de um compilador consiste basicamente na criação das

estruturas de cada comando, na verificação da correção dessas estruturas e na alimentação da tabela de símbolos com as informações geradas. Ele realiza esta tarefa a partir de cada elemento obtido na análise léxica, montando a estrutura apropriada (em geral, uma árvore) de acordo com as regras gramaticais da linguagem.

A análise semântica realizada pelo compilador verifica as regras semânticas estáticas da

linguagem, produzindo, da mesma forma que os demais analisadores, mensagens de erro para as incorreções ou inconsistências semânticas.

7.3.3 - Ligação ou Linkedição

Quando um programador escreve um programa, ele não se preocupa em codificar determinadas operações, porque o código binário necessário para realizar aquelas tarefas já existe armazenado no sistema. É preciso apenas que o código em questão seja localizado e buscado onde estiver e incorporado ao sistema. Assim, o código objeto gerado por um compilador não é imediatamente executável, visto que ainda há código binário a ser incluído no programa.

A maioria das aplicações de qualquer tamanho tem um número de módulos compilados ou

montados separadamente. Estes módulos podem ser gerados por linguagens de programação diferentes ou estar presentes nas bibliotecas da linguagem de programação ou do sistema operacional. Cada módulo deve prover a informação descrita anteriormente, para que possa ser ligado, carregado e executado.

Um editor de ligação ou ligador (linker) é um programa que combina módulos montados

separadamente (módulos objeto) em um único programa, que é chamado de módulo de carregamento. O ligador resolve todas as referências globais e externas e realoca endereços dos módulos separados. O módulo de carregamento pode então ser carregado na memória pelo carregador, que pode também modificar endereços se o programa for carregado em uma posição diferente da original usada pelo ligador.

Uma técnica relativamente nova chamada de bibliotecas ligadas dinamicamente (Dynamic

Link Libraries – DLLs), popularizada pela Microsoft no sistema operacional Windows, está presente em formas semelhantes em vários outros sistemas operacionais; adia a ligação de alguns componentes até que eles sejam usados durante a execução.

Para combinar módulos montados ou compilados separadamente em um único modo de

carregamento, o ligador precisa: � Resolver referências de endereços que são externos aos módulos que estão sendo ligados � Realocar cada módulo combinando-os como apropriado. Durante este processo de realocação, muitos

dos endereços de um módulo podem ser modificados para refletir sua nova localização � Especificar o símbolo inicial do módulo de carregamento � Detalhar as identidades e os conteúdos dos vários segmentos, se o modelo de memória inclui mais de um

segmento de memória



7.4 - Interpretação

Com o método de compilação/ligação/execução, para que um programa possa efetivamente ser executado é necessário que todos os comandos do código-fonte desse programa sejam previamente convertidos para código-objeto e este tenha tido todas as referências externas resolvidas (etapa de ligação). A compilação não compreende execução; ela é apenas uma fase de tradução, de conversão. Além disso, o método gera produtos bem distintos, como o código-objeto e, mais tarde, o código executável.

Em contrapartida, o método de interpretação se caracteriza por realizar as três fases

(compilação, ligação e execução), comando a comando, do programa-fonte. Não há, pois, um processo explícito de compilação e ligação. Na realidade, um programa-fonte é diretamente executado (interpretado) por outro programa (o interpretador) e produz o resultado. Não há produtos intermediários, como o código-objeto ou código executável como acontece com o método anterior.

Em resumo, pelo método de interpretação, cada comando do código-fonte é lido pelo

interpretador, é convertido em código executável e imediatamente executado, antes que o comando seguinte seja lido.

Há linguagens de programação cujas características estruturais são típicas de métodos de

compilação, possuindo apenas compiladores. São exemplos deste tipo: Cobol, Fortran, C e Pascal. Há outras que possuem apenas interpretadores. A linguagem Java é interpretativa.

7.4.1 - Compilação x Interpretação

Ambos os métodos possuem vantagens e desvantagens, oriundas do modo próprio de funcionamento de cada um. A principal vantagem da interpretação sobre a compilação é sua capacidade de identificar e indicar um erro no programa-fonte, seja na etapa de conversão da fonte para executável (estática), seja na execução do código binário (dinâmica), isto é, erro na lógica do algoritmo ou na inconsistência entre o valor do dado e o tipo de dado definido, por exemplo. Uma razoável desvantagem da interpretação é o consumo de memória.

No que se refere ao consumo de memória, verificamos que o método de compilação usa

memória apenas por períodos definidos de tempo. Ou seja, o compilador só permanece na memória durante a fase de compilação; ao terminar esta fase, o compilador cede espaço para o ligador e este, em seguida, cede espaço para o carregador executar o código binário.

Em compensação, o programa interpretador deve permanecer na memória durante toda a

execução do programa, porque cada comando necessita do interpretador. E estes são programas grandes, que ocupam uma área considerável de memória.

Outra desvantagem da interpretação sobre a compilação consiste na possibilidade de certas

partes do código de um programa-fonte (um loop, por exemplo) terem que ser interpretadas tantas vezes quantas definidas no loop, no método de compilação, isso sempre acontece uma única vez. Os interpretadores são, no entanto, bastante vantajosos quando se trata de desenvolvimento de programas e correção de erros nesta fase.

Quando se utiliza o método de compilação, a identificação de erros no programa se torna mais problemática à medida que o código executável entra em fase de execução. O programador terá de identificar que comando do código-fonte gerou o referido erro.



Por outro lado, quando se emprega o método de interpretação, é mais simples a relação entre o código-fonte e o executável, porque cada comando-fonte é imediatamente traduzido e executado. Assim, se ocorrer um erro, o responsável deve ser o comando que está sendo executado e, portanto, já está identificado. O interpretador pode informar o erro, indicando diretamente o comando, ou variável, causador da ocorrência, pelo seu nome simbólico e não por um endereço numérico de memória.

7.5 – Linguagem Assembly

Este item objetiva apresentar conceitos relativos à linguagem Assembly. É oportuno esclarecer um ponto de grande confusão por parte de pessoas leigas no assunto. O termo Assembly significa montagem, ou seja, linguagem de montagem, a qual é utilizada para programar um computador em baixo nível, sendo necessário montar o programa dentro do processador. Assembly não é uma linguagem de máquina (como muitos afirmam), mas é a linguagem de programação que está mais próxima disso.

A linguagem de máquina é a utilizada por um microprocessador para controlar as funções de

um computador digital. O microprocessador utilizado em um computador é um circuito que possui a capacidade de executar diversos tipos de funções distintas.

A linguagem de máquina só aceita e manipula informações numéricas expressas em notação

de códigos binários, os quais matematicamente representam os estados de tensão alta “1” ou tensão baixa “0” para os circuitos eletrônicos de um computador. Por questões de facilidade operacional, os números binários podem e devem ser representados no formato hexadecimal.

A programação de computadores digitais em linguagem de máquina foi muito utilizada,

principalmente durante a década de 1940, após o surgimento do primeiro computador eletrônico, o ENIAC. Entre o final da década de 1940 e início da década de 1950, foi desenvolvida a linguagem de programação Assembly com o objetivo de facilitar o trabalho de codificação de um programa de computador. Nessa ocasião os códigos numéricos (binários ou hexadecimais) da linguagem de máquina foram substituídos por um código alfabético que era muito mais fácil de ser utilizado.

A linguagem de programação de computadores Assembly possui uma estrutura sintática

particular. Ela é formada por um conjunto de instruções que, por meio de códigos mais legíveis, representam as instruções do código de máquina.

As instruções da linguagem Assembly são conhecidas pelo nome de mnemônicos. É muito

mais fácil olhar para um mnemônico e lembrar o que ele faz do que seu equivalente em código binário ou hexadecimal, legível apenas pelo microprocessador do computador.

A linguagem de programação de computadores Assembly tem ainda uma grande vantagem

sobre a linguagem de máquina, que é o fato de requerer menos atenção a detalhes que são exigidos para programar em linguagem de máquina. Desta forma, é uma linguagem de fácil alteração se comparada com a linguagem de máquina.

O termo Assembler significa o programa montador, ou seja, é o programa utilizado para

compilar um programa escrito em linguagem de montagem, tornando-o executável em um computador. Assembler é basicamente o ambiente de programação. É a ferramenta responsável por traduzir o programa-fonte escrito em linguagem Assembly para o programa objeto em código de máquina a ser interpretado por um processador. O programa Assembler é uma ferramenta que tem características semelhantes em alguns aspectos aos compiladores para uma determinada linguagem de alto nível.



7.5.1 - Registradores A linguagem de programação Assembly utiliza registradores para armazenar em memória os

valores que serão manipulados por um programa. Grosso modo, os registradores são semelhantes às variáveis encontradas nas linguagens de programação de computadores de alto nível para tratar a maior parte dos dados em memória.

O registrador está intimamente relacionado com a estrutura do microprocessador em uso.

Para cada tipo de processador existe uma forma peculiar de tratar este conceito. Será apresentada e considerada a estrutura de registradores para computadores digitais baseada no microprocessador 8086 da empresa Intel.

A estrutura é formada por 14 registradores, cada um com 16 bits, divididos em quatro

grupos funcionais denominados: registradores gerais (AX,BX,CX,DX), registradores de segmento (CS,DS,ES,SS), registradores de ponteiros (SI,DI,SP,BP,IP) e registradores de estado (F).

7.5.1.1 - Registradores Gerais

Os registradores gerais AX (Accumulator eXtend), BX (Base eXtend), CX (Counter eXtend) e DX (Data eXtend) têm 16 bits de dados, e cada registrador pode ser dividido em duas partes, cada uma com 8 bits.

Quando divididos, cada registrador é tratado com 8 bits mais significativos (alto) e 8 bits

menos significativos (baixo). Desta forma, o registrador de 8 bits AH (Accumulator High) e o registrador de 8 bits AL (Accumulator Low) são, respectivamente, divisões do registrador AX de 16 bits.

Para os demais registradores considera-se a mesma estrutura, BH-BL, CH-CL e DH-DL no

sentido de determinar registradores de 8 bits mais e menos significativos pertencentes respectivamente a cada um de seus registradores de 16 bits BX, CX e DX.

O registrador geral AX pode ser utilizado em operações aritméticas, acessos de portas de

entrada e saída, chamadas de interrupções, transferência de dados, entre outras possibilidades. O registrador geral BX pode ser utilizado como ponteiro para acessar a memória no sentido

de obter algum valor de retorno ou mesmo definir valores que serão usados para auxiliar operações aritméticas efetuadas com o registrador AX.

O registrador geral CX também é usado para receber alguns valores de interrupções, mas sua

principal finalidade é servir como contador de laços de repetição e operações de deslocamento. O registrador geral DX é usado em operações aritméticas (mais precisamente em operações

de multiplicação para armazenamento da parte de um produto de 32 bits e também em operações de divisão para o armazenamento do resto da divisão), acessos de portas de entrada e saída e também em algumas chamadas de interrupções.



7.5.1.2 - Registradores de Segmento

Os registradores de segmento CS (Code Segment), DS (Data Segment), ES (Extra data Segment) e SS (Stack Segment) têm 16 bits e são utilizados para acessar uma determinada área de memória denominada offset (segmento), ou seja, são utilizados para auxiliar o microprocessador a encontrar o caminho pela memória do computador. Observe que eles não podem ser divididos em registradores de 8 bits.

O registrador de segmento CS é utilizado para apontar para uma área de memória que

contém o segmento de código de programa que se encontra em execução. A mudança do valor existente nesse registrador de segmento pode resultar em travamento do computador.

O registrador de segmento DS é utilizado para apontar para uma área de memória que

estiver sendo utilizada no armazenamento dos dados do programa em execução. A mudança do valor existente nesse registrador de segmento pode ocasionar a obtenção de dados incorretos.

O registrador de segmento ES é utilizado para determinar um segmento extra de endereços

de dados (um novo segmento, ou seja, um segmento far pointer) distante da área em que se está operando. Normalmente utilizado quando há necessidade de acessar, por exemplo, a memória de vídeo.

O registrador de segmento SS é utilizado para identificar a área de memória que será usada

como pilha (stack), com o objetivo de armazenar dados temporários para a execução de um determinado programa. Esse registrador de segmento pode algumas vezes conter o mesmo valor encontrado no registrador de segmento DS. A mudança do valor existente nesse registrador de segmento pode trazer resultados imprevisíveis, normalmente relacionados aos dados.

7.5.1.3 - Registradores de Deslocamento

Os registradores de apontamento ou deslocamento, também denominados registradores de índice, estão associados ao acesso de uma determinada posição de memória previamente conhecida, com a utilização dos registradores de segmento.

Os registradores de ponteiro são cinco de 16 bits. Diferentemente dos registradores gerais,

eles não podem divididos em registradores de 8 bits. Dos cinco registradores de apontamento, quatro são manipuláveis, sendo SI (Source Index),

DI (Destination Index), SP (Stack Pointer) e BP (Base Pointer). O registrador de apontamento (deslocamento) IP (Instruction Pointer), conhecido como apontador da próxima instrução, possui o valor de deslocamento (offset) do código da próxima instrução a ser executada.

O registrador de apontamento IP é de uso interno do microprocessador e tem por finalidade

guardar o deslocamento (offset) da próxima instrução de um programa. O valor existente nesse registrador de apontamento só pode ser lido.

Os registradores de apontamento SI e DI são utilizados para manipular índices de uma

tabela, sendo o registrador de apontamento SI usado para a leitura de dados do tipo string de uma tabela e o registrador de apontamento DI usado para a escrita de dados do tipo string em uma tabela Em especial o registrador de apontamento DI também é utilizado na definição de endereçamento distante associado ao registrador de segmento ES.



Os registradores de apontamento SP e BP permitem o acesso à pilha de programa (memória para armazenamento de dados). A pilha possibilita armazenar dados em memória, sem utilizar registradores gerais. Uma pilha é um mecanismo que armazena dados de cima para baixo. Imagine uma pilha como uma matriz de uma dimensão (vetor). O registrador de apontamento BP armazena o endereço da base da pilha, enquanto o registrador de apontamento SP armazena o endereço do topo da pilha.

7.5.1.4 - Registrador de Estado

Os registradores de estado são considerados os mais importantes meios para a sinalização da efetivação de operações lógicas, aritméticas, manipulação de blocos e interrupções, pois indicam o estado de comportamento do microprocessador quando da execução de alguma instrução da linguagem de programação assembly.

O registrador de estados (Flags) tem 16 bits que agrupa um conjunto de flags de 1 bit, e cada

flag define ou sinaliza um estado de comportamento particular do computador. Se o valor de cada bit estiver sinalizado como 1, indica que o flag em questão está setado (acionado), caso esteja sinalizado com o valor 0, significa que o flag não está setado (desabilitado).

O flag está vinculado ao fato de uma ação ser ou não executada, ou seja, o tipo booleano. Se

uma determinada ação é executada, o flag (bandeira) é levantado, indicando que a ação ocorreu (valor 1). Quando a bandeira está abaixada, é sinal de que a ação em questão não sofreu nenhum tipo de alteração (valor 0) Os flags do registrador de estado são independentes, mas por questões de conveniência são agrupados no mesmo conjunto de registrador de estado.

7.5.2 – Assembly 8086

A denominação da linguagem de programação de computadores Assembly para computadores IBM-PC é feita normalmente com algumas siglas de identificação, tais como ASM86, x86, ASM8086, entre outras. Esta denominação refere-se ao uso da linguagem de programação Assembly para o processador Intel ou equivalentes de mercado, como por exemplos os processadores fabricados pela AMD.

Os demais lançamentos de processadores da família Intel, tais como do 80286, 80386, 80486

e também a série Pentium, possuem basicamente o mesmo conjunto de instruções existentes no padrão do processador 8086 e 8088, além de cada um possuir em sua evolução novas instruções e recursos. Os recursos desses outros processadores não serão abordados nesta disciplina, limitando-se às instruções básicas e características para os processadores 8086 e 8088.

A linguagem de programação de computadores Assembly 8086 tem 116 instruções

(mnemônicos) diferentes destinadas ao controle do microprocessador. Os demais processadores da família Intel possuem a cada série um número maior de novas instruções. Para quem está começando a estudar a linguagem Assembly, é aconselhável primeiro conhecer basicamente as instruções para o microprocessador 8086.

As instruções da linguagem Assembly estão divididas basicamente em seis grupos funcionais, a saber:

� Transferência de dados – instruções destinadas à movimentação de dados. Os dados podem ser

movimentados entre registradores, entre registradores e posições de memória e entre registradores e unidades de entrada e de saída.



� Aritméticas – instruções destinadas aos cálculos matemáticos básicos, como adição, subtração, multiplicação e divisão.

� Manipulação de bits – instruções que fazem o deslocamento de bits em um registrador ou posição de

memória. As funções de operações lógicas de conjunção, disjunção e negação são incluídas nesse grupo. � Manipulação de strings – elas fazem o controle (comparação, análise e movimentação) de grupos de

sequências de caracteres � Controle de programa – instruções que controlam a execução do código de programa. O controle pode

ser uma execução seqüencial, com laços (loopings) e com sub-rotinas ou subprogramas. As instruções podem manipular as interrupções de um programa em execução. A ação de interromper um programa durante sua execução pode ocorrer por vários motivos, como, por exemplo, aceitar uma entrada de dados via teclado. Para que o dado possa ser digitado, é necessário fazer uma interrupção no programa que após aceitar o dado continua sua execução.

� Controle do microprocessador – instruções que possibilitam o acesso dos registradores de controle do

microprocessador, com o objetivo de mudar seu estado de comportamento.

7.5.2.1 – Exemplos de Programas em Assembly

Seguem a seguir, alguns exemplos de programas em linguagem assembly. I – Programa que calcula a soma de dois números:

MOV AH, 01 ; programa operação de leitura INT 21 ; executa interrupção que solicita leitura SUB AL, 30 ; extrai o número lido MOV BL, AL ; salva o primeiro número lido INT 21 ; executa interrupção que solicita leitura SUB AL, 30 ; extrai o número lido ADD AL, BL ; soma os números MOV DL, AL ; copia para posterior exibição ADD DL, 30 ; converte para o caracter correspondente em hexadecimal MOV AH, 02 ; programa operação de escrita INT 21 ; executa interrupção de escrita INT 20 ; termina o programa



II – Programa que lê um valor numérico e caso esse valor seja menor ou igual a 5, soma-se a ele 10. Caso contrário, atribui-se a ele o valor 0. Ao final o número é escrito na tela.

MOV AH, 01 ; programa operação de leitura INT 21 ; executa interrupção que solicita leitura SUB AL, 30 ; extrai o número lido CMP AL, 5 ; compara o número com 5 JG zera ; caso seja maior que 5, zera o valor ADD AL, A ; soma ao número, o valor 10 JG final zera: MOV AL, 0 ; zera o valor final: ADD AL, 30 ; converte para o caracter correspondente em hexadecimal MOV AH, 02 ; programa operação de escrita MOV DL, AL ; copia para posterior exibição INT 21 ; executa interrupção de escrita INT 20 ; termina o programa

III – Programa que lê um caracter do teclado e o escreve 15 vezes na tela.

MOV AH, 01 ; programa operação de leitura INT 21 ; executa interrupção que solicita leitura MOV DL, AL ; copia para posterior exibição MOV AH, 02 ; programa operação de escrita MOV BL, F ; atribui 15 ao contador escreve: INT 21 ; executa interrupção de escrita SUB BL,1 ; decrementa o contador JNZ escreve ; retorna à escrita caso seja menor que 0 INT 20 ; termina o programa



8- Gramáticas 8.1 - Linguagens Formais

Podemos definir a Teoria das Linguagens Formais como o estudo de modelos matemáticos

que possibilitam a especificação e o reconhecimento de linguagens, suas classificações, estruturas, características, propriedades e relacionamentos.

Os primeiros estudos realizados em busca da definição de linguagens formais foram em

torno de linguagens naturais. Estes estudos não foram bem sucedidos, pois as linguagens naturais possuem propriedades que as tornam difíceis de serem representadas de maneira formal.

As linguagens naturais, normalmente são muito extensas, complexas, com sintaxe flexível,

além de não possuírem semântica bem determinada, sendo ricas em ambiguidade. Desta forma, o tratamento computacional para linguagens naturais não obteve êxito, e

resultados significativos somente foram alcançados na descrição de linguagens computacionais, principalmente nos processos de análise léxica e sintática dos compiladores. Isto se deve ao fato de as linguagens computacionais possuírem sintaxe muito mais simples e uma semântica bem definida. 8.2 - Linguagem

Como definição inicial, podemos dizer que uma linguagem é uma forma de comunicação. Sofisticando um pouco mais essa definição, uma linguagem pode ser descrita como um conjunto de símbolos e regras, combinados e compreendidos por uma comunidade. Por exemplo, a lingua portuguesa.

8.3 - Componentes de uma Linguagem � Símbolo – Entidade básica a qual não possui uma definição formal. Letras e dígitos são exemplos de

símbolos frequentemente utilizados. Ex : a b 9 0 L � Alfabeto – É um conjunto finito de símbolos. Portanto, um conjunto vazio também é considerado um

alfabeto. Ex : V = {a,b,c,d,e,...,x,y,z} � Cadeia (string ou palavra) - É uma sequência finita de símbolos do alfabeto, sem espaços em branco.

Por exemplo, para o alfabeto : V = {a,b} Seriam exemplos de cadeia para o alfabeto: a,b,ab,ba,aab,aaa ... O tamanho de uma cadeia x, ou seja, o número de símbolos que compõe uma cadeia, é denotado por | x |. x = abbbba <=> |x| = 6



Uma cadeia vazia possui tamanho 0, | x | = 0, sendo representada pelo símbolo ε. Se x e y são cadeias, então x.y representa a concatenação das duas cadeias formada pelos símbolos de x imediatamente seguidos pelos símbolos de y. x = abc y=def x.y = abcdef

� Sentença (frase) - é um conjunto finito de cadeias com um separador entre elas, normalmente um

espaço em branco. � Fechamento de um Alfabeto – é o conjunto de todas as cadeias possíveis que podem ser geradas a

partir do alfabeto. O fechamento reflexivo inclui todas as cadeias, inclusive a vazia. Já o fechamento transitivo ou positivo, inclui todas as cadeias com exceção da cadeia vazia.

8.4 - Representações de uma Linguagem

Uma linguagem L sobre um alfabeto V é um subconjunto de V:

L ⊆⊆⊆⊆ V

O estudo de linguagens está intimamente relacionado ao estudo das formas de representação dessas linguagens. O problema de representação de uma linguagem, por sua vez, está relacionado com o fato dela ser finita ou infinita.

Uma linguagem é dita finita, quando ela pode ser representada por enumeração, como por

exemplo a linguagem definida como sendo o conjunto dos inteiros positivos pares maiores que 0 e menores que 20, pode ser representado por: L = {2, 4, 6, 8, 10, 12, 14, 16, 18}.

Já numa linguagem infinita, existe a impossibilidade de usarmos enumeração.A linguagem

definida como sendo o conjunto dos inteiros pares poderia ser representada por V ={2, 4, 6, 8, 10,...} que apesar de intuitiva, não é finita e nem precisa.

Iremos considerar apenas as linguagens finitas. No que diz respeito a sua representação, as

linguagens classificam-se em reconhecedores e sistemas geradores. Reconhecedores são dispositivos formais que permitem verificar se uma determinada

sentença pertence ou não a uma linguagem. Esses dispositivos são chamados de autômatos. Já os sistemas geradores são dispositivos que possuem meios formais de gerar as sentenças

de uma linguagem. Os principais sistemas geradores são as gramáticas.

8.5 - Gramáticas

Sabemos que uma linguagem pode ser vista como um conjunto de cadeias (palavras) formado com os símbolos de um alfabeto. Assim, devemos nos preocupar em definir esse conjunto. Essa é a finalidade de uma gramática. Ela define uma estrutura sobre um alfabeto de forma a permitir que apenas determinadas combinações sejam válidas, ou seja, sejam consideradas sentenças, definindo assim a linguagem que ela representa.



De uma maneira informal, podemos dizer que uma gramática é um sistema gerador de linguagens, ou ainda, uma maneira finita de representar uma linguagem.

No contexto da teoria das linguagens formais, gramáticas devem ser entendidas como uma

espécie de dispositivo de natureza computacional que serve para gerar as palavras (cadeias) de uma linguagem. Como um dispositivo desta natureza, gramáticas tem uma definição formal importante, não somente para estabelecer de maneira precisa sua forma de uso, como também para caracterizar formalmente certas classes de linguagem que podem ser definidas gramaticalmente.

O que é importante perceber, é que gramáticas são como esquemas de programas para listar

palavras que pertençam a uma dada linguagem e por isso dizemos que uma gramática é um dispositivo de geração de linguagens.

Podemos dizer então que uma gramática é um mecanismo que nos permite definir

formalmente de uma maneira precisa e finita uma linguagem. Observe o exemplo a seguir, de uma gramática da lingua portuguesa :

<sentença> :: = <sujeito> <predicado> <sujeito> :: = <substantivo> | <artigo> <substantivo> | <artigo> <adjetivo> <substantivo> <predicado> :: = <verbo> <objeto> <substantivo> :: = João | Maria | cachorro | livro | pão <artigo> :: = o | a <adjetivo> :: = pequeno | bom | bela <verbo> :: = morde | le | olha <objeto> :: = <substantivo> | <artigo> <substantivo> | <artigo> <adjetivo> <substantivo>

Você seria capaz de escrever todas as frases ou sentenças geradas por essa gramática?

Uma gramática G é um mecanismo para gerar sentenças, formalmente definida por: G = (Vn, Vt, P, S) onde :

Vn – É um conjunto finito de símbolos denominados não-terminais. São os símbolos utilizados na descrição da linguagem.

Vt – É um conjunto finito de símbolos denominados terminais. São os símbolos da linguagem

propriamente ditos, ou seja, os símbolos que podem ser usados na formação das sentenças da linguagem. Note que :

Vn ∩ Vt = ϕ e Vn ∪ Vt = V

P – É um conjunto finito de pares (α , β) denominado produções (ou regras gramaticais ou regras de sintaxe). Uma produção é representada por αααα :: = ββββ, e significa que αααα é definido por ββββ, ou ainda que αααα produz ββββ ou equivalentemente que ββββ é gerado a partir de αααα.

S – É o símbolo inicial da gramática; deve pertencer a Vn. O símbolo inicial de uma gramática

é o não-terminal a partir do qual as sentenças de uma linguagem serão geradas.

Utilizando o exemplo descrito anteriormente, teriamos:



Gportugues = (Vn, Vt, P, S) Vn = { <sentença> , <sujeito> , <predicado> , <substantivo> , <artigo> , <adjetivo> , <verbo> , <objeto> } Vt = { joão, maria , cachorro, livro , pão, o , a , pequeno, bom , bela , morde , le , olha } P = é o conjunto das regras gramaticais apresentado S = <sentença>

8.6 - Derivação e Redução

São operações de substituição que formalizam a utilização de gramáticas. Derivação é a operação que consiste em substituir uma sentença (ou parte dela) por outra, de

acordo com as produções das gramáticas em questão, no sentido símbolo inicial → sentença; Redução é a operação que consiste na substituição de uma sentença (ou parte dela) por

outro, de acordo com as produções da gramática, no sentido sentença → símbolo inicial. Derivação é a operação adequada para geração de sentenças; enquanto que a operação de

redução é adequada ao reconhecimento de sentenças. 8.7 - Backus Naur Form

A forma normal de Backus ou notação BNF é bastante utilizada na definição de linguagens

de programação, sendo introduzida na década de 60 na descrição do ALGOL. Consiste de uma metalinguagem capaz de descrever produções gramaticais recursivamente, onde cada produção possui uma regra de substituição, que permite a associação de uma ou mais cadeias a outra cadeia de símbolos.

Como convenção notacional, pode-se admitir que símbolos não-terminais (N) serão sempre

representados por letras maiúsculas, e símbolos terminais (T) por letras minúsculas. Dígitos serão sempre considerados simbolos terminais da gramática.

Por convenção, o símbolo inicial S será sempre o símbolo não-terminal que aparecer do lado

esquerdo da 1a produção da gramática. Assim basta listar as regras de produção para se obter a gramática, como por exemplo: S::=AB A::= a | aA B::= b | ε

Que tipo (s) de sentença (s) é gerada pela gramática acima?



Exercícios 01 – Defina as regras de produção que gerem as sentenças solicitadas abaixo: a) Qualquer número inteiro maior ou igual a zero b) Palavras do alfabeto V= {a,b,c,d,e} que tenham tamanho par c) Qualquer número binário que possa ser representado por um byte d) Números impares entre 100 e 999 e) Palavras do alfabeto V = {a,e,i,o,u} que comecem com a e terminem com o f) Sequências na forma an bn, com n ≥ 0 g) Qualquer número hexadecimal que seja ≤ 255 decimal h) Palavras do alfabeto V = {k,x,w,y,z} que comecem e terminem com a mesma letra i) Palavras do alfabeto V = {a,b,c} que sejam palíndromes j) Sequências no formato 0n 1m, onde n > 0 e m=2n k) Palavras do alfabeto V = {0,1,2,3,4,a,b,c,d,e,f} intercalando sempre uma letra e um dígito l) Qualquer número inteiro positivo que intercale dígitos pares com dígitos impares. m) Palavras do alfabeto V = {a,b} que tenham tamanho ímpar e comecem e terminem com letras diferentes n) Sequências de 0´s e 1´s que comecem com 0 e terminem com 1 e tenham tamanho par o) Palavras do alfabeto V = {a,b,c,0,1} que comecem com uma letra e terminem com um número p) Palavras do alfabeto V = {a,e,i,o,u } que contenham apenas dois a´s q) Sequências da forma 0n1m, onde n é par e m é impar r) Sequências (abc)n, onde n é impar s) Sequências do tipo axbycz onde y=1 e z=x, sendo que x > 0 t) Palavras do alfabeto V = {a,e,i,o,u,0,1} cujo ultimo caracter seja um número

8.8 - Linguagens Definidas por Gramáticas

Consiste no conjunto de sentenças de terminais que esta gramática pode gerar. Uma cadeia ou palavra pertence a uma linguagem L(G) se e somente se ela consiste somente de símbolos terminais, inclusive a sentença vazia ( ε ), podendo ser produzida a partir de S. Logo, L é o conjunto de todas as cadeias terminais geradas a partir do símbolo inicial.

8.9 - Gramáticas Equivalentes

Duas gramáticas G1 e G2 são equivalentes entre si, se e somente se L(G1) = L(G2). Para mostrar a equivalência entre duas gramáticas, basta apenas mostrar que de forma diferente, ambas geram exatamente as mesmas cadeias. Por exemplo: Gramática G1

S::= aHa | bHb H::= aH | bH | ε

Note que as gramáticas são equivalentes e não iguais !!! Gramática G2

S::= aA | bB A::= aA | bA | a B::= aB | bB | b



8.10 - Tipos de Gramáticas

Até este ponto não foi imposta qualquer restrição sobre a gramática ou sobre as produções que denotam as leis de formação da linguagem que está sendo definida.

As gramáticas gerais têm limitações em relação à sua aplicabilidade no contexto do estudo

dos compiladores, devido às dificuldades que acarretam em seu tratamento, sendo que as linguagens de programação de interesse não exigem toda a generalidade que as gramáticas gerais definidas acima são capazes de oferecer.

Torna-se atraente o estudo de casos particulares, de aplicação mais restrita, porém suficiente

para resolver os problemas levantados ao se projetar compiladores para linguagens de interesse. Restringindo o tipo de produções que podem aparecer em uma gramática, é possível definir classes especiais de gramáticas, tal como proposto na hierarquia de Chomsky descrita a seguir:

� Gramática Tipo 0 (ou gramática sem restrições)

São aquelas às quais nenhuma limitação é imposta. Obviamente, todo o universo das linguagens que se pode definir através dos mecanismos generativos definidos pelas gramáticas corresponde exatamente ao conjunto das linguagens que esta classe de gramáticas é capaz de gerar. As regras de uma gramática do tipo 0 são da forma α → β , com α e β quaisquer. Ou seja, do lado esquerdo da produção pode haver uma seqüência de quaisquer símbolos, desde que, entre eles, haja um não-terminal. Do lado direito da produção pode haver qualquer seqüência de símbolos, inclusive a sentença vazia

� Gramática Tipo 1 (ou gramática sensível ao contexto – G.S.C.)

As gramáticas do tipo 1 possuem regras da forma α → β , em que se exige |α| ≤ |β|. É entretanto permitida uma regra que viola esta restrição : uma gramática do tipo 1 pode possuir a regra S → ε, se S não aparecer do lado direito de nenhuma regra e S for o símbolo inicial da gramática. Essa regra é válida também para as gramáticas seguintes.

S ::= aABC aA ::= aaa B ::= b C ::= ccc

� Gramática Tipo 2 ( ou Gramática Livre de Contexto – G.L.C. )

As gramáticas do tipo 2 são as gramáticas com regras da forma α → β , onde α é um símbolo não terminal único e β é uma sequência qualquer composta de terminais e não terminais. Ou seja, do lado esquerdo da produção deve sempre ocorrer um e apenas um não-terminal. � Gramática Tipo 3 ( ou Gramática Regular – G.R. )

As gramáticas do tipo 3 só podem ter regras dos três tipos descritos a seguir : A ::= aB - onde A e B são não terminais e a é um terminal A ::= a - onde A é um não terminal e a é um terminal A ::= ε - onde A é um não terminal



As gramáticas do tipo 3 são chamadas regulares pela simplicidade da estrutura de suas linguagens, garantida pelos rígidos formatos de suas regras. Note que o lado direito de uma produção é constituído por no máximo um símbolo não terminal (ou variável). Se essa variável existir, sempre antecede ou sucede qualquer símbolo terminal.

Observação: As linguagens representadas (geradas) por G.S.C., G.L.C. e G.R. são denominadas, respectivamente, Linguagens Sensíveis ao Contexto (L.S.C.) Linguagens Livres de Contexto (L.L.C.) e Linguagens Regulares (L.R.).

8.11 - Expressões Regulares

Toda linguagem regular pode se descrita por uma expressão simples, denominada expressão regular. Uma expressão regular é definida a partir de conjuntos básicos e operações de concatenação e união.

As expressões regulares são consideradas adequadas para a comunicação homem x homem

e, principalmente, para a comunicação homem x máquina. Gramáticas de tipo 3 são adequadas para representar algumas ``características locais'' de

linguagens de programação, tais como definição de formatos de constantes, identificadores e palavras da linguagem.

Em Pascal, um identificador é uma letra seguida por zero ou mais letras ou dígitos. Isso

poderia ser expresso, em uma gramática, da seguinte forma : IDENTIFICADOR ::= letra | letra COMPLEMENTO COMPLEMENTO ::= letra | digito | letra COMPLEMENTO | digito COMPLEMENTO A representação gramatical anterior, poderia ser escrita da seguinte forma como uma

expressão regular : letra ( letra | digito )*

Aqui, a barra vertical significa “ou”, os parênteses são usados para agrupar subexpressões, o

asteristico significa “zero ou mais instâncias” da expressão parentetizada e a justaposição de letra com o resto da expressão significam concatenação.

Uma expressão regular é constituída de expressões regulares mais simples usando-se um

conjunto de regras de definição. Cada expressão regular r denota uma linguagem L (r). As regras de definição especificam como L (r) é formada através da combinação, em várias formas, das linguagens denotadas pelas subexpressões de r.

Uma expressão regular r, sobre um conjunto de símbolos T, representa uma linguagem L (r),

a qual pode ser definida indutivamente a partir de expressões básicas, como segue : 1. ∅ representa a linguagem vazia (conjunto contendo zero palavras) 2. { ε } representa a linguagem cuja única palavra é a palavra vazia 3. { x | x ∈ T } representa a linguagem cuja única palavra é x



4. se r1 e r2 são expressões regulares definindo as linguagens L(r1) e L(r2), tem-se que :

• r1 | r2 é a linguagem cujas palavras constituem o conjunto L(r1) ∪ L(r2) • r1 r2 é a linguagem cujas palavras são formadas pela concatenação de uma palavra de L(r1) com

uma palavra de L(r2) nesta ordem • r1* representa o conjunto L*(r1), isto é, o conjunto de palavras que podem ser formadas

concatenando-se zero ou mais palavras de L(r1).

Exemplos de expressões regulares:

(0+1)* - palavras de 0s e 1s (0+1)*00(0+1)* - palavras de 0s e 1s com pelo menos 2 zeros consecutivos. a+b* - palavras com qualquer quantidade de a’s (no mínimo 1) seguido de qualquer quantidade de b’s , inclusive nenhum. ba* - todas as palavras que comecam com a letra b e contem um numero qualquer de a´s a*ba*ba* - todas as palavras que contem dois b´s e um numero qualquer de a´s

Note que: (a | b)* é diferente de (a + b)*, pois :

(a | b)* => {ε, ab,abab,ababab,ababababab,...} (a+b)* => {ε,a,b,ab,ba,abb,aaab,bbbbba,...}

Exercícios

1- Defina expressões regulares para: a) Números binários que comecem com 0 e terminem com 1 b) Palavras do alfabeto V = {a,e,i,o,u} que tenham sempre pelo menos uma letra i c) Sequências do tipo “abc” d) Números decimais ímpares e) Palavras do alfabeto V = {k,x,y,w,z} que comecem sempre com k



9- Autômatos Finitos 9.1 - Introdução

A análise léxica é considerada como a primeira etapa do processo de compilação. Nesta

etapa, o programa fonte é encarado como uma seqüência de caracteres que deverão ser agrupados e identificados como palavras reservadas da linguagem, constantes e identificadores. Os símbolos que deverão ser reconhecidos na análise léxica são representáveis por expressões regulares ou equivalentemente por gramáticas regulares.

Um reconhecedor para uma linguagem é um programa que toma como entrada uma cadeia x

e responde “sim” se x for uma sentença da linguagem e “não” em caso contrário. Compilamos expressões regulares num reconhecedor através da construção de um diagrama de transições generalizado chamado de autômato finito.

9.2 - Definição Formal

Um autômato finito M, é uma quíntupla, definida da seguinte forma:

M=(E,V,f,q0,F), onde :

E - é um conjunto finito não vazio de estados do autômato finito. V - é o alfabeto dos símbolos da linguagem f - é a função de transição de estados do autômato q0 - é denominado estado inicial do autômato finito F - é o conjunto de estados finais Exemplo:

M = ({q0, q1}, {0, 1}, f, q0, {q1}) f = (q0 ,0) ⇒ q0 (q0, 1) ⇒ q1 (q1, 1) ⇒ q1 (q1, 0) ⇒ q0

Para este autômato finito, reconhecem-se os seguintes elementos: � Estados do autômato: q0 e q1 � Símbolos do alfabeto de entrada: 0 e 1 � Estado final: q1 � Estado inicial: q0 � Linguagem reconhecida : cadeias de dígitos binários terminadas obrigatoriamente por um dígito 1.

A gramática correspondente para esse autômato seria:

S::= 0S | 1S | 1



A expressão regular para esse autômato seria:

(0 | 1)* 1

9.3 – Representação Gráfica de Autômatos Finitos

Um autômato finito pode ser representado através de um diagrama de transição de estados, que é um grafo, no qual os nodos representam os estados, e os arcos representam as transições entre estados. O estado inicial é indicado por uma seta, e os estados finais são distinguidos por circunferências concêntricas.

A seguir, é mostrada a representação do autômato descrito no item anterior.

9.4 - Tabela de Transição de Estados

Outra forma de representar um autômato, mais apropriada para fins de processamento automático, é através de tabelas de transição. Uma tabela de transição é uma matriz na qual as linhas representam os estados do autômato e as colunas os símbolos do alfabeto. Cada entrada na matriz indica qual o estado final de uma transição a partir do estado indicado na linha através do símbolo indicado na coluna.

0 1 → q0 q0 q1

* q1 q0 q1

A tabela de transição acima representa o autômato definido no item 4.2. Assim, linhas da

tabela de transição representam o estado corrente e as colunas, o símbolo corrente. O estado inicial é indicado por uma seta e os finais por asterístico. Uma entrada na tabela (cruzamento entre linha e coluna) pode ser vazia, indicando que não há transição possível, ou ter o próximo estado que é atingido pela transição corrente.

Autômatos finitos podem ser determinísticos, quando para cada combinação de estado de

entrada existe uma única transição aplicável, ou não-determinísticos em caso contrário. É possível mostrar que a cada autômato finito não-determinístico corresponde um autômato finito determinístico que aceita a mesma linguagem.

q0

0

1

q1

0

1



9.5 - Autômatos Finitos Determinísticos & Não Determinísticos

Autômato Finito Determinístico é aquele em que, dado um estado e uma transição, leva a um único estado, ou seja a função de transição mapeia para apenas um único estado. Além disso, um AFD, possui apenas um estado inicial.

a b → q0 q0 q1

* q1 q1 q0

Autômato Finito não Determinístico é aquele em que, dado um estado e uma transição, pode levar a mais de um estado, ou seja, a função de transição de um AFND mapeia para um conjunto de estado, formado por zero ou mais estados. Um AFND pode possuir mais de um estado inicial (sistema de múltiplas entradas).

a b → q0 q1 -

* q1 q0 q2 q2 - q1

Note que não existe nenhuma entrada na tabela para (q0,b) e (q2,a), ilustrando assim o não

determinismo.

q0

q1 b

a

b

a

q0

a

a

b

b

q1

q2



9.6 - Conversão para Autômato Finito Determinístico

Autômatos finitos não-determinísticos precisam lidar com situações de ambigüidade, como no caso de um estado a partir do qual parte mais de uma transição vazia. É possível eliminar essas ambigüidades através da construção de um autômato finito determinístico que é equivalente a um autômato finito não-determinístico.

O procedimento aqui apresentado é freqüentemente denominado de construção de

subconjuntos. Na descrição a seguir, o termo “estado original” refere-se a um estado do autômato não-determinístico, enquanto o termo “novo estado” refere-se a estados do autômato determinístico.

A base desse procedimento é criar novos estados que representem todas as possibilidades de

estados originais em um dado momento da análise da sentença em processo de reconhecimento. Para tal, define-se o conjunto ε∗ associado a um conjunto de estados de um autômato não determinístico. A ε∗ (lê-se épsilon-clausura) é o conjunto que inclui cada um dos estados indicados e todos os estados alcançáveis a partir dele através de transições por strings vazias. O resultado é um conjunto de estados que irá representar um novo estado no autômato determinístico.

O procedimento da construção de subconjuntos começa pela computação da ε∗ do conjunto que contém o estado inicial original. Neste caso, obtém-se um conjunto de estados que irá representar o novo estado inicial, pois o conjunto resultante inclui o estado inicial original.

Cada estado novo que é criado precisa ser posteriormente analisado. Para tanto, constrói-se uma lista de estados não-analisados que, inicialmente, contém apenas o novo estado inicial.

O procedimento prossegue com a análise dos novos estados ainda não analisados. Para cada novo estado s nessa lista, é preciso analisar o que acontece quando o próximo símbolo da sentença for um dos símbolos do alfabeto sob consideração na expressão regular. Por exemplo, se α1 é um dos símbolos que pode ocorrer na sentença, então analisa-se, para cada um dos estados originais em s, quais seriam os estados originais resultantes pela transição pelo símbolo α1 . A ε∗ desse conjunto de estados resultantes gera um novo estado t (que eventualmente já pode ser um estado novo já existente). O autômato finito determinístico irá conter a transição s → t.

A análise dos novos estados ainda não analisados deve prosseguir até que essa lista torne-se vazia. Quando isso ocorre, o procedimento está encerrado e o autômato finito determinístico está definido.

Seja o seguinte AFND:

a b b a,b

q2

q0 q1 q3 q2



Possuindo a seguinte tabela de transição de estados :

a b →→→→qo q0,q1 q0

q1 q2 q2 q3 * q3

Fazendo a transformação para um AFD, teríamos a seguinte tabela de transição :

a b →→→→qo q0,q1 q0

q0,q1 q0,q1 q0,q2 q0,q2 q0,q1 q0,q3 * q0,q3 q0,q1 q0

Onde: q0 - X q0q1 - Y q0q2 - W q0q3 - Z Logo:

a b →→→→X Y X

Y Y W W Y Z * Z Y X

a E que resultaria no seguinte AFD : a a b b a

b b

1.1.1.1.1.1.1.1.1 Y

W

Z



9.7 - Reconhecimento de Sentenças

Autômatos são sistemas formais capazes de aceitar todas as sentenças que pertencem a uma particular linguagem, rejeitando as demais. São chamados de reconhecedores.

Para uma sentença ser considerada reconhecida pelo autômato, ao chegar no final da mesma,

o autômato deverá encontrar-se em um estado final. Caso contrário, a sentença será rejeitada. Durante o processo de reconhecimento de sentenças é possível que ocorram configurações

para as quais se apresentem apenas uma, mais de uma ou eventualmente nenhuma possibilidade de movimentação.

No caso de apenas uma movimentação, diz-se que a transição efetuada é determinística,

dado que não existem outras opções de evolução para o autômato. Isso ocorre quando o autômato é determinístico.

No caso de mais de uma possibilidade de movimentação, ou mesmo nenhuma, todas elas são

válidas e legitímas, caracterizando uma operação não determinística do autômato. Diz-se então que o autômato é não determinístico. Um autômato não determinístico reconhece a cadeia de entrada, se pelo menos uma das alternativas conduzi-lo a alguma configuração final.

Por exemplo, para o primeiro autômato definido no item 4.5, vamos verificar a sentença

ababb : q0 ababb => a q0 babb => ab q1 abb => aba q1 bb => abab q0 b => ababb q1

Como ao terminar a sentença, o autômato encontra-se em um estado final, conclui-se que a mesma foi reconhecida pelo autômato.

Agora, vamos verificar a sentença abbaa :

q0 abbaa => a q0 bbaa => ab q1 baa => abb q0 aa => abba q0 a => abbaa q0

Como ao terminar a sentença, o autômato não encontra-se em um estado final, conclui-se que a mesma não foi reconhecida pelo autômato.

9.8 - Aplicações de Autômatos Finitos

Apesar da simplicidade desta ferramenta, existe uma grande variedade de softwares cuja especificação e/ou implementação pode ser bastante simplificada se realizada em termos de A.F., resultando em maior eficiência. Dentre as diversas aplicações que fazem uso de autômatos, podemos citar:

� Analisador Léxico: Os tokens (símbolos básicos) de uma linguagem de programação geralmente podem

ser especificados eficientemente através de E.R., as quais podem ser automaticamente convertidas para A.F.D. equivalentes, cuja implementação (o analisador léxico propriamente dito) é trivial.

� Editores de Texto: As operações de busca e substituição de cadeias de caracteres em um texto, podem

ser eficientemente realizadas de forma transparente ao usuário.



Além das aplicações acima (tidas como as principais) podemos também destacar o uso destas ferramentas nas seguintes áreas:

� Protocolos de comunicação � Projeto (modelagem) de sistemas operacionais � Problemas específico tais como: segurança de arquivos, desorientação em sistemas de hipertexto,

modelagem de redes neurais e compressão de dados.

Exercícios

1 – Represente graficamente e através da tabela de transição, os autômatos que reconheçam as sentenças das linguagens abaixo : a) Sequências que contenham b´s com tamanho ímpar b) Sequências de números binários que comecem com 0 e terminem com 1 c) Sequências ab, contendo um número impar de a´s e um número par de b´s d) Qualquer número decimal entre 0 e 999 e) Sequências do tipo xyz, com um número qualquer de x´s, um número impar de y´s e um número par de

z´s f) Placas de veículos g) Números de cep´s h) Palavras do alfabeto V={a,b,c,d,e} que tenham tamanho par i) Qualquer número binário que possa ser representado por um byte j) Palavras do alfabeto V={a,e,i,o,u} que comecem com a e terminem com o k) Sequências na forma (ab)n, com n > 0 l) Palavras do alfabeto V= {x,y,z} que comecem e terminem com a mesma letra m) Qualquer número inteiro positivo que intercale dígitos pares com dígitos impares. n) Sequências de 0´s e 1´s que comecem com 0 e terminem com 1 e tenham tamanho par o) Palavras do alfabeto V = {a,b,c,0,1} que comecem com uma letra e terminem com um número p) Palavras do alfabeto V = {a,e,i,o,u } que contenham apenas dois a´s q) Sequências da forma 0n1m, onde n é par e m é impar r) Sequências (abc)n, onde n é impar s) Palavras do alfabeto V = {a,e,i,o,u,0,1} cujo ultimo caracter seja um número 2 – Represente graficamente a seguinte tabela de transição:

a b → q0 q0 q2

q1 q0 q3 q2 q3 q0

* q3 q1 q3



3 – Transforme o AFND a seguir em um AFD : a,b a b a,b a,b

a b 4 – Verifique se as sentenças abaixo são reconhecidas por ele : a) abab b) bbaba c) bbbbb d) aaabbbb e) babab

qo

q1

q2

q3

a post i laar quite tura

Documents