00:00:11
[Música]
00:00:21
Olá hoje nós temos a quinta aula de
00:00:24
organização de computadores depois de
00:00:26
conversar sobre as características
00:00:28
gerais dos computadores suas classes
00:00:30
questões de desempenho e de falar do
00:00:33
modelo de fyan da arquitetura Harvard
00:00:35
das da modo de organizar esse computador
00:00:38
para que ele possa executar instruções
00:00:40
para que ele possa funcionar como um
00:00:42
computador programado hoje nós vamos
00:00:44
discutir Justamente a arquitetura do
00:00:47
conjunto de instruções ou seja essas
00:00:49
características que permitem que o
00:00:51
computador seja
00:00:53
programado mas antes da gente falar das
00:00:56
características do computador das
00:00:58
características do conjunto de
00:01:00
instruções é importante nós nos
00:01:02
atentarmos à duas definições a definição
00:01:05
do que é a organização de um computador
00:01:07
e do que é a arquitetura de um
00:01:09
computador são dois elementos
00:01:11
extremamente importantes que andam
00:01:12
juntos mas T diferenças
00:01:14
conceituais a organização de computador
00:01:17
ela se relaciona às unidades
00:01:19
operacionais e suas interconexões que
00:01:21
vão realizar essas especificações
00:01:24
arquiteturais portanto quando nós
00:01:25
falamos do modelo de fona que tinha
00:01:28
cinco elementos entrada saída memória e
00:01:31
o processador dividido em fluxo de dados
00:01:33
unidade de controle e que eu tinha um
00:01:35
único barramento que ligava o
00:01:37
processador à memória tudo isso está
00:01:39
ligado à organização do meu computador
00:01:42
tá então todas Quais são os elementos
00:01:46
Quais são
00:01:47
os os elementos que eu tô interligando
00:01:50
Quais são os como é essa interconexão
00:01:53
tudo isso caracteriza a
00:01:56
organização o outro aspecto agora com
00:01:59
relação a arquitetura né ela vai tá mais
00:02:02
próxima daquilo que é visível pro meu
00:02:04
programador ou seja Quais são as
00:02:07
instruções que eu posso executar quantos
00:02:10
bits tem essa instrução esse Esse
00:02:12
processador é de 32 bits é de 64 é de 16
00:02:16
né como é que o acesso à memória Então
00:02:18
essas características que que fazem que
00:02:21
são importantes pro programador que vão
00:02:23
afetar o desempenho de um programa tão
00:02:26
mais associadas à arquitetura do
00:02:28
computador e é justamente disso que nós
00:02:30
vamos discutir hoje né O que que
00:02:33
caracteriza a arquitetura do meu
00:02:35
computador ou mais precisamente a
00:02:38
arquitetura do conjunto de instruções né
00:02:41
do inglês nós temos o termo instruction
00:02:43
set architecture ou Isa é uma sigla que
00:02:46
aparece com outros significados também
00:02:48
na no ambiente de computação mas aqui no
00:02:51
nosso domínio Isa a instruction s
00:02:53
architecture ou a arquitetura do
00:02:55
conjunto de instruções e Justamente esse
00:02:58
conjunto de instruções de maneira
00:03:00
simplificada ele vai dizer para mim qual
00:03:02
que é o repertório de instruções de um
00:03:04
computador ou seja quais as instruções
00:03:07
que eu posso executar o que que eu posso
00:03:09
acessar em termos de memória tudo isso
00:03:11
caracteriza bom Por que que isso é
00:03:13
importante porque nós temos computadores
00:03:15
diferentes nós temos por exemplo no caso
00:03:18
da Intel se a gente observar temos o i7
00:03:20
i5 E3 voltando mais no tempo penum 486
00:03:25
386 todos esses processadores da Intel
00:03:28
eles têm caracter ticas internas
00:03:30
diferentes eles vão executar um
00:03:33
determinado programa em tempos de
00:03:35
execução diferentes mas eles
00:03:37
compartilham o mesmo conjunto de
00:03:39
instruções eles compartilham a mesma Isa
00:03:41
né Essa é uma característica que a Intel
00:03:44
se propôs a carregar desde os primeiros
00:03:46
computadores lá do da Dé final da década
00:03:49
de 70 Eles procuram garantir essa
00:03:51
compatibilidade da arquitetura de
00:03:53
instruções do conjunto de instruções
00:03:55
então uma vez que eu tenho esses esse
00:03:58
código compilado eu consigo executar em
00:04:01
diversas plataformas diferentes então
00:04:03
por isso que a gente fala diferentes
00:04:05
implementações para um mesmo conjunto de
00:04:07
instruções tá as mesmas características
00:04:10
pro programador gerar esse código em
00:04:13
assembly mas ele é capaz de rodar em
00:04:15
qualquer elemento em qualquer
00:04:17
implementação dessa minha arquitetura do
00:04:19
conjunto de instruções
00:04:23
ah apesar de existirem muitos
00:04:26
computadores diferentes por exemplo Arm
00:04:28
mips Park Power PC a própria Intel essas
00:04:32
esse conjunto de instruções ele tem
00:04:34
vários elementos que são comuns né a
00:04:37
gente tem principais elementos aqui são
00:04:39
cinco elementos principais que
00:04:41
justamente vão caracterizar como
00:04:44
funciona esse repertório Como funciona
00:04:46
essa Isa tá Ah e a ideia justamente hoje
00:04:50
a gente explorar o que que significam
00:04:52
esses cinco elementos que tipo de
00:04:53
impacto esses cinco elementos podem ter
00:04:56
na no nas características que a gente
00:04:58
vai ter do conjunto de instruções bom o
00:05:00
primeiro item aqui é o repertório das
00:05:03
operações quantas operações eu preciso
00:05:06
quantas instruções eu preciso bom a
00:05:08
gente pode começar pelas instruções
00:05:10
aritméticas eu preciso saber somar
00:05:12
subtrair adicionar dividir
00:05:15
multiplicar a gente tem as instruções
00:05:17
lógicas posso fazer end posso fazer a
00:05:20
operação or posso fazer A negação né eu
00:05:24
tenho as instruções de deslocamento à
00:05:26
esquerda deslocamento à direita então
00:05:28
todas essas são instruções que a gente
00:05:30
chama de instruções lógico aritméticas
00:05:32
depois eu vou ter as instruções de
00:05:34
movimentação de dados mesmo que eu tenha
00:05:36
a uma arquitetura memória memória né Eh
00:05:40
eu posso precisar fazer alguma
00:05:42
movimentação de dado mas tipicamente as
00:05:44
arquiteturas envolvem algum uso de
00:05:45
registrador ou de pilha e eu preciso ser
00:05:48
capaz de tirar um dado da memória e
00:05:50
levar para esses registradores então a
00:05:52
gente usa as instruções de load e Store
00:05:54
tirar da memória pro registrador load e
00:05:57
do registrador pra memória as instruções
00:05:59
de História o outro conjunto de
00:06:02
instruções que a gente tem aqui são as
00:06:04
instruções de controle um dos princípios
00:06:07
de fona que o programa era executado
00:06:10
sequencialmente mas quando a gente vai
00:06:12
programar a gente usa por exemplo
00:06:13
condições if e else se for uma igualdade
00:06:18
eu vou executar uma instrução se for
00:06:20
diferente um outro conjunto muitas vezes
00:06:22
nós escrevemos lups né contínuos para
00:06:25
repetir uma determinada conta para
00:06:27
permitir por exemplo uma multiplicação
00:06:28
de uma matriz fazemos dois os Loops de
00:06:31
for Então essas interações todas estão
00:06:33
relacionadas à sequência do programa ou
00:06:36
seja ao controle do programa Então as
00:06:39
instruções que de desvio que vão mudar a
00:06:41
ordem que eu tô executando as instruções
00:06:43
também são importantes e nós temos
00:06:46
podemos agrupar as instruções de
00:06:47
controle em dois tipos as instruções
00:06:50
incondicionais Por exemplo quando existe
00:06:52
um salto um Jump né a gente além do jump
00:06:56
tem o retorno desse Jump por exemplo
00:06:58
a que retorna pro endereço prévio e a
00:07:01
gente tem as instruções de desvio
00:07:03
condicional por exemplo se uma igualdade
00:07:06
for verdade se o valor for igual a zero
00:07:09
eu executo o desvio Caso contrário eu
00:07:12
executo sequencialmente então esses são
00:07:14
todos instruções que entram aqui no
00:07:17
Nosso repertório a gente pode ter ainda
00:07:19
instruções associadas aos dispositivos
00:07:21
de entrada e saída segundo aspecto
00:07:24
importante é os tipos e os tamanhos dos
00:07:27
meus operandos os meus dados tá tá então
00:07:30
por exemplo a gente tem arquiteturas
00:07:31
hoje de 64 bits há algum tempo atrás as
00:07:34
arquiteturas eram de 32 bits para quem
00:07:37
trabalha com sistemas embarcados for
00:07:38
trabalhar com sistemas embarcados a
00:07:40
gente vai ver que tem alguns
00:07:41
dispositivos que são de 8 bits ou de 16
00:07:43
bits cada uma dessas plataformas tem um
00:07:45
tamanho típico de palavra então numa
00:07:48
arquitetura de 8 bits a minha palavra
00:07:50
tem 8 bits na arquitetura de 64 minha
00:07:52
palavra tem 64 bits Então eu preciso ser
00:07:55
capaz de fazer operações todas essas
00:07:58
operações do meu repertório
00:08:00
inicialmente sobre a palavra da minha
00:08:03
arquitetura bom mas não é porque eu tô
00:08:05
numa arquitetura de 64 bits que eu não
00:08:07
posso querer fazer uma operação em cima
00:08:09
de um byte ou em cima de meia palavra
00:08:12
então a arquitetura também precisa
00:08:14
definir Quais são os tipo e tamanh de
00:08:16
operandos tipicamente a gente pode fazer
00:08:19
operações com bite com meia palavra ou
00:08:22
com a palavra inteira da minha
00:08:23
arquitetura é importante também definir
00:08:26
né quando a gente como é que a gente
00:08:28
mapeia esses tipos de dados por exemplo
00:08:30
nas instruções nos tipos de dados das
00:08:32
linguagens de alto nível como c o
00:08:35
inteiro quantos bits ele tem isso vai
00:08:37
depender da minha plataforma então a
00:08:39
gente também pode utilizar nas
00:08:41
declarações das linguagens de alto nível
00:08:43
dizer que o inteiro por exemplo é de 16
00:08:45
bits usar o int 16 isso não vai fazer
00:08:47
diferença se eu tô numa plataforma de 16
00:08:50
de 32 ou de 64 bits aquele dado vai ter
00:08:53
sempre o mesmo tamanho vai ser tratado
00:08:55
sempre da mesma
00:08:56
forma bom terceiro aspecto que a gente
00:08:59
tem é o endereçamento dos operandos
00:09:01
então na minha instrução se for uma
00:09:03
instrução de soma como é que eu vou
00:09:05
fazer essa soma eu vou apontar para um
00:09:07
registrador que tá os meus operandos eu
00:09:09
vou apontar para um endereço da memória
00:09:11
eu vou apontar para um registrador que
00:09:13
tem um endereço de memória onde eu vou
00:09:15
ter que carregar o operando Então a
00:09:17
gente tem várias formas que a gente pode
00:09:19
acessar os operandos e tudo isso é
00:09:21
caracterizado pela nossa arquitetura do
00:09:22
conjunto de instruções ela precisa
00:09:24
definir Quais são os modos de
00:09:26
endereçamento e como funcionam esses
00:09:28
modos de
00:09:31
endereçamento quarto aspecto é o formato
00:09:33
da instrução Então eu preciso definir
00:09:36
como é que a unidade de controle do
00:09:39
processador vai reconhecer que aquela
00:09:41
instrução é uma instrução de soma de
00:09:44
movimentação de dados ou uma instrução
00:09:46
de controle então tipicamente eu preciso
00:09:48
definir um conjunto de bits pro meu
00:09:50
código de operação pro meu upcode Então
00:09:52
esse é um dos primeiros componentes que
00:09:54
a gente tem aqui no formato da instrução
00:09:57
além do upcode para caracter essa minha
00:10:00
instrução eu preciso determinar como é
00:10:02
que eu sei quais são os operandos se é
00:10:04
uma instrução de soma eu vou ter dois
00:10:06
operandos ou vou ter três operandos se
00:10:08
eu tiver três operandos um destino e
00:10:10
duas origens isso tem que tá explícito e
00:10:12
eu tenho que ter uma sequência escrita
00:10:14
no meu formato de instrução a gente pode
00:10:16
ter uma instrução que tem dois operandos
00:10:19
onde o primeiro deles é naturalmente o
00:10:22
destino e um dos operandos isso
00:10:25
simplifica o formato da minha instrução
00:10:27
Mas por outro lado a minha unidade de
00:10:29
controle tem que saber entender que
00:10:31
aquele mesmo valor vai ser utilizado de
00:10:34
duas formas diferentes como operando e
00:10:36
como destino
00:10:38
ah Além disso também a característica do
00:10:40
formato de instrução quantos bits ela
00:10:42
tem se ela tem tamanho fixo ou tamanho
00:10:44
variável para algumas arquiteturas todas
00:10:47
as instruções TM por exemplo 32 bits
00:10:49
como é o caso do mips que nós vamos
00:10:51
conversar em algumas aulas à frente
00:10:54
outras arquiteturas como é o caso da
00:10:55
Intel a instrução tem tamanho variável
00:10:58
Como existe esse legado essa
00:11:00
compatibilidade com as com as várias ah
00:11:03
com as ampliações que a gente teve nas
00:11:05
arquiteturas pode ser que tenha
00:11:07
instruções de 8 bits instruções de 16
00:11:09
instruções de 32 64 então precisa saber
00:11:12
lidar e interpretar com esses vários
00:11:14
formatos de instrução e finalmente o
00:11:18
nosso último aspecto aqui é o
00:11:19
armazenamento dos
00:11:21
operandos eu posso pegar um operando que
00:11:23
tá na própria instrução por exemplo tem
00:11:25
uma constante que faz parte da instrução
00:11:28
eu posso ter um operando que tá num
00:11:29
registrador que tá num acumulador eu
00:11:31
posso ter um operando que tá na memória
00:11:33
Então tudo isso tem que ser definido no
00:11:36
meu na arquitetura do meu conjunto de
00:11:38
instrução para saber como eu vou fazer
00:11:40
essa busca desse operando e Esse aspecto
00:11:43
tá associado também ao endereçamento e
00:11:46
ao meu formato de instruções essas essas
00:11:49
informações todas são extremamente
00:11:51
relacionadas tá
00:11:53
Ah e por exemplo no caso do acumulador
00:11:57
ele ele já destina onde vai ser
00:11:59
armazenado o resultado então eu também
00:12:01
preciso determinar onde eu armazeno o
00:12:03
meu resultado das minhas operações Então
00:12:06
tudo isso são características da Isa
00:12:08
então toda e qualquer arquitetura vai
00:12:11
ter que definir esses aspectos todos tá
00:12:14
seja ela a arquitetura da Intel de 32
00:12:17
bits seja ela o a arquitetura da arm
00:12:19
seja ela a arquitetura do mips não
00:12:21
importa qual arquitetura ela tem que
00:12:23
definir esses aspectos
00:12:26
todos bom e E aí Então dependendo de
00:12:30
todas essas características a gente tem
00:12:32
a arquiteturas com características
00:12:35
diferentes uma possibilidade infinita de
00:12:38
ou uma possibilidade muito grande de
00:12:40
combinação desses parâmetros para
00:12:42
resultar e nessas escolhas nessas
00:12:44
possibilidades então de novo colocando
00:12:47
agora em perspectiva a nossa evolução
00:12:49
histórica da Computação nós tivemos lá
00:12:51
os primeiros computadores com propósito
00:12:53
específico programação através de Chaves
00:12:55
e relê Aí lá na década de 40 veio o mod
00:12:59
de phoa com o conceito de armazenamento
00:13:02
do programa né e determinando como é que
00:13:04
a gente poderia ter esse programa para
00:13:06
ser executado a memória era alguma coisa
00:13:09
que era cara naquela época e não era
00:13:11
muito grande nós não tínhamos
00:13:12
computadores como hoje que tem 8 GB de
00:13:15
de Ram facilmente era muito menor as
00:13:17
quantidades naquela época então o código
00:13:21
armazenado né o resultado do Programa
00:13:23
que eu ia escrever que eu gostaria de
00:13:25
armazenar no meu programa tinha que ser
00:13:26
pensado para ser eficiente porque eu
00:13:28
tinha pouca memória ela tinha que ser
00:13:30
dividida entre dado e instrução Então o
00:13:33
que fez com que nessa época na década de
00:13:35
50 se tivesse uma abordagem de que as
00:13:38
minhas instruções tinham que ser
00:13:40
compactas então a gente eh o que a gente
00:13:42
vê nessa época eh são as instruções ou
00:13:46
conjunto de instruções de característica
00:13:48
cisc Complex instruction set computer né
00:13:51
ou computador com conjunto de instrução
00:13:53
complexo O que quer dizer esse complexo
00:13:56
primeiro lugar eu tenho muitas
00:13:58
instruções uma infinidade de instruções
00:14:00
possíveis não é só soma é soma e faz
00:14:04
mais alguma coisa depois disso então
00:14:05
existe uma combinação muito grande de
00:14:07
tipos de instruções instruções com duas
00:14:10
funções associadas Mas por que associar
00:14:13
duas funções a uma mesma instrução
00:14:15
justamente porque a memória era cara eu
00:14:17
quero que essa minha instrução ela faça
00:14:20
bastante coisa para uma mesma informação
00:14:22
que tá codificada tá ah então por isso
00:14:26
que houve essa motivação para
00:14:27
desenvolver esses tipos de instruções
00:14:29
complexas trazer na medida do possível
00:14:32
uma proximidade das instruções que
00:14:34
estavam sendo programadas pro meu
00:14:37
computador com as instruções como a
00:14:39
gente vê nós humanos vemos a definição
00:14:41
do problema e um conceito importante
00:14:44
para
00:14:45
permitir esse uso das instruções Cis foi
00:14:48
o conceito de
00:14:49
microprogramação que ele permitia que a
00:14:51
gente tivesse instruções complexas
00:14:53
escritas na memória e que ela fosse
00:14:56
executada Ou micro programada para ser
00:14:59
executada no nosso
00:15:01
processador bom então falando um
00:15:03
pouquinho mais de cisc Aqui nós temos
00:15:05
três exemplos de instrução Então a
00:15:07
primeira dela cas compare and operant ou
00:15:10
seja duas instruções a primeira eu vou
00:15:12
comparar dois operandos dependendo
00:15:14
doesse meu resultado de comparação eu
00:15:17
vou trocar esses
00:15:19
operandos aqui por exemplo no rtr eu vou
00:15:22
retornar e restaurar códigos Então essas
00:15:25
instruções todas que a gente tem aqui
00:15:27
esses três exemplos eu tô fazendo duas
00:15:29
instruções com uma única
00:15:33
codificação então quando a gente pensa
00:15:35
nas características de projeto do cisc O
00:15:38
que que a gente tem primeiro formato de
00:15:40
dois operandos é o mais comum eu tô
00:15:42
simplificando a minha instrução então
00:15:45
por exemplo eu vou somar o conteúdo do
00:15:47
registrador cx com um determinado
00:15:49
endereço de memória e armazenar no meu
00:15:52
registrador
00:15:53
cx segundo aspecto eu tenho vários modos
00:15:56
de combinar essas instruções eu posso
00:15:59
trabalhar com dois registradores como
00:16:00
operando registrador memória que é esse
00:16:03
exemplo ou memória registrador então não
00:16:05
importa a ordem eu poderia ter aqui um
00:16:08
endereço de memória como destino e como
00:16:10
operando Então essa grande flexibilidade
00:16:12
nos modos é uma característica das
00:16:14
organizações
00:16:15
cisc a gente tem múltiplos modos de
00:16:18
endereçamento também associado a esses
00:16:20
múltiplos modos né e a própria maneira
00:16:23
como eu vou acessar a memória eu posso
00:16:25
simplesmente acessar o endereço de
00:16:26
memória específico eu posso acessar um
00:16:29
endereço de memória ou um registrador
00:16:30
para pegar o endereço que eu quero ler
00:16:32
depois então essa combinação essa
00:16:35
flexibilidade permite com que a gente
00:16:37
torne essas instruções ainda mais
00:16:40
complexas bom se eu tenho múltiplos
00:16:42
modos de instrução múltiplas combinações
00:16:45
isso vai fazer com que as instruções
00:16:47
tenham uma largura variável eu tenho
00:16:49
instruções que podem ser menores ou
00:16:51
maiores eu posso ter dois operandos três
00:16:53
operandos endereços de memória endereço
00:16:55
de registrador tudo isso leva a uma
00:16:57
instrução com largura variável
00:16:59
ah como essas instruções são complexas
00:17:02
por exemplo posso ter duas instruções
00:17:04
sendo especificada por uma única
00:17:06
instrução isso vai fazer com que eu
00:17:07
precise de múltiplos ciclos de relógio
00:17:10
para executar essa instrução então pro
00:17:12
programador é uma única instrução mas
00:17:14
pro meu hard pro meu processador eu vou
00:17:16
ter múltiplas múltiplas instruções sendo
00:17:19
executadas naquele ciclo isso faz com
00:17:22
que eu tenha as um tempo de execução
00:17:24
maior para uma dada instrução e o último
00:17:27
aspecto é que o hardware poucos
00:17:29
registradores Até porque eu tenho
00:17:31
bastante flexibilidade com a maneira de
00:17:33
fazer esse
00:17:35
endereçamento bom em contraposição a
00:17:38
esse caminho todo de de abordagem de
00:17:41
conjunto de instruções de cisc que
00:17:43
surgiu na década de 50 meados da década
00:17:46
de 70 mais forte no começo da década de
00:17:48
80 a gente teve um outro movimento de
00:17:50
projeto que tratava de um conjunto
00:17:53
reduzido de instruções ou seja o risque
00:17:56
o red reduced instruction set computer
00:17:59
ou um conjunto de instruções reduzido
00:18:02
reduzido traz várias implicações tá
00:18:06
então primeiro eu tenho menos instruções
00:18:08
eu tenho instruções mais simples então
00:18:11
cabe ao programador ou ao compilador
00:18:14
usar mais instruções para atingir essa
00:18:16
tarefa de alto nível que foi diferente
00:18:18
do que acontecia no cisc né ah todas as
00:18:22
instruções sem tamanho fixo então numa
00:18:24
arquitetura de 32 bits todas as minhas
00:18:26
instruções risque vão ter exatamente de
00:18:28
32 bits isso simplifica o meu projeto do
00:18:31
Hard simplifica o meu processo de
00:18:33
decodificação porque eu sempre vou
00:18:35
trabalhar com o tamanho da minha palavra
00:18:37
pra minha instrução eu tenho poucos
00:18:39
modos de endereçamento por que que eu
00:18:41
tenho poucos modos de endereçamento
00:18:43
porque a minha instrução para ter poucos
00:18:45
formatos de instrução para ter essa
00:18:47
previsibilidade essa Simplicidade no
00:18:49
processo eu preciso conseguir capturar
00:18:52
esses modos todos de endereçamento
00:18:54
dentro desses poucos tipos de instrução
00:18:56
que eu tenho tá então a simplicidade
00:18:59
desse conjunto de instrução reduzido vai
00:19:01
fazer com que o meu hardware seja mais
00:19:03
simples e vai sobre alguns aspectos ter
00:19:06
menos flexibilidade do que a gente tem
00:19:08
numa organização cisc num computador
00:19:10
cisc bom mas se tudo isso aqui é mais
00:19:14
estável mais simples mais regular isso
00:19:17
vai permitir com que eu tenha um
00:19:18
desempenho melhor do meu hardware a
00:19:19
unidade de controle é feita todo em
00:19:22
hardware e ela consegue tratar muitas
00:19:24
vezes com as instruções serem executadas
00:19:26
num único ciclo de relógio Então apesar
00:19:29
de eu ter mais instruções para mesmo
00:19:31
programa numa organização num computador
00:19:34
risque eu vou precisar posso eu posso
00:19:37
precisar de menos tempo do que num
00:19:39
computador cisc se no computador cisc eu
00:19:41
tenho poucas instruções mas que duram
00:19:43
muito no Risk eu posso ter muitas
00:19:45
instruções mas com um ciclo de execução
00:19:48
então é importante a gente lembrar que o
00:19:50
número de instruções não é uma métrica
00:19:52
para desempenho eu preciso saber qual
00:19:53
que é o meu tempo de ciclo então
00:19:55
justamente essa contraposição de Risk
00:19:58
cisk com relação ao número de instruções
00:20:00
e a o tem o número de ciclos para
00:20:02
executar cada instrução pode fazer com
00:20:04
que a gente tenha desempenho parecidos
00:20:06
ou diferentes dependendo de como foi
00:20:08
esse projeto do
00:20:10
Hardware bom pra gente contextualizar
00:20:13
aqui ah como eu falei para vocês aqui
00:20:15
tem uma vários eh projetos Risk aí da
00:20:20
década de 80 que eu gostaria de destacar
00:20:22
aqui para vocês eh que esse projeto da
00:20:25
década de 80 o Risk aqui ele dá
00:20:27
justamente
00:20:29
início a linhagem do arm do processador
00:20:31
que a gente tem bastante utilizado em
00:20:33
domínio de sistemas embarcados hoje aqui
00:20:35
aparece também o Spark e outros
00:20:38
processadores que aparecem aí no uso de
00:20:41
servidores bom o que que a gente tem
00:20:44
implementado hoje né Nem tanto risque
00:20:47
nem tanto cisk a gente ainda tem alguns
00:20:48
computadores Risk sendo implementados
00:20:50
sendo utilizados como eu falei o caso do
00:20:52
arm mas por exemplo a própria Intel que
00:20:54
começou com essa característica de cisc
00:20:57
hoje ela não apesar do conjunto de
00:20:59
instruções para esse cisc a
00:21:01
implementação não é completamente cisc
00:21:04
por quê Porque a gente teve avanços na
00:21:06
tecnologia né As Memórias têm muito mais
00:21:08
capacidade então não tem essa restrição
00:21:11
que a gente tem com relação a ao espaço
00:21:13
que o código vai gerar né e por outro
00:21:16
lado as arquiteturas Risk permitiram uma
00:21:18
série de evoluções com relação às
00:21:20
estratégias de desempenho que levaram a
00:21:23
o uso dessas técnicas dentro das
00:21:25
arquiteturas Risk dentro dessas
00:21:27
organizações micro programadas então não
00:21:30
tem mais essa distinção Clara desses
00:21:33
dois dado essa a mudança dos requisitos
00:21:35
e a essa evolução das técnicas que a
00:21:39
gente teve para projeto de arquitetura e
00:21:41
que acabaram sendo levadas pros dois
00:21:43
ambientes aí Risk
00:21:46
cisc aqui a gente tem vários elementos
00:21:48
para considerar gostaria de destacar
00:21:50
aqui o 486 como um cisc de 32 bits Pain
00:21:55
Então a gente tem aqui as arquiteturas
00:21:56
da Intel nessa região e aqui a gente vê
00:21:59
o arm como um exemplo clássico de
00:22:03
risque E aí como referências a gente tem
00:22:06
o Capítulo 2 do Livro do Patterson e do
00:22:08
henes e o capítulo 10 do livro do stal
00:22:26
[Música]
00:22:28
C
00:22:41
[Música]
