Arquitetura e organização de computadores

Guia de Estudo

Arquitetura e

Organização de

Computadores

2º Período

Unidade 1 a 3

Guia de Estudo – ARQUITETURA E ORGANIZAÇÃO DE COMPUTADORES

1

SABE – Sistema Aberto de Educação

Av. Cel. José Alves, 256 - Vila Pinto Varginha - MG - 37010-540

Tele: (35) 3219-5204 - Fax - (35) 3219-5223

Instituição Credenciada pelo MEC – Portaria 4.385/05

Centro Universitário do Sul de Minas - UNIS/MG Unidade de Gestão da Educação a Distância – GEaD

Mantida pela

Fundação de Ensino e Pesquisa do Sul de Minas - FEPESMIG

Varginha/MG


2

004.165

G633g. GOMES, José Eduardo Silva.

Guia de Estudo - Arquitetura e Organização de Computadores - José Eduardo Silva Gomes. Varginha: GEaD-UNIS/MG, 2007.

103p.

1. Sistemas Digitais. 2. Microprocessadores. 3. Programação. 4. Informática I. Título


3

REITOR Prof. Ms. Stefano Barra Gazzola

GESTOR Prof. Ms. Tomás Dias Sant’ Ana

Supervisor Técnico Prof. Ms. Wanderson Gomes de Souza

Coord. do Núcleo de Recursos Tecnológicos Profª. Simone de Paula Teodoro Moreira

Coord. do Núcleo de Desenvolvimento Pedagógico Profª. Vera Lúcia Oliveira Pereira

Revisão ortográfica / gramatical Profª. Maria José Dias Lopes Grandchamp

Design/diagramação Prof. César dos Santos Pereira

Equipe de Tecnologia Educacional Profª. Débora Cristina Francisco Barbosa

Jacqueline Aparecida da Silva Prof. Lázaro Eduardo da Silva

Autor

JOSÉ EDUARDO SILVA GOMES

Técnico em Eletrônica (1984) pela ETEFMC, Santa Rita do Sapucaí – MG, Bacharel em Administração de Empresas (1992) pela FACECA, Varginha – MG, Bacharel em Ciência da Computação (2002) pelo UNIS, Varginha – MG, Pós-Graduação em Redes de Computadores (2003) pelo UNIS e mestrando em Engenharia Elétrica pela UNIFEI (Universidade Federal de Itajubá). Atua também como Supervisor Técnico do Departamento de Engenharia da EPTV Sul de Minas, emissora de televisão afiliada a Rede Globo e é professor das instituições UNIS e FACECA nos cursos de Sistemas de Informação, Ciência da Computação, Engenharia de Produção.


4

TABELA DE ÍCONES

REALIZE. Determina a existência de atividade a ser realizada. Este ícone indica que há um exercício, uma tarefa ou uma prática para ser realizada. Fique atento a ele.

PESQUISE. Indica a exigência de pesquisa a ser realizada na busca por mais informação.

PENSE. Indica que você deve refletir sobre o assunto abordado para responder a um questionamento.

CONCLUSÃO. Todas as conclusões, sejam de idéias, partes ou unidades do curso virão precedidas desse ícone.

IMPORTANTE. Aponta uma observação significativa. Pode ser encarado como um sinal de alerta que o orienta para prestar atenção à informação indicada.

HIPERLINK. Indica um link (ligação), seja ele para outra página do módulo impresso ou endereço de Internet.

EXEMPLO. Esse ícone será usado sempre que houver necessidade de exemplificar um caso, uma situação ou conceito que está sendo descrito ou estudado.

SUGESTÃO DE LEITURA. Indica textos de referência utilizados no curso e também faz sugestões para leitura complementar.

APLICAÇÃO PROFISSIONAL. Indica uma aplicação prática de uso profissional ligada ao que está sendo estudado.

CHECKLIST ou PROCEDIMENTO. Indica um conjunto de ações para fins de verificação de uma rotina ou um procedimento (passo a passo) para a realização de uma tarefa.

SAIBA MAIS. Apresenta informações adicionais sobre o tema abordado de forma a possibilitar a obtenção de novas informações ao que já foi referenciado.

REVENDO. Indica a necessidade de rever conceitos estudados anteriormente.


5

Índice de Figuras

Figura 1 – Ábaco. ..................................................................................................... 14

Figura 2 – Bastões de Napier. .................................................................................. 14

Figura 3 – Régua de Cálculo. ................................................................................... 14

Figura 4 – Calculadora de Pascal............................................................................. 15

Figura 6 – Z3, fabricado em 1941 por Konrad Zuse. ................................................ 15

Figura 7 – Mark I, construído em 1944 pela Universidade de Harvard e a IBM........ 15

Figura 8 – Relé e Válvulas........................................................................................ 16

Figura 9 – ENIAC...................................................................................................... 17

Figura 10 – IBM 650. ................................................................................................ 17

Figura 11 – DEC PDP-1............................................................................................ 18

Figura 12 – IBM 7094. .............................................................................................. 18

Figura 13 – IBM 360. ................................................................................................ 19

Figura 14 – DEC PDP-11.......................................................................................... 19

Figura 15 – Microprocessadores Intel 386 e 486/DX2.............................................. 19

Figura 16 – Altair 8800.............................................................................................. 20

Figura 17 – Apple II. ................................................................................................. 20

Figura 18 – IBM/XT................................................................................................... 20

Figura 19 – Osborne I. .............................................................................................. 20

Figura 20 – Processadores: Intel Core 2 Extreme e AMD Athlon 64 X2 Dual-Core. 21

Figura 21 – Modelo de von Neuman......................................................................... 22

Figura 22 – Modelo de von Neuman (Estrutura em Barramento). ............................ 22

Figura 23 – Componentes de um Computador......................................................... 23

Figura 24 – Unidade Central de Processamento (CPU). .......................................... 24

Figura 25 – Hierarquia de Memórias. ....................................................................... 27

Figura 26 – Dispositivos de Entrada. ........................................................................ 28

Figura 27 – Dispositivos de Saída. ........................................................................... 28

Figura 28 – Dispositivos de Entrada e Saída............................................................ 28

Figura 29 – Disco Magnético. ................................................................................... 50

Figura 30 – Memórias RAM e Cache........................................................................ 53

Figura 31 – Diagrama em Blocos do SAP-1. ............................................................ 57


6

Figura 32 – Diagrama em Blocos do SAP-2. ............................................................ 69

Figura 33 – Utilização de tempo e circuito em um computador básico..................... 88

Figura 34 – Modificação para uma estrutura com pipeline. ...................................... 89

Figura 35 – Movimento da instrução na pipeline. ..................................................... 90

Figura 36 – Movimento da instrução e temporização da pipeline. ............................ 90

Figura 37 – Fluxo da instrução por meio do circuito de pipeline. .............................. 91

Figura 38 – Aumento da velocidade de um processador de von Neumann.............. 97

Figura 39 – Símbolo para um elemento de processamento genérico....................... 98

Figura 40 – Máquina de instrução única, segmento de dados único (SISD). ........... 98

Figura 41 – Máquina de instrução única, segmento de dados múltiplo (SIMD). ....... 99

Figura 42 – Máquina de instrução múltipla, segmento de dados único (MISD). ..... 100

Figura 43 – Máquina de instrução múltipla, segmento de dados múltiplo (MIMD).. 101


7

Índice de Tabelas

Tabela 1 – Tabela de Medidas. ................................................................................ 29

Tabela 2 – Conversão de Base Numérica. ............................................................... 36

Tabela 3 – Porta NOT............................................................................................... 37

Tabela 4 – Porta OR................................................................................................. 38

Tabela 5 – Porta AND............................................................................................... 38

Tabela 6 – Porta NOR. ............................................................................................. 39

Tabela 7 – Porta NAND. ........................................................................................... 40

Tabela 8 – Porta XOR............................................................................................... 41

Tabela 9 – Porta XNOR. ........................................................................................... 42

Tabela 10 – Regras da Álgebra Booleana. ............................................................... 43

Tabela 11 – Conjunto de Instruções do SAP-1......................................................... 59

Tabela 12 – Códigos de Operação do SAP-1........................................................... 61

Tabela 13 – Conjunto de Instruções do SAP-2......................................................... 79

Tabela 14 – Ciclos de Clock / Utilização do Circuito................................................. 90


8

Sumário

Apresentação .......................................................................................................... 11

1. INTRODUÇÃO ..................................................................................................... 12

1.1. Conceitos Básicos ...................................................................................... 12

1.2. Arquitetura X Organização ......................................................................... 12

1.3. Evolução Histórica das Arquiteturas de Computadores ............................. 13

1.3.1. Geração Zero (1642 - 1945) – Mecânicos e eletromecânicos............. 14

1.3.2. As Máquinas de Primeira Geração (1945 - 1955) – Válvulas .................. 16

1.3.3. As Máquinas de Segunda Geração (1955 - 1965) – Transistores.......... 17

1.3.4. As Máquinas de Terceira Geração (1965 - 1980) – Circuitos Integrados 18

1.3.5. As Máquinas de Quarta Geração (1980 - 1990) – Circuitos LSI.............. 19

1.3.6. As Máquinas de Quinta Geração (1990 - dias atuais) – Circuitos ULSI .. 20

1.3.7. O modelo de von Neumann..................................................................... 22

1.4. Principais Componentes de um Computador................................................ 23

1.4.1. A Unidade Central de Processamento (CPU) ..................................... 23

1.4.2. Barramentos........................................................................................ 25

1.4.3. Clock ................................................................................................... 25

1.4.4. Memória Principal................................................................................ 26

1.4.5. Memória Cache ................................................................................... 26

1.4.6. Memória Secundária ........................................................................... 27

1.4.7. Dispositivos de Entrada e Saída (E/S ou I/O)...................................... 27

2. SISTEMAS DIGITAIS........................................................................................... 29

2.1. O Bit, a Palavra, o Caractere, o Nibble e o Byte......................................... 29

2.2. Sistemas Numéricos................................................................................... 30

2.2.1. Sistema Decimal ................................................................................. 30

2.2.2. Sistema Binário ................................................................................... 31

2.2.2.1. Conversão de Binário em Decimal.................................................... 31

2.2.2.2. Conversão de Decimal em Binário.................................................... 32

Exercícios: Converta os valores para as bases indicadas. ............................ 33

2.2.3. Sistema Octal ...................................................................................... 33


9

2.2.3.1. Conversão de Binário em Octal ........................................................ 33

2.2.3.2. Conversão de Octal em Binário ........................................................ 33

2.2.3.3. Conversão de Octal em Decimal....................................................... 34

2.2.3.4. Conversão de Decimal em Octal....................................................... 34

2.2.4. Sistema Hexadecinal........................................................................... 34

2.2.4.1. Conversão de Hexa em Binário ........................................................ 35

2.2.4.2. Conversão de Binário em Hexa ........................................................ 35

2.2.4.3. Conversão de Hexa nos demais sistemas e vice-versa.................... 35

2.3. Portas Lógicas............................................................................................ 36

2.3.1. Portas NOT (Inversoras) ..................................................................... 37

2.3.2. Portas OU (OR, + , ∨).......................................................................... 37

2.3.3. Portas E (AND, . , ∧)............................................................................ 38

2.3.4. Portas NÃO OU (NOR)........................................................................ 39

2.3.5. Portas NÃO E (NAND) ........................................................................ 39

2.3.6. Portas OU Exclusiva – XOU (XOR, ⊕) ................................................ 40

2.3.7. Portas NÃO OU Exclusiva – XNOU (XNOR, �).................................. 41

2.4. Álgebra Booleana e Mapa de Karnaugh..................................................... 42

2.4.1. Álgebra Booleana................................................................................ 42

2.4.1.1. Expressões Lógicas – Aplicações das Portas................................... 43

2.4.1.2. Simplificação de Expressões Lógicas ............................................... 44

2.4.2. Mapas de Karnaugh ............................................................................ 45

2.4.2.1. Regras para Minimização (Simplificação) ......................................... 46

2.5. Memórias.................................................................................................... 49

2.5.1. Memória de Massa.............................................................................. 50

2.5.2. Memória Semicondutora ..................................................................... 51

2.5.2.1. Memória ROM................................................................................... 51

2.5.2.2. Memória RAM .................................................................................. 52

3. MICROPROCESSADORES ................................................................................. 55

3.1. O Microprocessador SAP-1........................................................................ 55

3.1.1. Definição dos Blocos do SAP-1........................................................... 55

3.1.2. Diagrama em Blocos .............................................................................. 57

3.1.3. Conjunto de Instruções do SAP-1 ....................................................... 57

3.1.4. Programação do SAP-1 ...................................................................... 61

3.1.5. Análise do Diagrama Temporal (Fasorial) ........................................... 62


10

3.2. O Microprocessador SAP-2........................................................................ 67

3.2.1. Definição dos Blocos do SAP-2............................................................. 67

3.2.2. Diagrama em Blocos .............................................................................. 69

3.2.3. Instruções do SAP-2................................................................................ 70

3.2.3.1. Instruções com Referência à Memória............................................. 70

3.2.3.2. Instruções de Registradores ............................................................ 70

3.2.3.3. Instruções de JUMPS (Saltos) ......................................................... 72

3.2.3.4. Instruções Lógicas ........................................................................... 75

3.2.3.5. Outras Instruções............................................................................. 76

3.2.4. Conjunto de Instruções do SAP-2............................................................ 78

3.3. A Linguagem Assembly.............................................................................. 85

3.3.1. Linguagem de Máquina....................................................................... 85

3.3.2. Linguagem Assembly .......................................................................... 85

3.3.3. Linguagem de Alto Nível ..................................................................... 86

3.3.4. Vantagens e Desvantagens da Linguagem Assembly ........................ 86

3.3.5. Aplicações da Linguagem Assembly................................................... 86

3.3.6. Programa Debug ................................................................................. 87

3.4. A Técnica do Pipeline................................................................................. 87

3.5. Arquiteturas CISC e RISC .......................................................................... 94

3.5.1. Máquinas CISC ................................................................................... 94

3.5.2. Máquinas RISC ................................................................................... 95

3.5.3. Computadores Modernos.................................................................... 96

3.6. Conceitos Básicos em Processamento Paralelo ........................................ 96

3.6.1. Classificação de Máquinas Paralelas.................................................. 98

3.6.1.1. SIMD ................................................................................................ 99

3.6.1.2. MISD .............................................................................................. 100

3.6.1.3. MIMD.............................................................................................. 100

REFERÊNCIAS ...................................................................................................... 102


11

Apresentação

Tenha em mente que tudo que você aprende na escola é trabalho de muitas gerações. Receba essa herança, honre-a, acrescente a ela e, um dia, fielmente, deposite-a nas mãos de seus filhos.

Albert Einstein

Prezado(a) aluno(a): Este é o seu Guia de Estudos da disciplina de Arquitetura e Organização de Computadores, ministrada para o curso de Bacharelado em Sistemas de Informação pelo Centro Universitário do Sul de Minas – UNIS-MG. Ele será utilizado no desenvolvimento da disciplina, apresentando os conteúdos e demais informações para que você realize as atividades programadas. O estudo de Arquitetura e Organização de Computadores apresenta a estrutura interna de um microprocessador e as várias técnicas utilizadas na sua construção. Este conhecimento irá ajudá-lo a entender melhor o funcionamento de um sistema operacional, e você terá uma idéia de como as instruções são, fisicamente, executadas na implementação de programas computacionais, apesar da abstração do hardware que as modernas linguagens de programação proporcionam. Porém, antes de estudarmos o funcionamento dos microprocessadores, veremos os conceitos básicos de sistemas digitais. O estudo de sistemas digitais exige o domínio de outros sistemas de numeração além do decimal, que usamos no nosso cotidiano. Assim inicialmente estudaremos os sistemas binário, octal e hexadecimal. Então iremos projetar sistemas digitais, usando dispositivos lógicos, metodologias e técnicas empregadas no desenvolvimento de circuitos digitais que podem ser usadas em outras situações como, por exemplo, em programação. Darei uma especial atenção à fixação destes conceitos uma vez que, se não forem bem assimilados, poderão comprometer o seu desempenho no decorrer da disciplina. Trata-se de uma disciplina básica, diretamente inserida no escopo do curso. O conhecimento da Arquitetura e Organização de Computadores será empregado em diversas áreas de estudo do curso como: Linguagens e Técnicas de Programação, Sistemas Operacionais, Estrutura de Dados, Redes de Computadores, etc. A minha expectativa é mostrar a relação entre hardware e software focalizando conceitos que são a base dos atuais computadores e apresentar os paradigmas organizacionais que determinam a capacidade e o desempenho de sistemas de computação. Acredito que o curso de Sistemas de Informação esteja sendo um período de desenvolvimento intelectual e de crescimento pessoal e desejo que esta disciplina contribua para o seu sucesso profissional, portanto, mãos à obra. José Eduardo Silva Gomes Professor de Arquitetura e Organização de Computadores


12

1. INTRODUÇÃO

A mente que se abre a uma nova idéia jamais voltará ao seu tamanho original.

Albert Einstein

Neste primeiro capítulo, você encontrará os conceitos básicos da arquitetura e organização de computadores e um breve histórico sobre os computadores. Para finalizar o tópico, serão apresentados os principais componentes de um computador.

1.1. Conceitos Básicos

A Arquitetura de Computadores trata do comportamento funcional de um sistema computacional do ponto de vista do programador.

Tamanho de um tipo de dados – 32 bits para um inteiro.

A Organização de Computadores trata da estrutura interna que não é visível para o programador.

Freqüência do relógio (clock) ou tamanho da memória física.

Existe um conceito de níveis na arquitetura de computadores. A idéia básica é que existem muitos níveis nos quais o computador pode ser considerado, do nível mais alto, onde o usuário executa programas, ao nível mais baixo, que consiste de transistores e fios (MURDOCCA, 2000).

1.2. Arquitetura X Organização

Arquitetura: são os atributos visíveis para o programador:

� conjunto de instruções;

� número de bits utilizado para a representação de dados;

� mecanismos de E/S;

� técnicas de endereçamento.


13

Existe uma instrução de divisão?

Quais os formatos de endereçamento existentes?

Organização: como as características da arquitetura são implementadas:

� sinais de controle disponíveis;

� interfaces;

� tecnologias de memória.

� como o conjunto de instruções é executado.

Existe uma unidade para divisão ou a divisão é feita por subtrações sucessivas?

� Toda a família Intel X86 possui a mesma arquitetura básica.

� A organização é diferente de uma máquina para outra dentro da mesma família.

� Ter a mesma arquitetura garante a compatibilidade do código.

1.3. Evolução Histórica das Arquiteturas de Computadores

O computador se desenvolveu paralelamente à necessidade crescente de cálculos rápidos e exatos da humanidade. Os ancestrais do computador remontam a mais de 3000 anos.

O primeiro elemento com que o homem contou para fazer seus cálculos foi o conjunto de dedos de suas mãos, daí a palavra digital deriva de dígito, que por sua vez procede do latim digitus, significando dedo. Com a evolução da humanidade, fizeram-se necessárias novas invenções para auxiliar os cálculos.

� Ábaco (aproximadamente 2500 a.C.).

� Bastões de Napier (1610 - 1614).

� Réguas de Cálculo (1621).


14

Figura 1 – Ábaco.

Figura 2 – Bastões de Napier.

Figura 3 – Régua de Cálculo.

1.3.1. Geração Zero (1642 - 1945) – Mecânicos e eletromecânicos

O primeiro a construir uma máquina de calcular foi o filósofo e matemático francês Blaise Pascal em 1642. Essa máquina era inteiramente mecânica e só somava e subtraía. A linguagem de programação PASCAL é assim chamada em homenagem a esse cientista. Trinta anos mais tarde, surge um filósofo e matemático alemão chamado Leibnitz que cria uma máquina que realizava as quatro operações.

No século XIX, o matemático inglês Charles Babbage construiu sua máquina de diferenças que calculava tabelas úteis à navegação naval, mais tarde construiu a máquina analítica que possuía quatro componentes: o armazenamento (memória), o engenho (unidade de cálculo), a seção de entrada (leitora de cartões perfurados) e a seção de saída (saída perfurada e impressa). Uma vez que essa máquina era programável, ele contrata a 1ª programadora da história chamada Ada Lovelace cujo nome serviu para a moderna linguagem de programação, ADA, desenvolvida para o departamento de defesa dos EUA.

Em 1889, Herman Hollerith desenvolveu o cartão perfurado para guardar os dados e também uma máquina tabuladora mecânica, acionada por um motor elétrico, que contava, classificava e ordenava informações armazenadas em cartões perfurados. Ele fundou a empresa Tabulating Machines Corporation que, em 1924, transformou-se na famosa IBM (International Business Machines).

Konrad Zuse (Alemanha) construiu durante a década de 1930 uma série de máquinas de calcular baseadas em relés eletromagnéticos, mas a Segunda Guerra Mundial impediu o seu avanço e ainda causou a sua destruição. Howard Aiken


15

(Estados Unidos da América) construiu em 1944 uma máquina de propósito geral chamada Mark I, baseada no trabalho de Babbage, mas que usava relés eletromagnéticos no lugar de engrenagens.

Figura 4 – Calculadora de Pascal.

Figura 5 – Máquina Diferencial de Babbage.

Figura 6 – Z3, fabricado em 1941 por Konrad Zuse.

Figura 7 – Mark I, construído em 1944 pela Universidade de Harvard e a IBM.


16

1.3.2. As Máquinas de Primeira Geração (1945 - 1955) – Válvulas

Os computadores de primeira geração eram baseados em tecnologias de relés e válvulas eletrônicas. Eles normalmente quebravam após não muitas horas de uso. Tinham dispositivos de entrada/saída primitivos, calculavam com uma velocidade só de milésimos de segundo e eram programados em linguagem de máquina.

Figura 8 – Relé e Válvulas.

Os cartões perfurados foram o principal meio usado para armazenar os arquivos de dados e para carregá-los no computador. A grande utilidade dessas máquinas era o processamento de dados. No entanto tinham uma série de desvantagens como: custo elevado, relativa lentidão, pouca confiabilidade, grande quantidade de energia consumida e necessitavam de grandes instalações de ar condicionado para dissipar o calor gerado por um alto número de válvulas (cerca de 20 mil).

A Segunda Grande Guerra estava no seu auge e a demanda por computadores cada vez mais rápidos vinha crescendo. Os britânicos criavam a menos famosa Colossus para decifrar os códigos nazistas, e, em 1945, os americanos apresentavam o ENIAC (Eletronic Numerical Integrator and Calculator). O modelo utilizava válvulas eletrônicas e os números eram manipulados na forma decimal. Apesar da alta velocidade para a época, era extremamente difícil mudar as instruções contidas dentro do computador, já que a programação era feita por meio de válvulas e fios que eram trocados de posição de acordo com o que se desejava.

O sucessor do ENIAC foi o EDVAC (Electronic Discrete Variable Computer), apesar de ser mais moderno, não diminuiu de tamanho e ocupava 100% do espaço que o ENIAC ocupava. Todavia ele era dotado de cem vezes mais memória interna que o ENIAC - um grande salto para a época. Um outro grande avanço do EDVAC foi o abandono do modelo decimal e a utilização dos códigos binários, reduzindo drasticamente o número de válvulas.

Baseado na revolucionária teoria de von Neumann, em 1951, foi construído o UNIVAC I (Universal Automatic Computer) era bem menor que seus predecessores. Tinha "apenas" vinte metros quadrados e cerca de cinco toneladas. O computador recebia as instruções de cartões magnéticos e não mais de cartões perfurados. Foram produzidas quinze unidades do UNIVAC I e ele foi o primeiro computador comercial da história.

O computador IBM 650 foi disponibilizado publicamente nos USA pela IBM em dezembro de 1954. Media 1,5 m X 0,9 m X 1,8 m e tinha uma massa de 892 Kg. O


17

IBM 650 era indicado para resolver problemas comerciais e científicos. A empresa projetou a venda de 50 exemplares do computador (mais do que todos os computadores do mundo juntos) - o que foi considerado um exagero. Apesar do pessimismo, em 1958, duas mil unidades do IBM 650 estavam espalhadas pelo mundo.

Figura 9 – ENIAC. Figura 10 – IBM 650.

1.3.3. As Máquinas de Segunda Geração (1955 - 1965) – Transistores

Em 1948, surgiu um novo componente que apresentava inúmeras vantagens em relação às antigas válvulas: ele tinha características como menor aquecimento, maior poder de cálculo e confiabilidade e um consumo de energia bem menor - com o adicional de que não necessitava de tempo para aquecer. A Bell Laboratories inventava o transistor. Os cálculos passaram a ser medidos de segundos para microssegundos. As linguagens utilizadas para esses computadores eram normalmente a FORTRAN, COBOL ou ALGOL.

A partir desse momento, devido à maior facilidade e praticidade do transistor, muitos modelos de computador surgiram. O primeiro modelo de computador 100% transistorizado foi o TRADIC, da Bell Laboratories. Outro modelo dessa época era o IBM 1401, com uma capacidade memória base de 4.096 bytes operando em ciclos de memória de 12 microssegundos. A instalação de um IBM 1401 ocupava uma sala, e o tamanho dos computadores ainda era bastante grande. Existiam também outros modelos, como o sofisticado IBM 7094. O IBM TX-0, de 1958, tinha um monitor de vídeo de alta qualidade, além de ser rápido e relativamente pequeno. A Digital Equipment Corporation (DEC) tinha então uma posição proeminente no setor com sua linha PDP. O primeiro minicomputador foi o PDP-1, criado em 1959 e instalado em 1961. No entanto, os elevados custos destas máquinas restringiam sua utilização a aplicações estratégicas do governo, grandes empresas e universidades.


18

Figura 11 – DEC PDP-1. Figura 12 – IBM 7094.

1.3.4. As Máquinas de Terceira Geração (1965 - 1980) – Circuitos Integrados

A terceira geração inicia-se com a introdução dos circuitos integrados (transistores e outros componentes eletrônicos miniaturizados e montados numa única pastilha de silício - o chip), aos computadores. Com esses circuitos integrados, o tempo passou a ser medido em nanosegundos (bilionésimos de segundos). A tecnologia utilizada, na época, era a de pequena escala de integração (SSI – Small Scale of Integration) com a qual ao redor de mil transistores podiam-se integrar no circuito de uma pastilha. Com isso os computadores eram menores, mais confiáveis, com maior velocidade de operação e um custo bem mais baixo do que as máquinas das gerações anteriores. Também eram usados discos magnéticos para armazenamento, o que permitiu o acesso direto a arquivos muito grandes.

Os custos de produção de um computador começavam a cair, atingindo uma faixa de mercado que abrangia empresas de médio porte, centros de pesquisa e universidades menores. O Burroughs B-2500 foi um dos primeiros modelos dessa geração. O PDP-5, produzido pela DEC, foi o primeiro minicomputador comercial e o INTEL 4004 o primeiro microprocessador.

O exemplo típico dessa geração foi o IBM 360, série que introduziu o conceito de família de computadores compatíveis, facilitando a migração dos sistemas quando é necessário mudar para um computador mais potente. Esta estratégia permitiu que a IBM se posicionasse, já neste período, como líder do mercado de computadores. Outros computadores desta geração que conheceram grande sucesso, particularmente nas universidades e centros de pesquisa, foram os minicomputadores da série PDP-11.

Mais uma novidade introduzida por esta classe de computadores foi o conceito de multiprogramação, na qual diversos programas poderiam estar residentes na memória da máquina. No caso em que um programa entrasse em espera para uma operação de entrada/saída de dados, a unidade central passava a executar a parte de um outro programa.


19

Figura 13 – IBM 360. Figura 14 – DEC PDP-11.

1.3.5. As Máquinas de Quarta Geração (1980 - 1990) – Circuitos LSI

Ainda mais avançados que os circuitos integrados, eram os circuitos LSI (Large Scale of Integration) com mil transistores por "chip" e VLSI (Very Large Scale of Integration) com cem mil transistores por "chip". O uso desses circuitos na construção de processadores representou outro salto na história dos computadores.

As linguagens mais utilizadas eram a PROLOG, FP, UNIX e o início da utilização da linguagem C. Logo em 1981, nasce o microprocessador 286 utilizando slots ISA de 16 bits e memórias de 30 pinos. Quatro anos mais tarde, era a vez do 386, com maior velocidade de processamento. Ao contrário do 286, era possível rodar o Windows 3.11 no 386. Introduziram-se, no mercado, as placas VGA e suporte a 256 cores. Em 1989, eram lançados os primeiros 486 DX, eles vinham com memórias de 72 pinos (muito mais rápidas que as antigas de 30 pinos) e possuíam slots PCI de 32 bits - o que representava o dobro da velocidade dos slots ISA.

Figura 15 – Microprocessadores Intel 386 e 486/DX2.

Desde o início da década de 80, os preços haviam caído de tal maneira que começava ser possível a uma pessoa ter o seu próprio computador. Foi cunhado o conceito de "PC", ou "Personal Computer", e os computadores pessoais passaram a ser utilizados de uma maneira relativamente distinta dos grandes computadores de então.

O primeiro microcomputador da história foi o Altair 8800, que usava o chip Intel 8088, tornou-se o padrão mundial da época para os microcomputadores de uso pessoal, abrindo uma nova era na história da informática.

Sthephen Wozniak e Steve Jobs criaram, em 1976, uma pequena empresa, a Apple, quando construíram, numa garagem de fundo de quintal, o Apple I. Um ano depois, com um novo e melhor projeto, surge o Apple II, primeiro microcomputador com


20

grande sucesso comercial e, mais tarde, o Apple III. Em 1983, entra no mercado o Lisa e, em 1984, o Macintosh, com tecnologia de 32 bits.

Figura 16 – Altair 8800.

Figura 17 – Apple II.

Em 1981, a IBM entrou no mercado de micros, introduzindo o PC, um microcomputador com tecnologia de 16 bits (Intel 8088) que em pouco tempo se tornou um padrão. O PC/XP usava o sistema operacional PC/MS-DOS, uma versão do MS-DOS desenvolvida para a IBM pela Microsoft.

Além disso, diversos modelos e estilos foram sendo lançados nessa época: Lotus 1-2-3, Sinclair ZX81/ZX Spectrum, Osborne1, etc.

Figura 18 – IBM/XT. Figura 19 – Osborne I.

1.3.6. As Máquinas de Quinta Geração (1990 - dias atuais) – Circuitos ULSI

As aplicações exigem cada vez mais uma maior capacidade de processamento e armazenamento de dados. Sistemas especialistas, sistemas multimídia (combinação de textos, gráficos, imagens e sons), banco de dados distribuídos e redes neurais, são apenas alguns exemplos dessas necessidades. Uma das principais características dessa geração é a simplificação e miniaturização do computador, além de melhor desempenho e maior capacidade de armazenamento. Tudo isso, com os preços cada vez mais acessíveis.

A tecnologia VLSI foi substituída pela ULSI (Ultra Large Scale Integration). O conceito de processamento está partindo para os processadores paralelos, ou seja,


21

a execução de muitas operações simultâneas pelas máquinas. A redução dos custos de produção e do volume dos componentes permitiu a aplicação destes computadores nos chamados sistemas embutidos, que controlam aeronaves, embarcações, automóveis e computadores de pequeno porte. Os micros que utilizam a linha de processadores Pentium, da Intel, são exemplos desta geração de computadores que surgiu em 1993. As grandes mudanças neste período ficariam por conta das memórias DIMM de 108 pinos, do aparecimento das placas de vídeo AGP e de um aprimoramento da slot PCI melhorando ainda mais seu desempenho. Em 1997 surge o Pentium II, em 1999 o Pentium III, em 2001 o Pentium 4 e mais recentemente os processadores da nova microarquitetura Intel Core, com processadores com mais de um núcleo em um único encapsulamento (sem contar os modelos similares da concorrente AMD).

Figura 20 – Processadores: Intel Core 2 Extreme e AMD Athlon 64 X2 Dual-Core.

Enfim, a informática evolui cada vez mais rapidamente e as velocidades de processamento dobram em períodos cada vez mais curtos. Para se ter uma noção disso, basta observar que entre os modelos de computador mais antigos, os espaçamentos entre uma novidade e outra eram de dezenas de anos, sendo que hoje não chega a durar nem um mês. Isso nos leva a concluir que o avanço científico e do poder de cálculo avança de maneira que não se encontra paralelo na história humana, barateando os custos e tornando acessíveis os computadores às pessoas de baixa renda.

Quem sabe uma nova geração de computadores não está por vir? Alguns falam em processadores quânticos quando os limites da miniaturização do silício forem atingidos, enquanto outros falam em moléculas de água armazenando informações - mas o fato é que coisas novas vão surgir e novas gerações deixarão a atual tão longe e ultrapassada como está a segunda para nós. Mesmo rompendo recentemente a barreira dos terabytes, a evolução dos computadores ainda está longe de terminar.

Leia, no Ambiente Virtual de Aprendizagem, na Midiateca, a apresentação “Uma Breve História da Computação”. Material baseado em uma compilação da Profa. Dra. Rosely Sanches.


22

Pesquise a respeito das especificações técnicas (memória, processamento, barramento, clock, instruções, etc.) dos computadores de 1ª a 5ª geração.

Faça um pequeno relatório com as especificações técnicas de uma máquina de cada geração.

1.3.7. O modelo de von Neumann

A grande maioria dos computadores existentes atualmente segue um modelo proposto pelo matemático americano John von Neumann por volta de 1940. Nesse modelo, um elemento processador segue as instruções armazenadas em uma memória de programas, para ler canais de entrada, enviar comandos sobre canais de saída e alterar as informações contidas em uma memória de dados. A Figura 21 indica a estrutura desse modelo.

Figura 21 – Modelo de von Neuman.

Esse modelo inicial evoluiu para uma estrutura em barramento (Figura 22), que é a base dos computadores modernos. Nessa estrutura, as memórias de dados e de programa são fundidas em uma memória única, e as comunicações entre elementos são efetuadas através de uma via comum de alta velocidade.

Figura 22 – Modelo de von Neuman (Estrutura em Barramento).

Uma variante do modelo básico de máquinas von Neumann é denominado de máquinas Harvard, no qual há vias separadas para dados e instruções entre


23

memória principal e CPU. A origem do termo vem dos computadores Mark I a Mark IV, desenvolvidos em Harvard, com memórias de dados e instruções separadas.

1.4. Principais Componentes de um Computador

Existem três elementos fundamentais em um sistema computacional, cada um executando uma tarefa especial. Estes elementos são:

1. A Unidade Central de Processamento (CPU).

2. A Memória Principal.

3. Os Dispositivos ou Portas de Entradas e Saídas (I/O).

Figura 23 – Componentes de um Computador.

1.4.1. A Unidade Central de Processamento (CPU)

A CPU, ou processador, tem como função principal unificar todo o sistema, controlando as funções realizadas por cada unidade funcional. A CPU executa o processamento numérico, as operações lógicas e as funções de temporização. As operações da CPU são controladas por um conjunto de instruções que, quando organizadas em uma seqüência lógica, formam o chamado programa.

Os programas e os dados a serem manipulados obrigatoriamente deverão estar armazenados na memória principal. A CPU é alimentada com dados e sinais de controle, executa uma instrução por vez e produz como saída dados e sinais de controle.


24

Internamente, uma CPU é formada por 3 unidades fundamentais:

1. Os Registradores.

2. A Unidade Lógica e Aritmética (ULA).

3. O Circuito de Controle.

Figura 24 – Unidade Central de Processamento (CPU).

Registradores – são dispositivos de alta velocidade para armazenamento temporário de dados. Os registradores, geralmente numerosos, são utilizados para assegurar o armazenamento temporário de informações importantes para o processamento de uma determinada instrução. Um registrador memoriza um número limitado de bits, geralmente uma palavra de memória. Os registradores mais importantes são:

• Contador de Programa (PC - Program Counter), que aponta para a próxima instrução a ser executada.

• Registrador de Instrução (IR - Instruction Register) que armazena a instrução em execução.

• Outros registradores que permitem o armazenamento de resultados intermediários.

Unidade Lógica e Aritmética (ALU) – assume todas as tarefas relacionadas às operações lógicas (ou, e, negação, etc.) e aritméticas (adições, subtrações, etc...) a serem realizadas no contexto de uma tarefa.

Unidade de Controle – coordena todas as atividades do microprocessador. É esta unidade que assume toda a tarefa de controle das ações a serem realizadas pelo computador, comandando todos os demais componentes de sua arquitetura. Através de pulsos externos de temporização chamados "clocks", o circuito de controle gera as seqüências apropriadas de eventos necessários à execução das tarefas de processamentos.


25

1.4.2. Barramentos

A CPU, a memória principal e os dispositivos de I/O são interligados por meio de linhas de comunicação denominadas barramentos ou vias. Um barramento (bus) é um conjunto de fios paralelos (linhas de transmissão), nos quais trafegam informações como dados, endereços ou sinais de controle.

Os dados trafegam na CPU, memória e I/O através de via de dados. Estes dados poderão ser instruções para CPU ou informações da CPU para portas I/O e vice-versa.

A via de endereço é utilizada pela CPU para selecionar uma célula de memória ou um dispositivo I/O por meio de um código binário.

A via de controle conduz os sinais de controle para a memória e para os dispositivos I/O, especificando as direções dos dados em relação à CPU, o momento exato da transferência, o tipo de operação, etc.

Se um processador quiser armazenar um dado 10101100b no endereço 5h, ele deverá colocar, no barramento de dados, o valor do dado (10101100b), no barramento de endereços, o valor do endereço (5h) e, no barramento de controle, confirmar que se trata de uma operação de escrita em memória. Tudo isso é feito simultaneamente e é transparente ao usuário.

1.4.3. Clock

Clock é um circuito oscilador que tem a função de sincronizar e ditar a medida de velocidade de transferência de dados no computador, por exemplo, entre o processador e a memória principal. Esta freqüência é medida em ciclos por segundo, ou Hertz.

Existe a freqüência própria do processador, comandando operações internas a ele e a freqüência do computador a ele associado, basicamente ciclos CPU-Memória principal.

Os processadores Pentium-100, Pentium MMX-233, Pentium II-300 acessam a memória principal a 66 MHz. Suas freqüências respectivas de 100, 233 e 300 MHz são atingidas, tão somente, no interior do chip. Dizem respeito, portanto, ao processamento interno do processador e não à freqüência na relação CPU-Memória do computador. Já o processador Pentium II-350 tem uma freqüência externa de 100 MHz, acarretando um desempenho melhor do microcomputador, tanto no processamento propriamente dito quanto nas operações de disco e vídeo.

25MHz são 25 milhões de ciclos por segundo. A duração de um ciclo, seu período, é o inverso da freqüência, então cada ciclo será o inverso de 25.000.000 ou 1/25.000.000 = 0,00000004 ou 40x10-9 = 40 ηseg.


26

1.4.4. Memória Principal

É o componente do sistema com a função de armazenar informações que são, foram ou serão manipuladas pelo processador. Ela é conhecida também como primária e é formada por dois tipos de memória: RAM (Random Access Memory) – Memória de Acesso Aleatório e a ROM (Read Only Memory) – Memória Somente de Leitura.

Atualmente, os microcomputadores possuem memória principal (RAM) de 256MB (Mega Bytes) a 2GB (Giga Byte). A RAM é uma memória volátil, porém há uma pequena parte da memória principal composta por memória não volátil (ROM) que armazenamos instruções que são sempre executadas quando o computador é ligado. O software gravado na ROM recebe o nome de firmware. Eles são basicamente três:

• BIOS (Basic Input/Outpu System) – Conjunto de instruções básicas de software que permite ao processador trabalhar com periféricos básicos.

• POST (Power-On Self Test) – Autoteste de inicialização, realizado sempre que o computador é inicializado.

• SETUP – Programa de configuração do hardware do computador.

1.4.5. Memória Cache

A memória cache é uma memória volátil de alta velocidade normalmente integrada aos processadores. O tempo de acesso a um dado nela contido é muito menor que se fosse buscá-lo diretamente na memória principal. Este tempo é de 10 a 25ηs e normalmente sua capacidade varia de 256KB, 512KB e 1MB.

Toda vez que o processador faz referência a um dado armazenado na memória principal, ele “olha” antes na memória cache. Se o processador encontrar o dado na cache, não há necessidade do acesso à memória principal; do contrário, o acesso é obrigatório.

Um computador sem cache:

• 30% mais lento para processamento.

• 20% mais lento para acesso a disco.

• 10% mais lento para acesso a vídeo.

Imagine a memória RAM como uma mesa do outro lado da sala. Quando você vai pegar uma informação lá, por exemplo, um número de telefone, você vai anotá-lo para trazê-lo para sua mesa. Por quê? Se você precisar do mesmo número de telefone outra vez, não vai precisar se levantar e buscá-lo na outra mesa, só precisa ler no papel perto de você.


27

1.4.6. Memória Secundária

Conhecida também como memória auxiliar ou memória de massa é um meio permanente (não volátil) de armazenamento de programas e dados. Enquanto a memória principal precisa estar sempre energizada para manter suas informações, a memória secundária não precisa de alimentação.

A memória secundária pode ser constituída por diferentes tipos de dispositivos, alguns diretamente ligados ao sistema para acesso imediato, como no caso dos discos rígidos (HDs), e outros que podem ser conectados quando desejado (disquetes, fitas, CD-ROM, DVD, etc.).

O acesso à memória secundária é lento se comparado com o acesso à memória cache ou à principal, porém seu custo é baixo e sua capacidade de armazenamento é bem superior à da memória principal. O tempo de acesso/ciclo de memória é alto devido a esses dispositivos serem, em geral, eletromecânicos e não circuitos puramente eletrônicos. HDs de 5 a 40ms, CD-ROM de 120 a 300 ms e fitas magnéticas na ordem de segundos.

Figura 25 – Hierarquia de Memórias.

1.4.7. Dispositivos de Entrada e Saída (E/S ou I/O)

Os dispositivos de entrada e saída, também conhecidos por periféricos, são utilizados para permitir a comunicação entre o computador e mundo externo. Através desses dispositivos, o computador pode armazenar, ler, transmitir e receber dados. Dentre os diversos dispositivos de E/S, existem alguns que são especializados apenas em ENTRADA, outros especializados apenas em SAÍDA e outros em ENTRADA e SAÍDA.


28

� Entrada: teclado, mouse, microfone, scanner, caneta óptica, mesa

digitalizadora, leitora de códigos de barras, leitora de cartão magnético, joystick, câmera de vídeo, sensores, etc.

� Saída: monitor de vídeo, projetor de vídeo, impressora, plotadora, caixa de som, controladores, etc.

� Entrada e Saída: drive de disquete (floppy disk), disco rígido (HD), modem, placa de rede, leitor e gravador de CD/DVD, pen drive, etc.

Figura 26 – Dispositivos de Entrada.

Figura 27 – Dispositivos de Saída.

Figura 28 – Dispositivos de Entrada e Saída.


29

2. SISTEMAS DIGITAIS

Os computadores são equipamentos eletrônicos digitais, portanto toda a informação a ser armazenada, movimentada e processada internamente deverá ser transformada para o código binário, ou seja, usam apenas DUAS grandezas, representadas pelos algarismos 0 e 1.

2.1. O Bit, a Palavra, o Caractere, o Nibble e o Byte

A menor unidade de informação armazenável em um computador é o algarismo binário ou dígito binário, conhecido como bit (binary digit). O bit assume dois valores: 0 e 1.

O menor grupo ordenado de bits representando uma informação útil e inteligível para o ser humano é o caracter. Cada sistema poderá definir como cada conjunto de bits irá representar um determinado caractere, quantos bits e como se organizam.

O conjunto de 4 bits é chamado de nibble, termo pouco empregado. O conjunto de 8 bits foi definido pela primeira vez pela IBM e é chamado de byte. Daí em diante, todos os fabricantes adotam o mesmo padrão até os dias de hoje.

A palavra é o conjunto de bits que representa uma informação útil e está relacionada com o armazenamento e a transferência de informações entre a Memória Principal e a CPU. Portanto a palavra é um conjunto de bytes. Um computador com uma palavra de 32 bits tem 4 bytes/palavra. As operações de armazenamento e recuperação de dados na memória são feitas byte a byte ou palavra a palavra, portanto é comum mencionarmos o tamanho de uma memória em termos de bytes.

Para representar valores maiores, utilizaremos o sistema métrico de grandeza, com algumas adaptações para os computadores.

Sufixo Quantidade

Kilo (K) 1 Kilobytes ou 1 KB = 1024 = 210

Mega (M) 1 Megabytes ou 1 MB = 1.048.576 = 220

Giga (G) 1 Gigabytes ou 1 GB = 1.073.741.824 = 230

Tera (T) 1 Terabytes ou 1 TB = 1.099.511.627.776 = 240

Peta (P) 1 Petabytes ou 1 PB = 1.125.899.906.843.624 = 250

Exa (E) 1 Exabytes ou 1 EB = 1.152.921.504.607.870.976 = 260

Tabela 1 – Tabela de Medidas.


30

Devemos ter cuidado para não cometermos falsos arredondamentos. 65.536, por exemplo, representa, em binário, 64 K (e não 65 K, como parece), assim como 157.286.400 representa 150 M (e não 157 M). (TORRES, 1999).

2.2. Sistemas Numéricos

Sistemas numéricos são sistemas de notação usados para representar quantidades abstratas denominadas números. Um sistema numérico é definido pela base que utiliza.

A base de um sistema é o número de símbolos diferentes, ou algarismos, necessários para representar um número qualquer. O sistema decimal, utilizado hoje de forma universal, utiliza dez símbolos diferentes ou dígitos para representar um número e é, portanto, um sistema numérico na base 10.

Os computadores utilizam a base 2 (sistema binário) e os programadores, por facilidade, usam em geral uma base que seja uma potência de 2, tal como 24 (base 16 ou sistema hexadecimal) ou eventualmente ainda 23 (base 8 ou sistema octal).

Se na base 10, dispomos de 10 algarismos para a representação do número: 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9. Na base 2, seriam apenas 2 algarismos: 0 e 1. Na base 16, seriam 16: os 10 algarismos aos quais estamos acostumados, mais os símbolos A, B, C, D, E e F, representando respectivamente 10, 11, 12, 13, 14 e 15 unidades. Generalizando, temos que uma base b qualquer disporá de b algarismos, variando entre 0 e (b-1).

2.2.1. Sistema Decimal

Entre os sistemas numéricos existentes, o sistema decimal é o mais utilizado. Os símbolos ou dígitos utilizados são os algarismos 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9. Os elementos são agrupados de dez em dez e, por essa razão, os números podem ser expressos por intermédio de potência de dez e recebem o nome de sistema de numeração decimal.

486 = 400 + 80 + 6 = 4 x 100 + 8 x 10 + 6 x 1 = 4 x 102 + 8 x 101 + 6 x 100, ou seja, 486 = 4 x 102 + 8 x 101 + 6 x 100.


31

Observe que o número 4 está numa posição tal que seu peso é igual a 2 e que o número 6, por sua vez, tem o peso igual a zero. Então podemos concluir que o algarismo ou dígito, dependendo do seu posicionamento, terá um peso. Note que aquele situado na extrema esquerda do número está sendo multiplicado pela potência de dez maior, ou seja, é o dígito mais significativo (most significant digit – MSD). Analogamente, o que está situado na extrema direita será multiplicado pela menor potência, ou seja, é o dígito menos significativo (least significant digit – LSD).

a) O princípio de posicionamento, que formula o expoente da base 10, pode ser estendido a qualquer sistema numérico, ou seja, independe da base numérica em que está representado.

b) Por ser o sistema padrão de uso (é o sistema que utilizamos em nosso dia-a-dia), o sistema decimal não necessita de representação de base, a fim de simplificação de escrita.

2.2.2. Sistema Binário

Como o próprio nome já indica tem base 2, pois utiliza apenas dois símbolos ou algarismos: 0 e 1. Também vale ressaltar que, em processamentos digitais, o dígito 1 também é conhecido por nível lógico 1, nível lógico alto, ligado, verdadeiro e energizado. Já o dígito 0 pode ser nível lógico 0, nível lógico baixo, desligado, falso e desenergizado.

Assim, a cada posição de cada algarismo corresponde uma potência de 2, como foi exposto para número decimal, ao qual correspondia uma potência de 10.

2.2.2.1. Conversão de Binário em Decimal

É o mesmo processo já estudado para base 10, ou seja:

10111(2) = 1x24 + 0x23 + 1x22 + 1x21 + 1x20 = 16 + 0 + 4 + 2 + 1 = 23, ou seja,

10111(2) = 23(10) ou 10111(2) = 23


32

Como os dígitos binários são chamados de bit, da mesma forma como falamos no sistema decimal, dependendo do posicionamento o algarismo ou bit terá um peso; o da extrema esquerda será o bit mais significativo (most significant bit – MSB) e o da extrema direita o bit menos significativo (least significant bit – LSB).

4 3 2 1 0 1 1 0 1 1(2) = 1x24 + 1x23 + 0x22 + 1x21 + 1x20 = 16 + 8 + 0 + 2 + 1 = 27

MSB LSB

2.2.2.2. Conversão de Decimal em Binário

Na conversão decimal-binário, podem ser utilizados dois métodos: o primeiro que é mais geral, dito das divisões sucessivas, consiste em dividir sucessivamente o número por 2 até obtermos o cociente 0 (zero). O resto dessa divisão colocado na ordem inversa corresponde ao número binário correspondente ao decimal dado.

54 = ?(2)

54 = 1 1 0 1 1 0 (2)

O segundo método de conversão consiste em, começando como número decimal a ser convertido, extrair a maior potência de 2 (menor ou igual) possível. Repetindo este processo para o resto dessa subtração até que o resto seja zero. Concluindo, marque com o dígito 1 os expoentes utilizados e com o dígito zero os expoentes não utilizados.

54 = ?(2) 256 128 64 32 16 8 4 2 1

54 – 32 = 22 22 – 16 = 6 6 – 4 = 2 2 – 2 = 0

Portanto nós utilizamos as potências 32=25, 16=24, 4=22 e 2=21, ou seja:

5 4 3 2 1 0

32 16 8 4 2 1

Resposta = 1 1 0 1 1 0 (2)


33

Este método, evidentemente, exige um pouco mais de raciocínio, devido ao problema de memorização das potências de dois e subtrações.

Exercícios: Converta os valores para as bases indicadas.

a) 111011(2) = ? b) 110110(2) = ? c) 10011(2) = ?

d) 10110(2) = ? e) 215 = ? (2) f) 43 = ? (2)

g) 101 = ? (2) h) 36 = ? (2) i) 543 = ? (2)

2.2.3. Sistema Octal

O sistema octal ou base 8 é composto por oito símbolos ou dígitos: 0, 1, 2, 3, 4, 5, 6, e 7. Os números binários, como vimos, são longos demais para manipularmos; são muito apropriados para as máquinas ou computadores, mas para seres humanos são muito trabalhosos.

Se considerarmos três dígitos binários, o maior que pode ser expresso por esses três dígitos é 111(2) ou em decimal 7. Como o 7 é também o algarismo mais significativo do sistema octal, conclui-se que com a combinação de três dígitos binários pode-se ter o algarismo octal correspondente; daí também se pode dizer que os números octais têm um terço do comprimento de um número binário e fornecem a mesma informação.

2.2.3.1. Conversão de Binário em Octal

É feita pela combinação de três dígitos binários, podendo assim ter todos os algarismos octais:

11011011(2) = 11 011 011 = 3 3 3 (8) →→→→ 11011011(2) = 333(8)

1011101(2) = 1 011 101 = 1 3 5 (8) →→→→ 1011101(2) = 135(8)

2.2.3.2. Conversão de Octal em Binário

A conversão de uma base em outra é bastante simples, uma vez que se trata da operação inversa à já descrita, ou seja, basta converter individualmente cada dígito octal em três binários.


34

137(8) = ?(2)

O número 1 equivale a 001(2), o número 3 igual a 011(2) e o número 7 vale 111(2).

Portanto:

137(8) = 001011111(2), ou seja, 137(8) = 1011111(2).

2.2.3.3. Conversão de Octal em Decimal

Esta conversão se passa pela conversão em binário e posteriormente em decimal, ou seja:

17(8) = ?

17(8) →→→→ 001 111(2) →→→→ 1x23 + 1x22 + 1x21 + 1x20 →→→→ 8 + 4 + 2 + 1 = 15.

2.2.3.4. Conversão de Decimal em Octal

Conforme vimos anteriormente, também neste caso, devemos passar pelo sistema binário.

22 = ?(8)

22 →→→→ 10110(2) →→→→ 10 110(2) →→→→ 26(8),ou seja, 22 = 26(8).


a) 45(8) = ?(2) = ? b) 1011(2) = ? (8) = ? c) 56(8) = ?

d) 101 = ? (8) e) 101(2) = ? (8) = ? f) 47(8) = ?(2) = ?

2.2.4. Sistema Hexadecinal

O sistema hexadecimal (hexa) foi criado com o mesmo propósito do sistema octal, para minimizar a representação de um número binário que é o utilizado em processamento. Tanto os números em hexa como em octal são os meios de manipulação do homem, porém existirão sempre conversores internos à máquina que os converta em binário, com o qual a máquina trabalha.

Analogamente, se considerarmos quatro dígitos ou bits binários, o maior número que pode ser expresso por esses quatro dígitos é 1111 ou em decimal 15, da mesma forma que 15 é o algarismo mais significativo do sistema hexadecimal, portanto com


35

a combinação de 4 bits ou dígitos binários pode-se ter o algarismo hexadecimal correspondente.

Assim, com esse agrupamento de 4 bits ou dígitos, podem-se definir 16 símbolos, de 0 até 15. Contudo, como não existem símbolos dentro do sistema arábico que possam representar os números decimais entre 10 e 15 sem repetir os símbolos anteriores, foram usados os símbolos A, B, C, D, E e F, portanto o sistema hexadecimal será formato por 16 símbolos alfanuméricos: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E e F.

2.2.4.1. Conversão de Hexa em Binário

Basta converter cada dígito hexadecimal em seu similar binário, ou seja, cada dígito em hexa equivale a um grupo de 4 bits.

B15(16) = ? (2) B(16) →→→→ 11 →→→→ 1011(2)

1(16) →→→→ 1 →→→→ 0001(2)

5(16) →→→→ 5 →→→→ 0101(2)

Logo, B15(16) = 101100010101(2)

2.2.4.2. Conversão de Binário em Hexa

De maneira análoga, basta realizar o processo inverso de hexa para binário.

10011011(2) = ? (16) 1001(2) →→→→ 9 →→→→ 9(16)

1011(2) →→→→ 11 →→→→ B(16)

Portanto, 10011011(2) = 9B(16)

2.2.4.3. Conversão de Hexa nos demais sistemas e vice-versa

Como podemos perceber, para realizarmos a conversão nos demais sistemas, basta passarmos pela binária e/ou pelo sistema decimal.


a) 211 = ? (2) = ? (8) = ? (16) b) 1101011(2) = ? (16) = ? = ? (8)

c) 3747(8) = ? (16) = ? (2) = ? d) AAE(16) = ? = ? (8) = ? (2)

e) Fazer um programa para conversão de sistemas numéricos entre as diversas bases (2, 8, 10 e 16), somente números inteiros.


36

Baixe da Midiateca, no Ambiente Virtual de Aprendizagem, o programa Sisnum.exe que é um conversor de base numérica desenvolvido pelo aluno Márcio Henrique da Silva. Este software será útil para a correção dos exercícios propostos.

TABELA DE CONVERSÃ0

Decimal Binário Octal Hexadecimal

0 0000 0 0

1 0001 1 1

2 0010 2 2

3 0011 3 3

4 0100 4 4

5 0101 5 5

6 0110 6 6

7 0111 7 7

8 1000 8

9 1001 9

10 1010 A

11 1011 B

12 1100 C

13 1101 D

14 1110 E

15 1111 F

Tabela 2 – Conversão de Base Numérica.

2.3. Portas Lógicas

Durante séculos, os matemáticos sentiram que havia uma conexão entre a Matemática e a Lógica, mas ninguém antes de George Boole pôde achar este elo ausente. Em 1854, ele inventou a lógica simbólica, conhecida por álgebra booleana. Cada variável, na álgebra booleana, tinha qualquer um de dois valores: verdadeiro ou falso. Após algumas décadas, os engenheiros entenderam que a álgebra booleana podia ser aplicada à Eletrônica dos Computadores.


37

2.3.1. Portas NOT (Inversoras)

Uma inversora é uma porta com apenas um sinal de entrada e um sinal de saída, o estado da saída é sempre o oposto da entrada.

Simbologia:

Tabela Verdade

A Ā

0 1

1 0 Tabela 3 – Porta NOT.

Representação em Álgebra Booleana: AS =

2.3.2. Portas OU (OR, + , ∨∨∨∨)

A porta OR tem dois ou mais sinais de entrada (padrão 2 ou 3), mas somente um sinal de saída. Se qualquer sinal de entrada for alto (nível 1 - fechado), o sinal de saída será alto.

Simbologia:


38

Tabela Verdade

A B C S

0 0 0 0 0 0 1 1 0 1 0 1

0 1 1 1 1 0 0 1

1 0 1 1 1 1 0 1

1 1 1 1 Tabela 4 – Porta OR.

Representação em Álgebra Booleana: CBAS ++=

2.3.3. Portas E (AND, . , ∧∧∧∧)

A porta AND tem dois ou mais sinais de entrada (padrão 2 ou 3), mas somente um sinal de saída. Se qualquer sinal de entrada for baixo (nível 0 - aberto), o sinal de saída será baixo.

Simbologia:

Tabela Verdade

A B S

0 0 0 0 1 0 1 0 0

1 1 1 Tabela 5 – Porta AND.

Representação em Álgebra Booleana: B.AS =


39

Exercícios:

a) Fazer o circuito de portas lógicas equivalente para seguinte equação booleana:

B.C)(AS +=

b) Fazer a tabela verdade para porta AND com 3 entradas.

c) Fazer a tabela verdade para porta OR com 4 entradas.

d) Fazer o circuito de portas lógicas equivalente a: BC).(AC).B)((AS +++=

e) Fazer o circuito de portas lógicas para:

C.)BA(.C)B).((AS ++=

2.3.4. Portas NÃO OU (NOR)

As portas NOR apresentam as mesmas características das portas OR, com relação à entrada e saída. Sua diferença está no fato de ter associado a sua saída uma porta NOT, o que inverte o resultado de S, ou seja, só teremos nível lógico 1 na saída quando todas as entradas forem de nível 0.

Simbologia:

Tabela Verdade

A B S

0 0 1 0 1 0 1 0 0

1 1 0 Tabela 6 – Porta NOR.

Representação em Álgebra Booleana: BAS +=

2.3.5. Portas NÃO E (NAND)

De maneira análoga às portas NOR, as portas NAND nada mais são que portas AND onde foram acrescentadas portas NOT em sua saída. Portanto, só obteremos nível 0 quando todas as suas entradas forem de nível 1.


40

Simbologia:

Tabela Verdade

A B S

0 0 1 0 1 1 1 0 1 1 1 0 Tabela 7 – Porta NAND.

Representação em Álgebra Booleana: B.AS =

Talvez esta porta seja a mais importante de todas, pois através dela podemos implementar as demais:

Porta NOT

Porta AND

Porta OR

2.3.6. Portas OU Exclusiva – XOU (XOR, ⊕⊕⊕⊕)

Uma porta XOR reconhece apenas quando houver um número ímpar de entradas em nível alto.


41

Circuito equivalente:

Simbologia:

Tabela Verdade

A B S

0 0 0 0 1 1 1 0 1

1 1 0 Tabela 8 – Porta XOR.

Representação em Álgebra Booleana: BAB.AB.AS ⊕=+=

2.3.7. Portas NÃO OU Exclusiva – XNOU (XNOR, ��)

Como nas demais portas, para obtermos uma porta XNOR, basta adicionarmos ao final de uma porta XOR uma porta inversora, o que provocará a inversão dos resultados na saída.

Simbologia:


42

Tabela Verdade

A B S

0 0 1 0 1 0 1 0 0

1 1 1 Tabela 9 – Porta XNOR.

Representação em Álgebra Booleana: BABAB.AB.AS �=⊕=+=

Exercícios:

Consultar o livro Microcomputadores e Microprocessadores, do autor Albert Paul Alvino. Fazer os problemas 2-1 a 2-25 e os problemas 3-1 a 3-34 do livro.

2.4. Álgebra Booleana e Mapa de Karnaugh

Iremos estudar a álgebra booleana e os mapas de Karnaugh, tópicos indispensáveis ao projetista digital. O projeto digital, usualmente, inicia-se especificando uma saída desejada com uma tabela-verdade. A pergunta então é como apresentar um circuito lógico que tenha a mesma tabela-verdade? A álgebra booleana e os mapas de Karnaugh são as ferramentas usadas para transformar uma tabela-verdade num circuito lógico prático.

2.4.1. Álgebra Booleana

O que se segue é uma discussão das relações básicas em álgebra booleana. Muitas destas relações são as mesmas da álgebra comum, o que facilita lembrá-las.


43

Relações Booleanas: Leis Comutativas, Associativas e Distributivas:

RELAÇÕES BOOLEANAS

A0A =+ 11A =+ AAA =+

1AA =+ AA = A1.A =

00.A = AA.A = 0A.A =

B.ABA =+ BAB.A += AB.AA =+

A)BA(.A =+ BAB.AA +=+ B.A)BA(.A =+

ABBA +=+ BAB.A = ABBA =

C)BA()CB(A ++=++ C)BA()CB(A = CABA)CB(A +=+

)CA()BA(CBA +++=+ ⇒ Vale lembrar que não se trata de álgebra comum.

Tabela 10 – Regras da Álgebra Booleana.

2.4.1.1. Expressões Lógicas – Aplicações das Portas

Uma expressão lógica ou uma função lógica pode ser definida como sendo uma expressão algébrica formada por variáveis lógicas (binárias), por símbolos representativos de uma operação lógica (+, . , etc.), por parênteses (às vezes) e por um sinal de igual.

Prioridades:

1º - sempre serão resolvidos os parênteses, do mais interno para o mais externo;

2º - o operador NOT quando ele envolve apenas um elemento;

3º - o operador AND;

4º - o operador OR;

5º - o operador XOR.

)BA(C.BAX +⊕+=

Para A = 1 , B = 0 e C = 1:

1º - 0101BA ==+=+ ⇒ Resolvemos primeiro o parêntese

2º - 01.0C.B ==

3º - 101C.BA =+=+

4º - 101)BA()C.BA( =⊕=+⊕+


44

Exercícios:

Seja A = 1001, B = 0010, C = 1110 e D = 1111. Calcule:

a) )DB()DC.B(AX ⊕++⊕=

b) )BC(.))D.CB(A(Y +⊕+=

c) )C.A()DC(.)BA(W +++=

2.4.1.2. Simplificação de Expressões Lógicas

� Utilização das regras da álgebra Booleana para obter expressões mais simples.

� Usualmente há mais de uma possibilidade de simplificação.

C.AC.B.AC.B.AF ++=

C.AC.B.AC.B.A ++ ⇒ C.A)C(C.B.A ++= ⇒

⇒ C.A1.B.A += ⇒ C.AB.AF +=

Exercícios:

a) Desenhar o circuito digital simplificado para:

a.1) DCBADCBADCB A S ++=

a.2) DCBADCBADCBADCBA S +++=

b) Escreva a equação booleana para:


45

c) Determinar o circuito lógico digital e tabela verdade para a seguinte expressão booleana:

C)(BACB S ++=

A B C BC Ā B+C Ā(B+C) S

0 0 0

0 0 1

0 1 0

0 1 1

1 0 0

1 0 1

1 1 0

1 1 1

d) Idem ao exercício anterior para a expressão:

BAC)(BAS ++=

2.4.2. Mapas de Karnaugh

Como se pode constatar, a minimização ou simplificação é imprescindível em um comando digital. Para realizarmos tal tarefa utilizaremos a minimização por mapas de Karnaugh que é um método, uma vez entendido, muito simples.

O método consiste em fazer a minimização a partir de uma tabela da verdade, ou mapa, porém a simplificação é feita sobre um mapa característico chamado mapa de Karnaugh, que contém os mesmos elementos de uma tabela verdade comum, porém com uma distribuição diferente.

Tabela Verdade:

A B C S

0 0 0 0

0 0 1 0

0 1 0 1

0 1 1 1

1 0 0 1

1 0 1 1

1 1 0 0

1 1 1 1

Mapa de Karnaugh:

Obs.: Observe que há uma inversão de seqüência no mapa.

AB C 00 01 11 10

0 0 1 0 1

1 0 1 1 1


46

Podemos observar que no mapa de Karnaugh a combinação para as variáveis A, B e C se obtém pela combinação de uma linha com uma coluna, ou seja, a combinação 0, 0 e 0 se obtém pela combinação da primeira linha com a primeira coluna. Assim, observamos que temos todas as combinações de entrada mostradas na tabela verdade.

Devemos ressaltar que a expressão booleana é escrita a partir da tabela verdade perguntando-se quando obteremos a saída igual a nível 1, ou seja:

C.B.AC.B.AC.B.AC.B.AC.B.AS ++++=

2.4.2.1. Regras para Minimização (Simplificação)

A simplificação consiste em reunir células adjacentes que possuam a mesma saída (1), formando conjuntos denominados de subcubos e obedecendo às seguintes regras:

a) o número de células reunidas deve ser o maior possível, mesmo que para isso uma mesma célula possa pertencer a dois ou mais conjuntos diferentes;

b) o número de células reunidas em um subcubo deve ser sempre potência de 2, ou seja, 1, 2, 4, 8, 16,...;

c) uma mesma célula pode pertencer a subcubos diferentes para satisfazer o item a, mas não fazer agrupamentos desnecessários (pelo menos uma célula tem de pertencer a um subcubo somente) e

d) deve-se formar tantos agrupamentos até que não reste nenhuma saída igual a 1 que não tenha sido agrupada.

A expressão da saída se obtém dos subcubos formados. Cada subcubo define uma função AND entre as variáveis que não mudam de nível lógico dentro do subcubo. Os diversos subcubos obtidos no mapa formam uma função OR.

Voltando ao exemplo anterior e aplicando-se o mapa de Karnaugh, obteremos a seguinte expressão booleana simplificada:

B.AC.AB.AS ++= ou B.AC.BB.AS ++=

Um mapa de Karnaugh para 4 variáveis (A, B, C e D) seria da seguinte forma:

C AB

00 01 11 10

0 0 1 0 1

1 0 1 1 1

C AB

00 01 11 10

0 0 1 0 1

1 0 1 1 1

CD AB

00 01 11 10

00

01

11

10


47

Exercícios:

a) Dado a tabela verdade abaixo, determinar a expressão booleana simplificada por Karnaugh e o circuito digital resultante.

A B C S 0 0 0 1 0 0 1 0 0 1 0 0 0 1 1 0 1 0 0 1 1 0 1 1 1 1 0 0 1 1 1 1

b) Um guindaste deve permitir a elevação de massas compreendidas entre 20 e 80 quilos, pela atuação do motor M (é a nossa saída S). Para isso ele possui uma plataforma repousando sobre molas. De acordo com o peso das cargas a elevar, três sensores de carga (A, B e C) são atuados. As condições de funcionamento são as seguintes:

� em vazio o guindaste deve funcionar, isto é, quando nenhum dos sensores é acionado;

� para cargas até 20 Kg, ou seja, 0<peso<20, o guindaste não deve funcionar. Situação em que somente o sensor A está atuado;

� para cargas compreendidas entre 20 e 80 Kg, 20<peso<80, o guindaste deve funcionar, quando os sensores A e B permanecem atuados e

� para cargas superiores a 80 Kg, peso>80, o guindaste não deve funcionar, quando todos os sensores permanecem atuados.

Com base no sistema descrito, determinar:

1) tabela verdade de funcionamento;

2) equação Booleana simplificada por Karnaugh e

3) circuito digital.


48

c) Em um circuito digital eletrônico, utiliza-se um DISPLAY de 7 segmentos (a, b, c, d, e, f, g) para representar os números decimais positivos de um dígito somente. Com base nas informações de posicionamento dos segmentos e tabela de atuação, completar a tabela e montar o circuito lógico digital simplificado que atenda às necessidades decimais.

Dec. A B C D a b c d e f g LED

0 0 0 0 0 1 1 1 1 1 1 0 1 0 0 0 1 0 1 1 0 0 0 0 2 0 0 1 0 1 1 0 1 1 0 1 3 0 0 1 1 1 1 1 1 0 0 1 4 0 1 0 0 5 0 1 0 1 6 0 1 1 0 7 0 1 1 1 8 1 0 0 0 9 1 0 0 1

Obs:

1) Os números que não estão sendo utilizados na codificação ABCD, não interferem no resultado, ou seja, são condições irrelevantes (representados no mapa de Karnaugh por um “X”). Tais condições de irrelevância devem ser utilizadas como sendo nível lógico 0 ou 1, o que irá facilitar nas simplificações.

2) Cada segmento deve ser considerado como uma saída individual do nosso circuito.

Baixe da Midiateca, no Ambiente Virtual de Aprendizagem, o programa mk.exe que resolve Mapas de Karnaugh até 3 variáveis e foi desenvolvido pelo aluno Márcio Henrique da Silva. Este software será útil para a correção dos exercícios propostos.


49

Baixe da Midiateca, no Ambiente Virtual de Aprendizagem, o programa DW20_95.exe, Digital Works versão 2.0 (freeware). Este software é um simulador de circuitos digitais que permite a construção de circuitos com portas lógicas, flip-flops, dispositivos tri-state e memórias. As entradas podem ser implementadas usando chaves, clocks, seqüenciadores e dispositivos de entrada iterativos. As saídas podem ser visualizadas usando LED's, dispositivos de sete segmentos e dispositivos numéricos.

Baixe da Midiateca, no Ambiente Virtual de Aprendizagem, o vídeo ExemploDW.avi. Nele implemento, usando o Digital Works, o circuito digital mostrado no Exercício b do item 2.4.1.2. (Simplificação de Expressões Lógicas), do nosso Guia de Estudo. Este vídeo procura apenas mostrar um exemplo de utilização do software. O programa possui vários componentes e ferramentas que permitem que você construa circuitos digitais mais complexos.

Exercícios:

No Ambiente Virtual de Aprendizagem, na Midiateca, você vai encontrar o arquivo ExercSisDig.doc com uma lista de exercícios para aplicação de Álgebra Booleana e Mapa de Karnaugh.

2.5. Memórias

Existem 2 tipos de memórias:

1. Memória de Massa.

2. Memória Semicondutora.

Os microprocessadores usam dispositivos semicondutores para armazenar programas e dados. Os mais utilizados são:

• RAM (Random Access Memory): memória de acesso aleatório. • ROM (Read Only Memory): memória somente de leitura.

Para expandir o espaço de armazenamento de dados, os sistemas microprocessados usam alguns dispositivos de armazenamento de massa, tais como:

• discos flexíveis (disquetes); • discos rígidos (HDs); • fitas magnéticas; • disco Óptico (CD, DVD).


50

2.5.1. Memória de Massa

São memórias utilizadas para armazenagem de grandes quantidades de informações, ficam externamente à CPU e normalmente requerem dispositivo periférico de interfaceamento.

Todos os discos magnéticos (disquetes, discos rígidos, Zip disk, etc.) são divididos magneticamente em círculos concêntricos chamados trilhas. As trilhas, por sua vez, são divididas em setores. Em cada setor cabem 512 bytes de informação (esse valor é fixo). Dependendo do disco, ele poderá ter uma formatação com um maior número de trilhas e setores. Quanto maior esse número, mais dados o disco poderá armazenar (TORRES, 1999).

Para calcular a capacidade máxima de um disco, você pode utilizar a fórmula abaixo:

Capacidade de armazenamento = número de trilhas x número de setores por trilha x número de faces do disco x 512 bytes.

Um disco formado por 80 trilhas, 18 setores por trilha e possuindo duas faces, terá a capacidade de 1.474.560 bytes ou 1.440 KB. Essa é a formatação utilizada pelo nosso conhecidíssimo disquete de 1.44 MB.

Figura 29 – Disco Magnético.

O termo formatar um disquete ou HD consiste em criar trilhas e setores neles.


51

2.5.2. Memória Semicondutora

São memórias utilizadas para armazenagem de pequenas quantidades de informações, não necessitam de interface com a CPU, têm velocidade elevada em relação à memória de massa (para acesso) e trabalham em blocos para armazenamento de dados.

Há duas classes básicas de memória semicondutoras:

� Memória ROM: Os circuitos de memória ROM só permitem leitura, mas, em compensação, não perdem o conteúdo quando são desligadas, ou seja, não são voláteis. Além disto, as memórias ROM são mais lentas que as memórias RAM.

� Memórias RAM: São rápidas, permitem leitura e escrita, mas, em compensação, o seu conteúdo é perdido sempre que são desligadas, ou seja, são voláteis.

Para o processador, não há diferença entre acessar uma memória RAM ou ROM – a não ser a velocidade, pois a memória ROM é mais lenta do que a RAM.

2.5.2.1. Memória ROM

Memória ROM é um termo genérico utilizado para designar um circuito de memória de leitura somente. Os circuitos de memória ROM podem ser construídos utilizando uma das seguintes tecnologias básicas:

� Mask-ROM: Esse tipo de memória é gravada na fábrica do circuito integrado (CI) e não há como apagarmos ou gravarmos o seu conteúdo. Esse tipo de circuito é fabricado sob encomenda.

� PROM (Programmable ROM): Essa memória é vendida “virgem” e o fabricante do dispositivo que utilizará este circuito se encarrega de fazer a gravação de seu conteúdo. Entretanto, uma vez gravada, não há como apagar ou reprogramarmos o seu conteúdo. A diferença entre esse circuito e o anterior é o local da gravação. Enquanto a Mask-ROM é fabricada já com um conteúdo predefinido (isto é, a gravação é feita na fábrica do circuito), a PROM é gravada pelo fabricante do periférico que utilizará o circuito.

� EPROM (Erasable Programmable ROM): Da mesma forma que a PROM, a EPROM é vendida virgem e deve ser gravada pelo fabricante do dispositivo que a utilizará. Ao contrário dos outros dois tipos, o seu conteúdo pode ser apagado, o que é feito colocando-se o circuito integrado exposto à luz ultravioleta (esse circuito possui uma janela transparente para que o apagamento possa ser feito). Dessa forma, esse circuito pode ser regravado.

� EEPROM (Eletric Erasable Programmable ROM): A EEPROM ou E²PROM é uma EPROM na qual o apagamento não é feito por meio de luz, mas sim por impulsos elétricos. Para ser regravada tem que se selecionar (endereçar) a


52

posição da memória e apagar o que estava gravado anteriormente. Tem baixa velocidade do ciclo de erase e save. Essa tecnologia permite a reprogramação de circuitos sem a necessidade de removê-los.

� Flash-ROM: A Flash-ROM é uma EEPROM que utiliza baixas tensões de apagamento e este é feito em um tempo bem menor (daí o seu nome flash). Há duas diferenças importantes entre uma EEPROM e uma Flash-ROM: o apagamento da Flash-ROM é extremamente rápido e, ao contrário da EEPROM, não é possível reprogramar apenas um único endereço, isto é, quando a memória é apagada, todos os seus endereços são zerados. Na EEPROM é possível apagar o conteúdo de apenas um endereço e reprogramar somente um determinado dado.

Hoje em dia, a ROM da maioria das placas-mãe é formada por um circuito Flash-ROM, permitindo a reprogramação de seu conteúdo via software.

2.5.2.2. Memória RAM

De acordo com o seu elemento de memória é dividida em 2 tipos:

� DRAM (Dynamic RAM): A RAM dinâmica armazena os bits de informação através de minúsculos capacitores: um capacitor carregado equivale a um dado “1” e um capacitor descarregado a um “0”. O capacitor é um elemento muito fácil de ser construído, isto significa que podemos ter muitas células capacitivas em um pequeno espaço físico, ou seja, circuitos pequenos com alta capacidade de armazenamento. Dizemos que a DRAM tem alta densidade de armazenamento.

O grande problema é que, depois de algum tempo, os capacitores se descarregam. Dessa forma, deverá haver períodos de recarga dos capacitores da memória, período chamado refresh. Durante o refresh, a memória geralmente não pode ser acessada. Como conseqüência direta, a memória dinâmica tem uma imposição física para a sua velocidade. Em outras palavras, ela não pode ser mais rápida porque o refresh deve ser efetuado de tempos em tempos (na ordem de alguns milisegundos).

Características da Memória Dinâmica:

� barata;

� fácil integração (muita capacidade em pouco espaço);

� baixo consumo;

� lenta, pois necessita de refresh.

� SRAM (Static RAM): Existe um outro tipo de memória muito mais rápida que a memória dinâmica. Esse tipo de memória – chamada memória estática e geralmente abreviada para SRAM – utiliza, em vez de capacitores, circuitos


53

digitais chamados flip-flops para o armazenamento de cada “0” ou “1”. Esses circuitos armazenam os dados sem a necessidade de nenhum ciclo de refresh.

Esse tipo de memória é bem mais cara e tem baixa densidade de armazenamento, devido aos circuitos serem maiores. Em contrapartida, há uma grande vantagem: velocidade. Como não precisam do ciclo de refresh, as memórias estáticas são extremamente rápidas.

Características da Memória Estática:

� cara;

� difícil integração (pouca capacidade em muito espaço);

� alto consumo;

� rápida.

A principal desvantagem das DRAMs é o fato de que elas não são tão rápidas quando as SRAMs. A principal vantagem está no baixo custo por bit, tornando-as economicamente atrativas.

Com base na situação descrita (custo x velocidade), a solução para esse problema foi a introdução de um pequeno arranjo de memória local, chamado de memória cache, que utiliza a memória rápida SRAM. Para manter o custo do sistema razoável, o tamanho do cache é mantido relativamente baixo em relação à memória principal (DRAM). Memórias cache são utilizadas como um local de armazenamento temporário que pode ser utilizado pela CPU como se fosse a memória do sistema.

Figura 30 – Memórias RAM e Cache.


54

Exercícios:

a) O disco rígido Maxtor 7546AV tem, em seu manual, a indicação “DISCO RÍGIDO DE 546 MB”. Sua geometria é 1.060 cilindros, 16 cabeças (ou faces) e 63 setores por trilha. Está correta a informação do fabricante? Justifique.

b) O disco rígido Maxtor 7850AV possui a indicação “DISCO RÍGIDO DE 850 MB”. Sua geometria é de 1.648 cilindros, 16 cabeças e 63 setores. Está correta a informação do fabricante? Justifique.

c) Defina cada um dos termos a seguir relacionados a memórias: 1 – RAM 2 – ROM 3 – Capacidade 4 – Volatilidade 5 – Densidade 6 - Geometria 7 – Leitura 8 – Escrita

d) Quais são os três barramentos existentes em um sistema de memória de computador?

e) Qual barramento é usado pela CPU para selecionar uma posição de memória?

f) Qual barramento é usado para transportar dados da memória para a CPU durante uma operação de leitura?

g) Quem fornece os dados para o barramento de dados durante uma operação de escrita?


55

3. MICROPROCESSADORES

A velocidade da evolução da informática poderia levar a crer que a tarefa do professor de uma disciplina que estuda o funcionamento dos microprocessadores seria a de atualizar continuamente o material apresentado aos alunos, para que estes ficassem a par das constantes inovações tecnológicas. Porém, esta idéia não resiste, porém, a uma análise mais profunda. Os conceitos fundamentais que norteiam o funcionamento dos microprocessadores são mais importantes do que os últimos lançamentos da indústria, porque não mudam e sempre serão úteis. Por esta razão, o material aqui contido procura valorizar os conceitos independentes da inovação tecnológica.

A finalidade é fazer com que os alunos, ao concluírem a disciplina, entendam o funcionamento de microprocessadores.

O conteúdo a ser apresentado deve ser entendido como um guia para aqueles que pretendem se aprofundar em livros específicos sobre um determinado processador ou que irá cursar uma especialização nessa direção. A densidade da exposição de cada assunto está num formato apropriado para o curso de graduação. À medida que se avançam os tópicos, o aluno, gradualmente, irá adquirindo capacidades básicas para trabalhar em um projeto profissional.

3.1. O Microprocessador SAP-1

O SAP-1 (Simples-Quanto-Possível = Simple-As-Possble) é o primeiro estágio na evolução com vistas aos modernos computadores (MALVINO, 1985).

O SAP-1 é um microprocessador que possui 8 bits para dados e 4 bits para endereçamento.

3.1.1. Definição dos Blocos do SAP-1

� PC → Contador de Programa. Aponta o endereço da próxima instrução a ser executada;

� REM → Registrador de Endereços da Memória. Armazena temporariamente o endereço da instrução a ser executada;

� RAM → Área de memória onde estará o programa executável. Não faz parte do conjunto, ou seja, fica fora do microprocessador;

� RI → Registrador de Instrução. Armazena o código da instrução a ser executada;


56

� C/S → Controlador/Sequencializador. Responsável pela temporização e geração das linhas de controle do microprocessador;

� Acumulador (A) → Registrador;

� Somador/Subtrator → Responsável pelas operações aritméticas;

� Registrado B → Registrador;

� Registrado de Saída → Registra temporariamente os dados de saída;

� Display → Indicação visual, não faz parte do conjunto.

Pelo diagrama de bloco, podemos verificar os 12 sinais de controle e sua designação:

� L → LOAD: carrega o registrador;

� E → ENABLE: habilita saída do registrador;

� Su → Determina o tipo de operação da ULA (1 = subtração e 0 = adição);

� Cp → Prepara o contador de programa para contar, nas transições positivas do clock, para que ele possa ler a próxima instrução;

� CE → Disponibiliza a informação da RAM para o barramento.


57

3.1.2. Diagrama em Blocos

Figura 31 – Diagrama em Blocos do SAP-1.

A execução de uma instrução é dividida em 2 etapas (ciclos):

� Ciclo de Busca: consiste na leitura do código da instrução armazenada na RAM e armazenamento deste código no RI e

� Ciclo de Execução: consiste na execução da instrução armazenada no RI.

No SAP-1, o tempo do ciclo de busca e do ciclo de execução são equivalentes a 3 períodos de clock, portanto, o ciclo de instrução tem 6 períodos. No SAP-1, o clock é sensível à borda de descida e o microprocessador é sempre resetado no início do processamento, iniciando sempre do endereço 0000 da memória.

3.1.3. Conjunto de Instruções do SAP-1

Um computador é um amontoado inútil de hardware até que alguém o programe. Isto significa o carregamento de instruções passo-a-passo na memória antes do início de


58

um processamento no computador. Antes que possamos programar um computador, no entanto, devemos aprender seu conjunto de instruções, as operações básicas que ele pode executar (MALVINO, 1985). Segue-se o conjunto de instruções do SAP-1.

� LDA - LDA significa “carregar o acumulador” (Load the Accumulator). Esta instrução carrega o acumulador (registrador A) com o conteúdo da RAM do endereço (em hexadecimal) indicado.

LDA 8H, por exemplo, significa “carregar o acumulador com o conteúdo do local 8H da memória”. Assim como LDA FH significa “carregar o acumulador com o conteúdo do local FH da memória”.

� ADD - Soma ao acumulador (A) o conteúdo da RAM do endereço indicado. Uma instrução ADD completa inclui o endereço do número a ser acrescentado.

ADD 9H significa “acrescentar o conteúdo do local 9H da memória ao conteúdo do acumulador”, a soma substitui o conteúdo original do acumulador.

� SUB - Subtrai do acumulador (A) o conteúdo da RAM do endereço indicado. Uma instrução SUB completa inclui o endereço do número a ser subtraído.

SUB CH significa “subtrair o conteúdo do local CH da memória do conteúdo do acumulador”; a diferença é colocada para fora do Somador/Subtrator e depois substitui o conteúdo original do acumulador.

� OUT - Coloca o conteúdo do acumulador (A) no registrador de saída (RS) e conseqüentemente o resultado aparecerá no display. Depois de OUT ter sido executada, podemos ver a resposta ao problema que está sendo resolvido.

OUT é completa por si própria, isto é, não temos que incluir um endereço quando usamos OUT, porque a instrução não envolve dados da memória.

� HLT - HLT significa parar (halt). Esta instrução finaliza a execução de um programa, ou seja, diz ao computador para parar o processamento de dados. Devemos usar uma instrução HLT no fim de cada programa do SAP-1; do contrário, obtemos refugos (trash) no computador (respostas sem significado causadas pelo processamento descontrolado).


59

HLT é completa por si própria; não temos que incluir um endereço quando usamos HLT, porque a instrução não envolve dados da memória.

Instruções de Referência à Memória

LDA, ADD e SUB são chamadas instruções de referência à memória, porque elas usam dados armazenados na memória. OUT e HLT, por outro lado, não são instruções de referência à memória, porque elas não envolvem dados armazenados na memória.

Mnemônicos

LDA, ADD, SUB, OUT e HLT são o conjunto de instruções do SAP-1. Instruções abreviadas como estas são chamadas mnemônicos (auxílios à memória). Mnemônicos são conhecidos no trabalho dos computadores, porque eles nos lembram da operação que ocorrerá quando a instrução for executada. A Tabela 11 resume o conjunto de instruções do SAP-1.

Mnemônicos Operação

LDA Carregue os dados da RAM no acumulador. ADD Some os dados da RAM com o acumulador. SUB Subtraia os dados da RAM do acumulador. OUT Carregue os dados do acumulador no registrador de saída.

HLT Pare o processamento. Tabela 11 – Conjunto de Instruções do SAP-1.

Eis aqui um programa do SAP-1 em forma de mnemônico:

Endereço Mnemônicos

0H LDA 9H 1H ADD AH 2H ADD BH 3H SUB CH 4H OUT 5H HLT

Os dados na memória superior são: Endereço Mnemônicos

6H FFH 7H FFH


60

8H FFH 9H 01H AH 02H BH 03H CH 04H DH FFH EH FFH FH FFH

O que faz cada instrução?

O programa está na memória inferior, localizado nos endereços 0H a 5H. A primeira instrução carrega o acumulador com o conteúdo do local 9H da memória, e assim o conteúdo do acumulador torna-se

A = 01H.

A segunda instrução soma o conteúdo do local AH da memória ao conteúdo do acumulador para produzir um novo total do acumulador de

A = 01H + 02H = 03H.

Similarmente, a terceira instrução soma o conteúdo do local BH da memória

A = 03H + 03H = 06H.

A instrução SUB subtrai o conteúdo do local CH da memória para produzir

A = 06H – 04H = 02H.

A instrução OUT carrega o conteúdo do acumulador para a porta de saída; portanto, o display mostra o número

2.

A instrução HLT interrompe o processamento dos dados.


61

3.1.4. Programação do SAP-1

Para carregar palavras de dados e instruções da memória do SAP-1, temos que usar alguma espécie de código que o computador possa interpretar. A Tabela 12 mostra o código usado no SAP-1. O número 0000 significa LDA, 0001 significa ADD, 0010 significa SUB, 1110 significa OUT e 1111 significa HLT. Em virtude de este código dizer ao computador que operação executar, ele é chamado código de operação (op code).

Mnemônicos Código op

LDA 0000 ADD 0001 SUB 0010

OUT 1110 HLT 1111

Tabela 12 – Códigos de Operação do SAP-1.

Suponhamos que queremos armazenar as seguintes instruções:

Endereço Mnemônicos 0H LDA FH 1H ADD EH 2H HLT

Primeiro, convertemos cada instrução em binário como segue:

Instrução Instrução em Binário LDA FH 0000 1111 ADD EH 0001 1110 HLT 1111 XXXX

Na primeira instrução, 0000 é o código op de LDA e 1111 é o equivalente binário de FH. Na segunda instrução, 0001 é o código op de ADD e 1110 é o equivalente binário de EH. Na terceira instrução, 1111 é o código op de HLT e XXXX são saídas irrelevantes, porque a HLT não é uma instrução de referência da memória.

A linguagem de montagem (Assembly language) envolve o trabalho com mnemônicos quando se escreve um programa. A linguagem de máquina envolve o trabalho com 0s e 1s.


62

Traduzir o programa do exemplo do item 3.1.3. em linguagem de máquina do SAP-1.

Endereço Mnemônicos 0H LDA 9H 1H ADD AH 2H ADD BH 3H SUB CH 4H OUT 5H HLT

Este programa está em linguagem de montagem, para obtê-lo em linguagem de máquina, nós o traduzimos em 0s e 1s conforme segue:

Endereço Mnemônicos 0000 0000 1001 0001 0001 1010 0010 0001 1011 0011 0010 1100 0100 1110 XXXX 0101 1111 XXXX

Agora o programa está em linguagem de máquina.

Os quatro MSBs de uma instrução em linguagem de máquina SAP-1 especificam a operação, e os quatro LSBs dão o endereço. Às vezes nós nos referimos aos MSBs como o campo de instrução e os LSBs como o campo de endereço. Simbolicamente,

Instrução = XXXX XXXX

Campo de instrução

Campo de endereço

3.1.5. Análise do Diagrama Temporal (Fasorial)

A fim de facilitar nossa compreensão, iremos estudar o diagrama fasorial para instrução LDA.

T1 →→→→ Habilita Ep do Contador de Programa (PC) e coloca seu conteúdo no

barramento. Habilita Lm e o que está no barramento vai para REM, na descida do clock.

Portanto, em T1, temos Ep = 1 e Lm = 0.

T2 →→→→ Habilita Cp . Na descida do clock, o PC irá apontar para o endereço 0000 + 1, ou seja, incrementa de uma unidade binária o PC.


63

Portanto, em T2, Cp = 1.

T3 →→→→ Habilita CE e Li . Ao final de T3, temos RI com a instrução que a RAM liberou no barramento (fim do ciclo de busca).

Logo, em T3, CE = 0 e Li = 0.

T4 →→→→ Habilita Ei e Lm endereça a memória. O C/S recebe a instrução a ser executada gerando os sinais de controle necessários.

T5 →→→→ Habilita CE e La . Na descida do clock, o conteúdo da RAM vai para A.

T6 →→→→ NOP - Nenhuma operação a executar, ou seja, todos os sinais de controle recebem pulsos que os desabilitam.

� Os tempos T1, T2 e T3 são idênticos para todas as operações da SAP-1, pois consiste no ciclo de busca da instrução.

� Em um dado de 8 bits, temos XXXX YYYY, onde X = instrução e Y = endereço.

� Vale lembrar, da eletrônica digital, que 1 = ativo e 0 = desativo, mas, se tivermos a indicação de sinal barrado, o raciocínio é oposto.

Fazer a análise temporal e montar a tabela RAM para a execução no SAP-1 da seguinte equação:

17 - 12 + 5 + 9 Os dados da equação serão armazenados, respectivamente, nos endereços EH, DH, CH e BH.

Solução:

� O primeiro passo é converter os números para hexadecimal:

17 - 12 + 5 + 9 ⇒⇒⇒⇒ 11H - CH + 5H + 9H

� Em seguida devemos preencher a tabela que representa a memória

RAM do SAP-1:

Endereço Endereço Instrução Instrução


64

em Binário em Binário 0H 0000 LDA EH 0000 1110 1H 0001 SUB DH 0010 1101 2H 0010 ADD CH 0001 1100 3H 0011 ADD BH 0001 1011 4H 0100 OUT 1110 xxxx 5H 0101 HLT 1111 xxxx 6H 0110 7H 0111 8H 1000 9H 1001 AH 1010 BH 1011 09H 0000 1001 CH 1100 05H 0000 0101 DH 1101 0CH 0000 1100 EH 1110 11H 0001 0001 FH 1111

� Análise temporal: Instrução LDA EH T1 → H0REM0Lm;1Ep =⇒== T2 → H1PC1Cp =⇒=

T3 → EHLDARI0Li;0CE =⇒==

T4 → EHREM0Lm;0Ei =⇒==

T5 → H11A0La;0CE =⇒== T6 → NOP Instrução SUB DH T1 → H1REM0Lm;1Ep =⇒== T2 → H2PC1Cp =⇒=

T3 → DHSUBRI0Li;0CE =⇒==

T4 → DHREM0Lm;0Ei =⇒==

T5 → CH0B0Lb;0CE =⇒==

T6 → H05A0La;1Eu;1SU =⇒=== Instrução ADD CH T1 → H2REM0Lm;1Ep =⇒== T2 → H3PC1Cp =⇒=


65

T3 → CHADDRI0Li;0CE =⇒==

T4 → CHREM0Lm;0Ei =⇒==

T5 → H05B0Lb;0CE =⇒==

T6 → AH0A0La;1Eu;0SU =⇒=== Instrução ADD BH T1 → H3REM0Lm;1Ep =⇒== T2 → H4PC1Cp =⇒=

T3 → BHADDRI0Li;0CE =⇒==

T4 → BHREM0Lm;0Ei =⇒==

T5 → H09B0Lb;0CE =⇒==

T6 → H13A0La;1Eu;0SU =⇒=== Instrução OUT T1 → H4REM0Lm;1Ep =⇒== T2 → H5PC1Cp =⇒=

T3 → OUTRI0Li;0CE =⇒==

T4 → H13RS0LO;1EA =⇒== T5 → NOP T6 → NOP Instrução HLT T1 → H5REM0Lm;1Ep =⇒== T2 → H6PC1Cp =⇒=

T3 → HLTRI0Li;0CE =⇒== T4 → NOP T5 → NOP T6 → NOP


66

Exercícios:

a) Descreva os tempos de instrução (T1 a T6) e monte a tabela da RAM para um programa com as seguintes instruções LDA CH, ADD 7H, SUB AH, OUT e HLT. Sabendo-se que os endereços possuem os seguintes dados: CH=01000010(2), 7H=01000000(2) e AH=00010010(2).

b) Sabendo-se que os endereços AH, BH e CH contém 70, 48 e 08 respectivamente. Descrever os tempos das instruções abaixo e qual será o valor do display.

LDA AH SUB BH ADD CH OUT HLT

c) Fazer um programa para que o SAP-1 execute a seguinte operação decimal:

5 + 4 + 3 - 6 - 2

Usar os endereços BH, CH, DH, EH e FH para os dados, respectivamente.

Construa a tabela RAM do programa em binário.

d) Em uma tabela RAM, temos, na primeira linha, a seguinte instrução LDA 6H e, na linha 6H, temos 70 como conteúdo. Qual será o conteúdo da REM em T4 para a instrução SUB AH se esta instrução estiver na linha 3 da tabela RAM?

e) De quantas unidades podemos dizer que são constituídos um microprocessador? Com base nesta informação quais são os blocos da SAP-1 que não pertencem à CPU?

f) Cite quais são os blocos do SAP-1 que trabalham exclusivamente com os barramentos de endereço e controle.

Baixe da Midiateca, no Ambiente Virtual de Aprendizagem, o programa Install_SAP1.zip. Este programa é um simulador do microprocessador SAP-1 desenvolvido por mim e por meu colega William. Entrando com a expressão desejada, o software preenche a tabela RAM, simula a execução das instruções passo-a-passo e mostra a análise temporal.


67

Baixe da Midiateca, no Ambiente Virtual de Aprendizagem, o vídeo SAP1.avi. Nele mostro um exemplo de utilização do simulador de SAP-1. Faço o exemplo do item 3.1.5. (Análise do Diagrama Temporal) do nosso Guia de Estudo.

Exercícios:

No Ambiente Virtual de Aprendizagem, na Midiateca, você vai encontrar o arquivo ExercSAP1.doc com uma lista de exercícios sobre o microprocessador SAP-1.

3.2. O Microprocessador SAP-2

O SAP-1 é um computador, porque ele, primeiramente, armazena um programa e os dados antes de começar os cálculos e, então, executa automaticamente as instruções do programa sem a intervenção humana. E, também, o SAP-1 é uma máquina primitiva. Ele se compara com o computador moderno da mesma forma que o homem das cavernas se compara com o homem moderno. Algo está ausente nele, algo que pode ser encontrado em qualquer computador moderno.

O SAP-2 é o próximo passo da evolução em direção ao computador moderno, porque inclui instruções de salto. Estas novas instruções obrigam o computador a repetir ou omitir partes de um programa. Como você verá, as instruções de salto abrem as portas para toda uma nova capacidade computacional (MALVINO, 1985).

3.2.1. Definição dos Blocos do SAP-2

� Portas de Entradas → O SAP-2 tem 2 portas de entrada, numeradas com 1 e 2. Um codificador hexadecimal de teclado está ligado à porta 1. Ele nos permite dar entrada a dados e instruções hexadecimais através da porta 1.

� PC → Contador de Programa. Desta vez, ele possui 16 bits, portanto ele pode endereçar de 0000H a FFFFH, ou seja, de 0 a 65.535, em decimal.

� REM → Registrador de Endereços da Memória.

� RAM → Área de memória onde estará o programa executável. Esta memória está dividida em 2 blocos: uma ROM de 2K com endereços de 0000H a 07FFH. Esta ROM contém um programa, o monitor, que inicializa o computador ao ser ligado; interpreta as entradas do teclado e assim por diante. O restante da memória é uma RAM de 62K com endereços de 0800H a FFFFH.


68

� Registrador de Dados de Memória (MDR) → É um registrador buffer de 8 bits. A sua saída alimenta a RAM. O MDR recebe dados do barramento antes de uma operação de escrita e envia dados para o barramento depois de uma operação de leitura.

� RI → Registrador de Instrução. Como o SAP-2 tem mais instruções que o SAP-1, usaremos 8 bits, em vez de 4, para o código de operação. Um código de operação de 8 bits pode acomodar 256 instruções e o SAP-2 possui 43 instruções.

� C/S → Controlador/Sequencializador. Responsável pela temporização e geração das linhas de controle do microprocessador. Como o SAP-2 tem um repertório de instruções maior, o controlador/sequencializador tem mais hardware.

� Acumulador (A) → Registrador.

� ULA e Flags → A ULA é a responsável pelas operações lógicas e aritméticas. Já o flag é um flip-flop (uma célula de memória que armazena 1 bit) que informa sobre uma condição variável durante a execução de um programa. O SAP-2 tem 2 flags, o flag de sinal (S) que é setado quando o conteúdo do acumulador torna-se negativo durante a execução de algumas instruções, e o flag de zero (Z) que é setado quando o conteúdo do acumulador torna-se zero.

� Registradores TMP, B e C → Em vez de usar o registrador B para guardar o dado que está sendo adicionado ou subtraído do acumulador, usa-se um registrador temporário (TMP). Isto nos traz maior liberdade ao usar o registrador B. Além destes registradores, também temos o registrador C, o que nos dá uma maior flexibilidade ao mover dados durante uma execução do programa.

� Portas de Saída → O SAP-2 tem 2 portas de saída numeradas 3 e 4. O conteúdo do acumulador pode ser carregado na porta 3, que alimenta um display hexadecimal, ou para porta 4.


69

3.2.2. Diagrama em Blocos

Figura 32 – Diagrama em Blocos do SAP-2.


70

3.2.3. Instruções do SAP-2

3.2.3.1. Instruções com Referência à Memória

O ciclo de busca do SAP-2 é o mesmo de antes. Portanto, todas as instruções do SAP-2 usam a memória durante o ciclo de busca, porque toda instrução é transferida da memória para o registrador de instrução.

Durante o ciclo de execução, entretanto, a memória pode ou não ser usada dependendo do tipo de instrução que foi buscada. Uma instrução de referência à memória (IRM) é aquela que usa a memória durante o ciclo de execução.

� LDA e STA - LDA tem o mesmo significado de antes, carregar o acumulador com o dado endereçado na memória. A única diferença está no fato de termos de especificar um endereço maior de memória. Para se distinguir as diferentes partes de uma instrução, o mnemônico é chamado de código de operação e o restante da instrução é conhecido como operando.

STA (Store Accumulator) é um mnemônico para armazenar o acumulador. Todas as instruções STA necessitam de um endereço.

LDA 2000H significa carregar o acumulador com o conteúdo da posição 2000H na memória. LDA é o código de operação e 2000H é o operando.

A instrução STA 7FFFH significa armazenar o conteúdo do acumulador no endereço 7FFFH da memória.

3.2.3.2. Instruções de Registradores

As instruções com referência à memória são relativamente lentas, porque necessitam de mais de um acesso à memória durante o ciclo de instrução. Além disso, seguidamente queremos transferir dados de um registrador para outro sem ter de passar pela memória.

� MVI – (Move Immediate) é o mnemônico para mova imediato. Esta instrução diz para o computador carregar um registrador indicado com o byte que sucede imediatamente o código de operação.

Você pode usar a instrução MVI com os registradores A, B e C. Os formatos destas instruções são:

MVl A,byte MVI B,byte

MVI C,byte


71

MVl A,37H - diz para o computador carregar o acumulador com 37H. Depois da execução desta instrução, o conteúdo do acumulador será:

A = 0011 0111.

� MOV – (Move) é o mnemônico de mova. Esta instrução diz para o computador mover dados de um registrador para o outro.

Você pode mover dados entre os registradores A, B e C. Os formatos de todas as instruções MOV são:

MOV A,B MOV A,C

MOV B,A MOV B,C

MOV C,A MOV C,B

MOV A,B - diz para o computador mover o conteúdo do registrador B para o acumulador. O conteúdo de B é copiado sem ser destruído. Por exemplo, se:

A = 34H e B = 9DH,

então a execução de MOV A,B resulta em:

A = 9DH e B = 9DH.

� ADD e SUB – ADD significa adicionar o conteúdo do registrador designado ao acumulador. De maneira parecida, a instrução SUB significa subtrair o conteúdo do registrador designado do acumulador.

Os formatos das instruções ADD e SUB são:

ADD B SUB B

ADD C SUB C

ADD B – significa adicionar o conteúdo do registrador B ao acumulador. Se:

A = 04H e B = 02H,

então a execução de ADD B resulta em:

A = 06H.

� INR e DCR – muitas vezes, desejamos incrementar ou decrementar o conteúdo de um dos registradores. INR é o código de operação para incrementar, e DCR é o código de operação para decrementar.

Os formatos destas instruções são:


72

INC A DCR A

INC B DCR B

INC C DCR C

Se: B = 56H e C = 8AH,

então a execução das instruções INR B e DCR C resultam em:

B = 57H e C = 89H.

3.2.3.3. Instruções de JUMPS (Saltos)

O SAP-2 possui três instruções de jump que podem alterar a seqüência de instruções dentro do programa, ou seja, em vez de buscar a próxima instrução da maneira usual (seqüencial), o microprocessador pode saltar ou desviar para uma outra parte do programa. Estes saltos podem ser condicionais (que dependem de uma dada condição) ou incondicionais (irão executar o salto independentemente de qualquer coisa).

� JMP (incondicional) – salta para o endereço especificado. Toda instrução JMP inclui um endereço que é carregado no contador de programa.

JMP 3000H – diz ao computador para buscar a próxima instrução na posição 3000H de memória.

� CALL e RET (incondicional) – uma sub-rotina é um programa armazenado na memória para um possível uso num outro programa. Muitos microprocessadores têm sub-rotinas para cálculo de senos, co-senos, tangentes, etc.

CALL (chamar) é um código de operação para chamar sub-rotina. Toda instrução CALL deve incluir o endereço inicial da sub-rotina desejada bem como deve ser finalizada com a instrução RET (retornar). Caso você esqueça de colocar a instrução RET ao final de uma sub-rotina, o microcomputador não poderá voltar ao ponto original e você acabará obtendo entulho em seu programa. Uma


73

observação importante é que a instrução RET retorna a primeira instrução logo após o CALL que lhe deu origem.

CALL 5000H – envia o computador para a sub-rotina localizada na posição 5000H de memória.

� JM (condicional) – o SAP-2 tem dois flags o de sinal (S) e o de zero (Z). Durante a execução de algumas instruções, estes flags serão setados ou zerados dependendo do que acontece com o conteúdo dos registradores em execução. Se o conteúdo do registrador se tornar negativo, o flag de sinal será setado, se não, será zerado, ou seja:

JM é uma instrução de salto (Jump if Minus). O microprocessador saltará para o endereço designado somente se o flag de sinal estiver setado (S=1). Se a condição de saltar não for verdadeira (S=0), a seqüência de execução das linhas de programa permanecerá inalterada.


74

JM 3000H – se S=1, esta instrução desvia a execução do programa para o endereço 3000H. Se a condição de saltar não for verdadeira (S=0), a próxima instrução a ser executada será a do endereço 2004H.

� JZ (condicional) – (Jump if Zero) funciona de maneira similar à instrução JM. Aqui teremos um salto em função do flag zero (Z). Este flag é setado toda vez que o resultado do registrador em execução se tornar zero durante a execução de alguma instrução.

Os flags de Zero (Z) e de Sinal (S) são alterados todas as vezes que se utiliza uma instrução que os afete, vide Tabela 13 (Conjunto de Instruções do SAP-2).

� JNZ (condicional) – significa saltar se não zero (Jump if Not Zero). Ela manda o microprocessador saltar para o endereço designado apenas quando o flag de zero estiver zerado (Z=0), quando o flag zero estiver setado (Z=1), não haverá o salto.

JM, JZ e JNZ são instruções de salto condicional, porque o salto no programa ocorre apenas quando certas condições estão satisfeitas. Por outro lado, JMP e CALL são incondicionais, porque depois que a instrução for buscada, o ciclo de execução sempre fará o programa pular para o endereço especificado.


75

3.2.3.4. Instruções Lógicas

Um microprocessador pode fazer operações lógicas tanto como aritméticas. A seguir, temos as instruções lógicas do SAP-2.

� CMA – Complementar o Acumulador. A execução de uma CMA inverte ou nega cada um dos bits do acumulador produzindo o complemento de 1.

� ANA – (AND Acumulador) significa fazer uma operação AND com o Acumulador juntamente com o conteúdo de um registrador, o qual deverá ser designado.

Você pode usar a instrução ANA com os registradores B e C. Os formatos destas instruções são:

ANA B ANA C

Se A = 66H e B = F1H uma operação ANA B resultará em A = 60H, ou seja:

inicialmente A = 0110 0110

B = 1111 0001. Realizando uma operação AND,

teremos A = 0110 0000 = 60H.

� ORA – (OR Acumulador) significa fazer a operação lógica OR no acumulador juntamente com o registrador indicado.

Você pode usar a instrução ORA com os registradores B e C. Os formatos destas instruções são:

ORA B ORA C

Utilizando o mesmo exemplo da instrução ANA, teremos:

A = 1111 0111 = F7H.

� XRA – (XOR Acumulador) realizar a operação XOR com acumulador juntamente com o registrador especificado.

Você pode usar a instrução XRA com os registradores B e C. Os formatos destas instruções são:

XRA B XRA C

Utilizando o mesmo exemplo da instrução ANA, teremos:

A = 1001 0111 = 97H.


76

� ANI – (AND Imediato) o SAP-2 também apresenta instruções lógicas imediatas. ANI manda fazer a operação AND entre o conteúdo do acumulador e o byte que sucede imediatamente o código de operação. O seu formato é:

ANI byte.

Para A = 0101 1110, se realizarmos ANI C7H, teremos:


byte = 1100 0111,

teremos A = 0100 0110 = 46H.

� ORI – (OR Imediato) irá resultar em uma operação OR entre o conteúdo do acumulador e o byte que foi especificado na instrução. O seu formato é:

ORI byte.

Para A = 0011 1000, se realizarmos ORI 5AH, teremos:


byte = 0101 1010,

teremos A = 0111 1010 = 7AH.

� XRI – (XOR Imediato) produzirá uma operação de XOR entre o conteúdo do acumulador e o byte especificado no código de operação. O seu formato é:

XRI byte.

Para A = 0001 1100, se realizarmos XRI D4H, teremos:


byte = 1101 0100,

teremos A = 1100 1000 = C8H.

3.2.3.5. Outras Instruções

Iremos estudar agora o restante das instruções do SAP-2. Como tais instruções não pertencem a nenhum grupo já estudado, elas foram reunidas aqui formando um grupo à parte.

� NOP – significa não operar. Durante a execução de uma NOP, todos os estados T não fazem nada. Portanto, não ocorre nenhuma alteração nos registradores, ou


77

seja, esta operação gera somente um retardo de tempo que irá ser determinado pelo clock do sistema. Isto é útil em operações de temporização.

Se colocarmos um NOP dentro de um laço de repetição que será executado 100 vezes, nós criaremos um retardo de tempo de 400 estados T.

� HLT – como já estudado no SAP-1, aqui ele também encerra o processamento dos dados.

� OUT – quando esta instrução é usada, o conteúdo do acumulador é carregado na porta de saída indicada. Como há duas portas numeradas 3 e 4 (conforme diagrama de blocos), você terá que especificar qual será usada. O seu formato é:

OUT byte.

OUT 03H irá transferir o conteúdo do acumulador para a porta 3.

� IN – é uma instrução de entrada (input). Ela manda o computador transferir dados de uma porta designada para o acumulador. Como há duas portas, você terá de indicar qual está sendo usada. O formato da instrução é:

IN byte.

IN 02H significa transferir os dados da porta 2 para o acumulador.

� RAL – é uma instrução para rotacionar o conteúdo do acumulador para a esquerda (Rotate the Accumulator to Left). Esta instrução deslocará todos os bits do acumulador para a esquerda além de mover o bit mais significativo (MSB) para a posição do bit menos significativo (LSB).

Para A = 1011 0100, um RAL dará 0110 1001.


78

� RAR – esta instrução provocará uma rotação para direita no conteúdo do acumulador (Rotate the Accumulator to Right). Desta vez, os bits do acumulador se deslocam para a direita e o bit menos significativo (LSB) vai para a posição do bit mais significativo (MSB).

A instrução RAR dará A = 0101 1010, para o exemplo anterior.

3.2.4. Conjunto de Instruções do SAP-2

Instrução Código Hexadec.

Estados T

Flags Afetados

Bytes Efeito Principal

ADD B 80 4 S, Z 1 A ⇐⇐⇐⇐ A + B

ADD C 81 4 S, Z 1 A ⇐⇐⇐⇐ A + C

ANA B A0 4 S, Z 1 A ⇐⇐⇐⇐ A and B

ANA C A1 4 S, Z 1 A ⇐⇐⇐⇐ A and C

ANI byte E6 7 S, Z 2 A ⇐⇐⇐⇐ A and byte

CALL ender. CD 18 Nenhum 3 Chama sub-rotina

CMA 2F 4 Nenhum 1 A ⇐⇐⇐⇐ Ā

DCR A 3D 4 S, Z 1 A ⇐⇐⇐⇐ A – 1

DCR B 05 4 S, Z 1 B ⇐⇐⇐⇐ B – 1

DCR C 0D 4 S, Z 1 C ⇐⇐⇐⇐ C – 1

HLT 76 5 Nenhum 1 Fim do programa

IN byte DB 10 Nenhum 2 A ⇐⇐⇐⇐ byte

INR A 3C 4 S, Z 1 A ⇐⇐⇐⇐ A + 1

INR B 04 4 S, Z 1 B ⇐⇐⇐⇐ B + 1

INR C 0C 4 S, Z 1 C ⇐⇐⇐⇐ C + 1

JM ender. FA 10 / 7 Nenhum 3 Salta se S = 1

JMP ender. C3 10 Nenhum 3 Salta

JNZ ender. C2 10 / 7 Nenhum 3 Salta se Z = 0


79

JZ ender. CA 10 / 7 Nenhum 3 Salta se Z = 1

LDA ender. 3A 13 Nenhum 3 A ⇐⇐⇐⇐ Myyyy

MOV A, B 78 4 Nenhum 1 A ⇐⇐⇐⇐ B

MOV A, C 79 4 Nenhum 1 A ⇐⇐⇐⇐ C

MOV B, A 47 4 Nenhum 1 B ⇐⇐⇐⇐ A

MOV B, C 41 4 Nenhum 1 B ⇐⇐⇐⇐ C

MOV C, A 4F 4 Nenhum 1 C ⇐⇐⇐⇐ A

MOV C, B 48 4 Nenhum 1 C ⇐⇐⇐⇐ B

MVI A, byte 3E 7 Nenhum 2 A ⇐⇐⇐⇐ byte

MVI B, byte 06 7 Nenhum 2 B ⇐⇐⇐⇐ byte

MVI C, byte 0E 7 Nenhum 2 C ⇐⇐⇐⇐ byte

NOP 00 4 Nenhum 1 Retardo

ORA B B0 4 S, Z 1 A ⇐⇐⇐⇐ A or B

ORA C B1 4 S, Z 1 A ⇐⇐⇐⇐ A or C

ORI byte F6 7 S, Z 2 A ⇐⇐⇐⇐ A or byte

OUT byte D3 10 Nenhum 2 Porta byte ⇐⇐⇐⇐ A

RAL 17 4 Nenhum 1 A ⇐⇐⇐⇐ Rotação à esq.

RAR 1F 4 Nenhum 1 A ⇐⇐⇐⇐ Rotação à dir.

RET C9 10 Nenhum 1 Retorno ao CALL

STA ender. 32 13 Nenhum 3 Myyyy ⇐⇐⇐⇐ A

SUB B 90 4 S, Z 1 A ⇐⇐⇐⇐ A – B

SUB C 91 4 S, Z 1 A ⇐⇐⇐⇐ A – C

XRA B A8 4 S, Z 1 A ⇐⇐⇐⇐ A xor B

XRA C A9 4 S, Z 1 A ⇐⇐⇐⇐ A xor C

XRI byte EE 7 S, Z 2 A ⇐⇐⇐⇐ A xor byte

Tabela 13 – Conjunto de Instruções do SAP-2.


80

a) Mostre os mnemônicos necessários para somar os números decimais 23 e 45. A resposta deve ser armazenada na posição 5600H de memória. Além disto, a resposta incrementada de uma unidade deve ser armazenada no registrador C.

Solução:

Os números decimais 23 e 45 são equivalentes a 17H e 2DH. Aqui está um programa capaz de realizar esta tarefa:

Mnemônicos Comentários MVI A, 17H - move imediatamente o número hexadecimal

17H para o registrador A.

MVI B, 2DH - move imediatamente o número hexadecimal 2DH para o registrador B.

ADD B - adiciona B em A.

STA 5600H - move o conteúdo do acumulador A para a posição de memória 5600H.

INR A - incrementa em uma unidade o conteúdo do acumulador A.

MOV C, A - move o conteúdo do acumulador A para o registrador C.

HLT - indica o fim do programa.

b) Montar manualmente um programa significa traduzir um programa fonte num programa de máquina à mão em vez de usar uma máquina. Monte manualmente o programa do exemplo anterior no endereço 2000H.

Endereço Conteúdo Simbólico 2000H 3EH MVI A, 17H

2001H 17H

2002H 06H MVI B, 2DH

2003H 2DH

2004H 80H ADD B

2005H 32H STA 5600H

2006H 00H

2007H 56H

2008H 3CH INR A

2009H 4FH MOV C, A 200AH 76H HLT

Observe que as instruções ADD, INR, MOV e HLT são de 1 byte; as instruções MVI são de 2 bytes e a instrução STA, de 3 bytes.


81

c) Faça a montagem manual do seguinte programa que inicia no endereço 2000H.

Mnemônicos MVI C, 03H

DCR C

JZ 2009H

JMP 2002H

HLT

Solução:

Endereço Conteúdo Simbólico

2000H 0EH MVI C, 03H

2001H 03H

2002H 0DH DCR C

2003H CAH JZ 2009H

2004H 09H

2005H 20H

2006H C3H JMP 2002H

2007H 02H

2008H 20H

2009H 76H HLT

Aqui está o que acontece. A instrução MVI C,03H carrega o registrador C com 03H. A DCR C reduz o conteúdo para 02H. O conteúdo é superior a zero; portanto, o flag de zero é zerado e a instrução JZ 2009H é ignorada. A JMP 2002H faz o computador voltar à instrução DCR C.

Na segunda vez que a DCR C é executada, o conteúdo desce para 01H e o flag de zero ainda continua zerado. JZ 2009H é novamente ignorada e a JMP 2002H faz o computador voltar a DCR C.

Na terceira DCR C, o conteúdo vai a zero. Desta vez, o flag de zero é setado e, então, a JZ 2009H faz o programa pular para instrução HLT. Um laço é uma parte do programa que é repetida. Neste exemplo, nós passamos três vezes através do laço (DCR C e JZ 2009H). Se mudarmos a primeira instrução para MVI C,07H o computador fará 7 passagens pelo laço.

O registrador C age como um contador decrementador pré-ajustável.


82

d) O uso de rótulos é um auxílio usado com saltos e chamadas de sub-rotinas. Ao se escrever um programa em Assembly, normalmente não se tem nenhuma idéia dos endereços que devem acompanhar as instruções de salto e de chamada de sub-rotina. Ao se usar um rótulo no lugar de um endereço, podemos escrever programas que nos farão sentido.

Mostre a versão em linguagem Assembly do programa anterior usando rótulos.

Rótulo Instrução MVI C, 03H REPEAT: DCR C

JZ END

JMP REPEAT

END: HLT

e) Monte um programa para multiplicar os decimais 16 e 14. Faça a multiplicação em uma sub-rotina que inicie no endereço F006H.

Solução:


83

3005H 0EH

3006H CDH CALL F006H

3007H 06H

3008H F0H

3009H 76H HLT :

:

F006H 80H ADD B

F007H 0DH DCR C F008H C2H JNZ F006H F009H 06H F00AH F0H F00BH C9H RET

f) Os bits de um byte são numerados de 7 a 0 (MSB a LSB). Mostre um programa que dá entrada a um byte através da porta 2 e determine se o bit 0 é um 1 ou um 0. Se for 1, o programa carrega no acumulador um Y (yes = sim) em código ASCII. Caso contrário, o programa carrega um N (não) ASCII no acumulador. A resposta sim ou não deve ser enviada para a porta 3 de saída.

Solução:

Rótulo Mnemônico Comentário IN 02H - obtém o byte através da porta 2.

ANI 01H - isola o bit 0.

JNZ YES - salta se o bit 0 for 1.

MVI A, 4EH - carrega N no acumulador.

JMP DONE - passa por cima da próxima instrução.

YES: MVI A, 59H - carrega Y no acumulador.

DONE: OUT 03H - envia a resposta para a porta 3.

HLT

Códigos ASCII: Y = 0101 1001 = 59H

N = 0100 1110 = 4EH


84

Exercícios:

a) Mostre o mnemônico (instruções) de um programa que carrega o acumulador com 49H, o registrador B com 4AH e o registrador C com 4BH. A seguir, o programa armazena o conteúdo de A na posição 6285H da memória.

b) Converta o programa anterior para linguagem de máquina (código hexadecimal) e preencha a tabela RAM, iniciando o programa pelo endereço 2000H.

c) Faça um programa para gerar um loop de repetição o qual deverá gerar 5 giros e depois finalizar a rotina.

d) Converta o programa do exercício anterior para linguagem de máquina e preencha a tabela RAM iniciando pelo endereço 5000H.

e) Para o programa abaixo, pergunta-se:

1) Quantas vezes a instrução DCR C é executada (em decimal)?

2) Quantas vezes o programa salta para LOOP?

3) Como podemos alterar o programa para que o laço seja executado 210 vezes? MVI C, 78H LOOP: DCR C JNZ LOOP NOP HLT

f) Escreva um programa que multiplica o decimal 25 com 7 e armazena a resposta em 2000H.

g) Escreva um programa fonte que carrega o acumulador com o decimal 100, o registrador B com o decimal 150 e o registrador C com a soma dos registradores A e B.

Baixe da Midiateca, no Ambiente Virtual de Aprendizagem, o programa instalasap2.zip. Este programa é um simulador do microprocessador SAP-2 desenvolvido pelo aluno Márcio Henrique da Silva. Este software será útil para a correção dos exercícios propostos.

Exercícios:

No Ambiente Virtual de Aprendizagem, na Midiateca, você vai encontrar o arquivo ExercSAP2.doc com uma lista de exercícios sobre o microprocessador SAP-2.


85

3.3. A Linguagem Assembly

Uma linguagem de programação pode ser definida como sendo um conjunto limitado de instruções (vocabulário), associado a um conjunto de regras (sintaxe) que define como as instruções podem ser associadas, ou seja, como se podem compor os programas para a resolução de um determinado problema.

As linguagens de programação podem ser classificadas em níveis de linguagens, sendo que as de nível mais baixo estão mais próximas da linguagem interpretada pelo processador e mais distantes das linguagens naturais.

3.3.1. Linguagem de Máquina

Na linguagem de máquina, a representação dos dados e das operações (instruções) que constituem um programa é baseada no sistema binário, que é a forma compreendida e executada pelo hardware do sistema. Torna-se inviável escrever ou ler um programa codificado na forma de uma string de bits.

3.3.2. Linguagem Assembly

A linguagem de máquina de cada processador é acompanhada de uma versão “legível” da linguagem de máquina que é a chamada linguagem simbólica Assembly. Simbólica, pois esta linguagem não é composta de números binários como na linguagem de máquina. A linguagem Assembly é, na realidade, uma versão legível da linguagem de máquina. Ela utiliza palavras abreviadas, chamadas mnemônicos, indicando a operação a ser realizada pelo processador.

A passagem de um programa escrito em Assembly para a linguagem de máquina é quase sempre direta, não envolvendo muito processamento. Essa passagem é chamada de Montagem, e o programa que realiza esta operação é chamado de montador (Assembler). Muitas vezes, ouvimos "linguagem Assembler". É um erro muito difundido. Na realidade, Assembly é o nome da linguagem e Assembler é o montador.

O número hexadecimal B2 (178 decimal) corresponde a MOV DL em Assembly. MOV é o mnemônico de MOVer e DL é o byte menos significativo do registrador DX.

A linguagem Assembly é orientada para a máquina (ou melhor, para processador), é necessário conhecer a estrutura do processador para poder programar em Assembly. Essa linguagem utiliza instruções de baixo nível que operam diretamente com registros e memórias, ou seja, as instruções são diretamente executadas pelo processador.


86

3.3.3. Linguagem de Alto Nível

As linguagens de alto nível são assim denominadas por apresentarem uma sintaxe mais próxima da linguagem natural, utilizada no dia-a-dia, fazendo uso de palavras reservadas, extraídas do vocabulário corrente (com READ, WRITE, TYPE, etc.) e permitem a manipulação dos dados nas mais diversas formas (números inteiros, reais, vetores, etc.), enquanto a linguagem Assembly trabalha com bits, bytes, palavras armazenadas em memória.

A passagem de um programa escrito em linguagem de alto nível para o programa em linguagem de máquina é bem mais complexa, comparada com a linguagem Assembly. Essa passagem é feita utilizando compiladores e linkadores.

Um programa escrito em linguagem de alto nível pode, teoricamente, ser usado em qualquer máquina, bastando escolher o compilador correspondente. O que não acontece com um programa escrito em Assembly.

São linguagens de alto nível:

Pascal, C, C++, PHP, SQL, Python, C#, Java, etc.

3.3.4. Vantagens e Desvantagens da Linguagem Assembly

Com relação às linguagens de alto nível.

Desvantagens:

� a linguagem apresenta um número muito reduzido de instruções;

� o programador deve conhecer muito bem a máquina;

� o programa Assembly não é muito legível, precisa ser bem documentado;

� o programa Assembly não é portável (pode ser usado apenas em um tipo de computador). É portável apenas dentro de uma família de processadores;

� a programação Assembly tem um custo de desenvolvimento maior.

Vantagens:

� permite acesso direto ao programa de máquina. Um programa escrito em linguagem Assembly pode ser de 0 a 300% menor e mais rápido que um programa compilado;

� essa linguagem permite o controle total do hardware.

3.3.5. Aplicações da Linguagem Assembly

� Controle de processos com resposta em tempo real - Nesse tipo de aplicação, o processador deve executar um conjunto de instruções em um tempo limitado;


87

� Comunicação e transferência de dados - Nesse tipo de aplicação é utilizada a linguagem Assembly, devido à possibilidade de acessar diretamente o hardware;

� Otimização de subtarefas da programação de alto nível - Um programa não precisa somente ser escrito em linguagem Assembly ou linguagem de alto nível. Podemos ter programas de alto nível com subtarefas escritas em Assembly, para o caso de tarefas tempo-real ou para a programação do hardware do computador.

3.3.6. Programa Debug

Para a criação de um programa em Assembly os montadores mais usados são o TASM - Turbo Assembler da Borland e o Debug. Nesta disciplina, vamos usar o Debug, uma vez que podemos encontrá-lo em qualquer PC com o MS-DOS.

Baixe da Midiateca, no Ambiente Virtual de Aprendizagem, a apostila Assembly_Debug.doc. Esta apostila foi compilada, baseada em material definido por Hugo Perez (Universidade de Guadalajara). Nela procuro mostrar os procedimentos básicos para criar, armazenar e carregar um programa em linguagem Assembly. Também tem uma sessão com exemplos de programas implementados em Assembly.

Também na Midiateca, você pode baixar o material Tutorial_Assembly.doc. Este tutorial é o original do qual editei a apostila acima. Serve para consulta e pode ser interessante para quem quiser se aprofundar um pouco mais em programação Assembly.

Se você quiser ler mais sobre programação Assembly acesse:

http://www.geocities.com/obi_wan__kenobi/assembly/

http://assembly.8m.com/asm/asm2.htm

http://www.xs4all.nl/~smit/asm01001.htm

http://www.ime.uerj.br/~alexszt/cursos/softsis/material/asm/tutasm/program.html

3.4. A Técnica do Pipeline

É uma técnica utilizada para a redução do tempo total necessário para a execução de um programa. Ela é baseada na idéia de controlar o fluxo de instruções através da via de dados para maximizar a execução de instruções, isto é, o número de instruções que podem ser processadas por segundo. Para isso, é utilizado um esquema que tenta usar cada circuito existente no caminho do fluxo de dados durante cada período de clock em suas capacidades máximas.


88

Construiremos a CPU usando o diagrama em blocos mostrado na Figura 33 (a). Neste desenho, cada grupo de circuitos representa o circuito lógico necessário para completar uma determinada tarefa. A via de dados foi dividida nos seguintes agrupamentos padrão:

• BI: Busca de instrução;

• Dl: Decodificação da instrução;

• EXE: Execução da instrução;

• MEM: Acesso à memória (se necessário);

• EV: Escrita de volta no arquivo de registradores (se necessário).

Figura 33 – Utilização de tempo e circuito em um computador básico.

A motivação para a utilização da técnica de pipeline pode ser compreendida examinando-se o fluxo de dados através do circuito. Em um esquema de clock único, é necessário um período de clock para completar todas as cinco operações. Se acompanharmos o fluxo de dados passando na CPU, encontraremos atrasos normais associados a cada unidade. A linha de tempo da Figura 33 (b) mostra a localização do dado enquanto ele se move através do circuito. O resultado é disponibilizado no tempo tinst, no qual:

tinst = tBI + tDl + texe + tmem + tev.

É o pior caso de tempo necessário para acessar todas as unidades, obtido pela soma dos tempos individuais. Usando essa configuração, um novo dado é admitido a cada ciclo de clock. Portanto o período mínimo T de clock é dado por:

T1 ≥ Tinst ,


89

pois este período sempre permite que o dado complete o ciclo. A execução de n instruções necessita de um tempo total de nT1 segundos. A observação-chave é que, uma vez que o dado tenha passado por uma unidade particular da via de dados, esta unidade não é utilizada novamente até a próxima onda de dados. Como cada unidade concluiu sua tarefa, ela estará ociosa nas partes restantes do ciclo de clock. A técnica de pipeline tenta eliminar esse tempo de ociosidade de cada unidade, utilizando uma abordagem diferente para controlar o fluxo de dados.

A Figura 34 (a) mostra como o caminho do fluxo de dados pode ser modificado para permitir a inclusão da pipeline. As unidades lógicas também são divididas em seções identificadas por BI, Dl, EXE, MEM e EV, mas agora, cada unidade tem o seu próprio conjunto de registradores que controlam a entrada dos dados na unidade. Como os registradores são todos controlados pelo mesmo sinal de clock cada unidade recebe novos dados ao mesmo tempo. As características para o fluxo de dados são ilustradas pelos diagramas de tempo da Figura 34 (b). Para esse sistema, escolhemos um novo período de clock, tal que:

T = max (tBI , tDI, tEXE, tMEM, tEV).

Esta equação garante que a unidade mais lenta tenha tempo suficiente para responder, caracterizando o clock mais rápido que pode ser utilizado. Para completar uma única instrução, será necessário um tempo de 5T, o qual pode ser, de fato, maior do que t1, utilizado no esquema de clock mais simples.

Figura 34 – Modificação para uma estrutura com pipeline.


90

A vantagem de velocidade na técnica de pipeline é alcançada quando grandes seqüências de instruções são executadas pelo sistema.

Figura 35 – Movimento da instrução na pipeline.

Uma interpretação simplificada da pipeline é mostrada na Figura 35. Enquanto a instrução é processada pelo computador, ela "ocupa" um grupo de circuitos por vez. Podemos visualizar como a instrução é executada acompanhando-a do começo ao fim, enquanto ela passa através da pipeline. Para tanto, identificaremos os ciclos de clock por CC1, CC2, etc.

A tabela a seguir mostra a utilização do circuito em função dos ciclos de clock.

Ciclo de Clock Utilização do Circuito

CC1 Busca da instrução (BI)

CC2 Decodificação da instrução (Dl)

CC3 Execução da instrução (EXE)

CC4 Acesso à memória (MEM)

CC5 Escrita de volta (EV) Tabela 14 – Ciclos de Clock / Utilização do Circuito.

A instrução utiliza apenas um dos cinco blocos do circuito por vez. A técnica de pipeline utiliza essa característica, permitindo que uma nova instrução entre no fluxo lógico no começo de cada ciclo. O fluxo é mostrado na figura 36 para o caso no qual queremos executar uma operação de adição, como identificado por ADD. Esta figura mostra, claramente, a progressão da instrução dentro do processador.

Figura 36 – Movimento da instrução e temporização da pipeline.

Tendo compreendido o conceito, a introdução da pipeline ao sistema pode ser facilmente utilizada. Suponha que queiramos implementar a seqüência de instruções Inst1, lnst2, lnst3 e assim por diante. Cada instrução é aplicada em seqüência na pipeline, ou seja, cada instrução entra na unidade de BI a cada transição positiva de


91

clock. Isto resulta no fluxo de instrução mostrado na figura 37. Durante CC1, lnst1 entra no estágio de BI. Durante o próximo ciclo CC2 de clock, lnst1 é movida para a unidade de Dl enquanto inst2 entra no estágio de BI. O próximo pulso de clock CC3 move lnst1 para EXE, move lnst2 para Dl e permite que lnst3 entre na unidade de BI. Este carregamento seqüencial da pipeline continua até que ela esteja completa em CC5, quando o resultado de lnst1 estará disponível. O próximo ciclo de clock CC6 retira lnst1 e permite que inst6 entre na pipeline.

Figura 37 – Fluxo da instrução por meio do circuito de pipeline.

O conceito de processamento pipeline se assemelha muito a uma linha de montagem, na qual uma tarefa é dividida em subtarefas, executadas em diferentes estágios dentro da linha de produção.

Agora que já vimos como a pipeline funciona, analisaremos o aumento resultante na velocidade de processamento do computador. Como é necessário apenas um período T de clock para mover a instrução de uma unidade para a outra, o resultado da primeira instrução Inst1 estará disponível no tempo 5T após ela ter sido aplicada à pipeline. Pode-se verificar este fato pelo exemplo simples mostrado na figura 37. Entretanto, como a pipeline está cheia, lnst2 é completada no tempo 6T, lnst3 é completada em 7T e assim por diante. Em outras palavras, uma pipeline cheia completa uma instrução a cada período de clock, o que deve ser comparado com a situação na qual temos apenas uma única instrução sendo executada pelo processador. Neste caso, devemos esperar 5T segundos para cada instrução.

É possível calcular o aumento alcançado pelo preenchimento da pipeline com relação ao caso no qual uma única instrução é processada por vez. Suponha que queiramos executar um programa constituído de N instruções. Se apenas uma instrução for processada por vez, então será necessário um total de:

T1 = N x (5T) = 5NT


92

segundos para completar a execução do programa. Uma pipeline cheia, por outro lado, necessita de um tempo total de:

tpipe = 5T + (N-1) T = (N+4) T

em que o termo 5T assume que a pipeline está inicialmente vazia, considerando o tempo necessário para que a primeira instrução atinja o fim do processamento, enquanto o segundo termo (N-1)T é o tempo necessário para as instruções N-1 completarem o ciclo.

Se N = 1000, então:

t1 = 5000T

tpipe = 1004T

Portanto a pipeline aumenta a velocidade efetiva do processador por um fator de, aproximadamente, cinco vezes, para o nosso exemplo. Apesar de este cálculo ser apenas uma estimativa ideal, não levando em conta outros problemas encontrados em aplicações reais, ele mostra que a pipeline é uma técnica interessante para o aumento da velocidade de processamento.

Exercícios:

1) Um computador é construído usando a arquitetura de 5 estágios. Os atrasos de tempo das unidades individuais são dados por

tBI = 2,6ns tDI = 1,4ns tEXE = 2,5ns tMEM = 3,0ns tEV = 1,5ns

a) Qual a freqüência do clock f1 necessária pelo método de uma única instrução por período de clock (sem pipeline)?

b) Suponha que o clock seja utilizado em cada estágio simultaneamente (com pipeline). Qual seria a freqüência de clock f2 neste caso?

Solução:

a) T = 2,6 + 1,4 + 2,5 + 3 + 1,5 = 11ηs ⇒ f = 1 / T

f = 1 / (11 * 10-9) = 0,0909 * 109 = 90,9 * 106 = 90,9 MHz

b) T = 3ηs ⇒ f = 1 / T

f = 1 / (3 * 10-9) = 0,333 * 109 = 333 * 106 = 333 MHz

2) Considere um sistema que possua 80.000 instruções, uma freqüência de 250 MHz e uma arquitetura da pipeline de 7 estágios.

a) Calcule o tempo necessário para executar uma instrução.


93

b) Calcule o tempo necessário para executar todo o programa sem utilizar a técnica de pipeline.

c) Calcule o tempo necessário para executar todo o programa utilizando a técnica de pipeline.

Solução:

a) f = 1 / T = 1 / (250 * 106) = 0,004 * 10-6 = 4 * 10-9 = 4ηs

T1instr = T * NumEstag = 4 * 10-9 * 7 = 28ηs

b) TsemPIPE = T * NumEstag * NumInstr = 4 * 10-9 * 7 * 80 * 103 =

2240 * 10-6 = 2,24 * 10-3 ⇒ TsemPIPE = 2,24 ms

c) TcomPIPE = T ( NumInstr + NumEstag - 1) = 4 * 10-9 ( 80000 + 7 - 1)

= 4 * 10-9 ( 80006) = 0,000320024 = 0,320024 * 10-3

TcomPIPE = 0,32 ms

Exercícios:

1) Um computador é construído usando a arquitetura de cinco estágios mostrada na figura 33. Os atrasos de tempo das unidades individuais são dados por

tBI = 1,6ns tDI = 1,4ns tEXE = 3,2ns tMEM = 3,7ns tEV = 1,8ns

a) Qual a freqüência do clock f1 necessária pelo método de uma única instrução por período de clock?

b) Suponha que o clock seja utilizado em cada estágio simultaneamente, como na figura 34. Qual seria a freqüência de clock f2 neste caso?

2) Considere a arquitetura da pipeline de cinco estágios mostrada na figura 36.

Suponha que a estrutura seja utilizada para construir um computador com uma freqüência de clock de 300MHz. Um programa com 80 mil instruções é executado no sistema.

a) Calcule o tempo necessário para executar uma instrução.

b) Calcule o tempo necessário para executar todo o programa.

c) Qual a percentagem de aumento de velocidade com relação à utilização de uma arquitetura de cinco estágios sem pipeline?

3) Qual é a principal finalidade da técnica pipeline?


94

3.5. Arquiteturas CISC e RISC

Examinaremos agora a classificação dos computadores baseada no número e no tipo das instruções que são implementadas no sistema. Se acompanharmos a história da evolução do projeto de computadores, descobriremos que cada geração é, geralmente, mais sofisticada que a sua predecessora. Os melhoramentos da tecnologia permitem maior variedade dos tipos de instrução e modos de endereçamento e, conseqüentemente, devem-se incluir mais possibilidades para a via de dados. Estes avanços da tecnologia resultam nos chamados computadores com conjunto de instruções complexas (máquinas CISC – Complex Instruction Set Computers). Compiladores são escritos para utilizar o conjunto expandido de instruções sendo que, quando utilizada a linguagem Assembly para a programação, o programa é mais fácil de ser implementado, devido ao grande número de instruções disponíveis. Essa filosofia dominou a indústria dos computadores por muitas décadas. No entanto, estudos realizados na década de 70 formaram a base para uma abordagem modificada para o projeto de construção de computadores.

Essa abordagem é centrada no projeto de computadores com conjunto de instrução reduzido (máquinas RISC – Reduced Instruction Set Computer), os quais têm um número menor de instruções (se comparados com máquinas CISC). Em nível de hardware, o projeto enfatiza a execução de instruções o mais rapidamente possível. O alvo da arquitetura RISC de computadores é atingir cálculos rápidos, usando uma via de dados relativamente simples.

3.5.1. Máquinas CISC

Os microprocessadores são, em sua maioria, chips CISC. Um processador CISC suporta um conjunto maior de instruções, sendo cada instrução mais especializada; graças a isso, ele pode executar, de modo direto, a maioria das operações programadas pelos programas de alto nível.

Computadores CISC obtêm seus grandes conjuntos de instrução devido a uma técnica chamada de microprogramação. A microprogramação permite que o projetista crie uma instrução combinando as operações necessárias ao nível de microcódigo, que são pequenos programas armazenados dentro do processador. Isto é, na realidade, similar a termos um computador menor operando dentro do computador principal.

Nos processadores CISC, o número de registradores é pequeno e qualquer instrução pode referenciar a memória principal. Neste tipo de arquitetura, a implementação do pipeline é mais difícil.

A característica mais marcante de máquinas CISC é o fato de que o hardware tende a crescer em complexidade com o aumento do conjunto de microinstruções. Mas quanto maior a quantidade de instruções que um processador suporta, mais lenta é a execução de cada uma delas. De uma perspectiva histórica, o aumento da complexidade do hardware tem sido permitido pelos avanços tecnológicos, resultando em máquinas que têm aumentado tanto a capacidade quanto à velocidade de computação de geração em geração.


95

São exemplos de processadores CISC o Digital VAX 11/780, processadores Intel até o 486 e o Motorola 68020.

3.5.2. Máquinas RISC

Agora, estudaremos os conceitos existentes em um computador RISC. Um estudo intenso de programas executados em computadores CISC resultou no que é chamado de regra 80/20. Para compreendê-la, suponha que a máquina CISC tenha um grande número de instruções disponíveis. Então, de acordo com a regra 80/20, "80% dos programas utilizam apenas 20% das instruções disponíveis".

Por exemplo, se um computador tem 500 instruções disponíveis, então 80% dos programas típicos utilizarão apenas 100 destas instruções.

Obviamente, essa regra não apresenta uma resposta exata em termos de números, mas ela mostra um ponto importante: a maioria dos programas pode ser executada usando apenas um pequeno número de instruções, resultando no conceito de computador com conjunto de instrução reduzido (RISC).

Um processador com arquitetura RISC se caracteriza por possuir poucas instruções de máquina, em geral bastante simples, que são executadas diretamente pelo hardware. Na sua maioria, estas instruções não acessam a memória principal, trabalhando principalmente com registradores que, neste tipo de processador, se apresentam em grande número. Estas características, além de ajudarem as instruções serem executadas em alta velocidade, facilitam a implementação do pipeline.

A arquitetura RISC reduz o conjunto de instrução ao mínimo, e as instruções não implementadas diretamente são realizadas por uma combinação de instruções existentes. Mas em compensação, um programa é implementado por um número maior de instruções.

A Apple desenvolveu, sob a arquitetura RISC, em parceria com a Motorola e a IBM, o chip PowerPC, com mais poder de processamento que o chip Pentium.

Outros exemplos de processadores RISC que podemos citar são: o Sparc (SUN), RS-6000 (IBM), PA-RISC (HP), Alpha AXP (DEC) e R4x00 (MIPS).


96

3.5.3. Computadores Modernos

Tem sido muito falado que as arquiteturas RISC resultam em máquinas mais rápidas, mais baratas e fáceis de projetar, mas tudo isso é muito discutível. A simplicidade e o conjunto reduzido de instruções de filosofia RISC inicial se revelam insuficientes. As máquinas ditas RISC atuais têm um conjunto de instruções bastante grande. Um projeto RISC, na prática, também não significa um processador simplificado. A sofisticação da lógica de pipeline e paralelismo aumentam significativamente a complexidade do projeto. Sendo assim, a linha divisória entre RISC e CISC está perdendo a nitidez; as CPUs INTEL, do 486 em diante, já usam parte das técnicas RISC, diminuindo o conjunto de instruções e aumentando o número de registradores.

A simplificação das instruções é um grande mérito e provavelmente continuará a influenciar futuras arquiteturas. Isso significa que os princípios RISC e CISC poderão viver harmoniosamente em um único projeto. As memórias cache maiores (que diminuem a dependência dos acessos à memória) e uma melhoria na tecnologia dos compiladores diminuem ainda mais as diferenças apregoadas entre as máquinas RISC e CISC.

O projeto de processadores modernos evoluiu de tal maneira que eles normalmente utilizam o máximo possível das idéias da filosofia RISC, o que especialmente é verdadeiro para microprocessadores VLSI. Alguns processadores, tais como chips MIPS e PowerPC, são verdadeiramente máquinas RISC, enquanto outros, como processadores Pentium (Intel) e AMD, têm um núcleo RISC envolvido por uma estrutura de controle maior, que fornece operações do tipo CISC. Esse tipo de projeto é particularmente importante, pois uma nova geração de família de microprocessadores deve manter a compatibilidade com um produto CISC anterior.

Exercícios:

1) Faça uma pesquisa na internet para identificar onde são aplicados os computadores RISC.

2) Faça uma pesquisa na internet, jornais e revistas para identificar a evolução dos microprocessadores da família Intel e AMD.

3.6. Conceitos Básicos em Processamento Paralelo

O processamento paralelo trabalha com o conceito de utilização de vários processadores, simultaneamente, para solucionar um dado problema. Uma idéia similar é existente no processamento distribuído, no qual as partes de uma tarefa são distribuídas a vários processadores que, por sua vez, processam os dados ao mesmo tempo. Vamos lembrar do processo de execução de um programa em um computador clássico de von Neumann. Para cada instrução, o computador executa as quatro principais operações de:

� Busca de instrução (BI)

� Decodificação da instrução (Dl)


97

� Execução (EXE)

� Armazenagem (ARM)

No qual "armazenagem" significa uma operação de escrita de volta (com os resultados colocados em um registrador), ou, então, no armazenamento da memória principal. Como um programa de computador é uma seqüência de várias instruções individuais, a velocidade na qual um computador pode executar todo o programa depende da capacidade de execução de instruções do processador, isto é, do número de instruções por segundo.

Examinaremos as conseqüências dessa estrutura comparando dois processadores de velocidades diferentes, em que Ta e Tb são os tempos necessários para os Processadores A e B completarem uma instrução, respectivamente. A figura 38 compara os dois processadores para o caso no qual Tb<Ta. Como os dois processadores executam a mesma seqüência (BI → Dl → EXE → ARM), o Processador B tem uma performance maior do que o Processador A. Isto, por sua vez, implica que os circuitos individuais do Processador B são mais rápidos do que os do Processador A. Estes argumentos são válidos mesmo se os sistemas utilizarem pipelines, porque ela não diminui o tempo necessário para implementar uma única instrução.

Figura 38 – Aumento da velocidade de um processador de von Neumann.

Esta simples comparação ilustra um ponto crucial da arquitetura de von Neumann. Para se aumentar a velocidade de computação do sistema, precisamos diminuir o atraso de cada unidade individual. Para tanto, deve-se aumentar a velocidade do clock ao mesmo tempo em que melhoram os circuitos. Essa característica é chamada de gargalo de von Neumann.

O processamento paralelo soluciona o gargalo de von Neumann fazendo com que vários processadores trabalhem simultaneamente para executar um programa. Apesar de parecer semelhante à introdução de uma pipeline, os conceitos gerais são muito mais poderosos. Em particular, a velocidade de um circuito de processamento paralelo não é limitada pela velocidade de clock de um processador individual. Ao contrário, a velocidade depende do número de processadores utilizados no sistema e de como eles são conectados juntos.


98

Computadores paralelos são constituídos de unidades básicas chamadas de elementos de processamento (EPs), conectados juntos para partilhar dados. Em geral, um EP tem entradas, saídas e sinais de controle, executando algum tipo de operação. O símbolo que usaremos para representar um EP é mostrado abaixo. Um elemento de processamento pode ser muito simples ou muito complexo, dependendo da máquina. As funções são escolhidas de acordo com os cálculos executados. Um EP pode ser constituído de uma única porta, enquanto projetos mais poderosos podem definir um EP como um somador ou mesmo vários microprocessadores de uso geral.

Figura 39 – Símbolo para um elemento de processamento genérico.

3.6.1. Classificação de Máquinas Paralelas

Computadores paralelos podem ser agrupados de acordo com duas quantidades primárias:

� Número N de instruções que podem ser executadas em um mesmo tempo.

� Número S de segmentos de dados que são processados ao mesmo tempo.

O computador clássico de von Neumann executa uma instrução que opera em um único segmento de dado, portanto N=1 e S=1. Esse tipo de computador é referenciado como tendo uma arquitetura SISD (Single-lnstruction, Single-Data-Segment). Na discussão atual, uma máquina SISD genérica será representada pelo diagrama simples mostrado na figura 40. O elemento de processamento (EP) aceita a entrada D e produz o resultado Rx(D) de acordo com a instrução InstX.

Figura 40 – Máquina de instrução única, segmento de dados único (SISD).

Arquiteturas paralelas mais complexas podem ser descritas pela inclusão de mais três grupos:


99

� SIMD: Instrução única, segmento de dados múltiplo (N=1, S>1) - Single-Instruction, Multiple-Data-Segment;

� MISD: Instrução múltipla, segmento de dados único (N>1, S=1) - Multiple-instruction, Single-Data-Segment;

� MIMD: Instrução múltipla, segmento de dados múltiplo (N>1, S>1) - Multiple-instruction, Multiple-Data-Segment.

Cada tipo de arquitetura tem suas características próprias que as tomam interessantes para uma determinada aplicação específica.

3.6.1.1. SIMD

A arquitetura SIMD é mostrada na figura 41 para o caso de quatro processadores individuais, identificados por EP0, EP1, EP2 e EP3. Nesta arquitetura, cada processador executa a mesma operação, mas cada um trabalha com um segmento de dados diferentes. Com as entradas D0, D1, D2 e D3, os resultados dos processadores EP0, EP1, EP2 e EP3 são dados por, respectivamente:

RX(D0), RX(D1), RX(D2), RX(D3)

Figura 41 – Máquina de instrução única, segmento de dados múltiplo (SIMD).

Se a instrução for ADD, então cada processador executa a adição, mas as entradas (e, portanto, os resultados) são diferentes para cada um deles.


100

3.6.1.2. MISD

Na arquitetura MISD, cada processador recebe uma instrução distinta, mas todos os processadores utilizam a mesma entrada de dados. Um exemplo de máquina MISD é mostrado na figura 42. Neste caso, a entrada de dados D é utilizada em quatro operações diferentes, resultando em quatro resultados diferentes. Com a notação mostrada no desenho, as quatro saídas resultantes das instruções identificadas por Inst A, Inst B, Inst C e Inst D são, respectivamente:

RA(D), RB(D), RC(D), RD(D)

Figura 42 – Máquina de instrução múltipla, segmento de dados único (MISD).

3.6.1.3. MIMD

Este é o tipo de máquina paralela mais genérica. A arquitetura MIMD permite que várias operações sejam executadas usando diferentes segmentos de dados. Na figura 43 as entradas do circuito paralelo são D0, D1, D2 e D3. Cada processador executa uma instrução diferente; portanto os resultados são:

RA(D0), RB(D1), RC(D2), RD(D3).

Esse tipo de sistema fornece ao programador o maior nível de flexibilidade, mas é o mais complicado de ser projetado, construído e utilizado.


101

Figura 43 – Máquina de instrução múltipla, segmento de dados múltiplo (MIMD).


102

REFERÊNCIAS

ARAÚJO, Celso de; CHUI, William Soler. Praticando Eletrônica Digital. 2º Ed. São Paulo: Érica, 1997.

CAPUANO, Francisco G.; IDOETA, Ivan Valeije. Elementos de Eletrônica Digital. 38ª Ed. São Paulo: Editora Érica, 2001. 524P. ISBN: 8571940193.

LOURENÇO, Antonio Carlos; CRUZ, Eduardo C. Alves. Circuitos Digitais. São Paulo: Editora Érica, 1996. 322P. ISBN: 8571943206.

MACHADO, Francis B.; MAIA, Luiz Paulo. Arquitetura de Sistemas Operacionais. 4ª Ed. São Paulo: LTC, 2007. 324P. ISBN: 9788521615484.

MALVINO, Albert Paul. Microcomputadores e Microprocessadores. São Paulo: McGraw-Hill do Brasil, 1985. 550P.

MONTEIRO, Mário Antonio. Introdução à Organização de Computadores. 4ª Ed. São Paulo: LTC, 2001. 498P. ISBN: 8521612915.

MURDOCCA, Miles J.; HEURING,Vincent P. Introdução à Arquitetura de Computadores. São Paulo: Editora Campus, 2000. 512P. ISBN: 8535206841.

STALLINGS, William. Arquitetura e Organização de Computadores. 5ª Ed. São Paulo: Makron Books, 2002. 792P. ISBN: 8587918532.

TANENBAUM, Andrew S. Organização estruturada de computadores – 5ª Ed. Rio de Janeiro: Prentice-Hall, 2006. 464P. ISBN: 8576050676.

TOCCI, R.;WIDMER Neal S. Sistemas Digitais – Princípios e Aplicações. 8ª Ed. Rio de Janeiro: Prentice-Hall, 2003. 768P. ISBN: 8587918206.

TORRES, Gabriel. Hardware Curso Completo. 3ª Ed. Rio de Janeiro: Axcel Books, 1999. 1147P. ISBN: 8573231157.

UYEMURA, John P. Sistemas Digitais: uma abordagem integrada. São Paulo: Thomson Learning, 2002. 433P. ISBN: 8522102686.

Arquitetura e organização de computadores

Documents

Transcript of Arquitetura e organização de computadores