00:00:10
[Música]
00:00:20
Olá hoje nós temos a aula número sete de
00:00:23
organização de computadores na aula
00:00:26
passada nós estávamos discutindo os
00:00:27
princípios de projeto e as
00:00:29
características iniciais da arquitetura
00:00:32
do conjunto de instruções do mips hoje
00:00:34
nós vamos tratar mais alguns aspectos
00:00:37
importantes especificamente do mips mas
00:00:39
que valem para outros conjuntos de
00:00:41
instruções de outros
00:00:43
processadores bom pra gente lembrar né
00:00:46
Nós temos aqui
00:00:48
ah primeiro aspecto que nós discutimos
00:00:50
foi o repertório de operações do mips
00:00:53
nós conversamos um pouco sobre as
00:00:54
instruções de ula nós temos instruções
00:00:56
lógicas e aritméticas que permitem o uso
00:00:59
de de três registradores três com três
00:01:03
operandos registradores né dois vos
00:01:05
registrador e armazenando no registrador
00:01:07
ou nós temos os instruções é de I em de
00:01:10
I por exemplo aqui que são as instruções
00:01:11
que usam o imediato que eu posso usar
00:01:13
uma constante nessas
00:01:15
operações depois nós falamos das
00:01:17
instruções de transferências de dados ou
00:01:19
seja as instruções de load Store que vão
00:01:21
acessar a memória para trazer um valor
00:01:23
da memória pro registrador que são
00:01:25
instruções também do tipo I com relação
00:01:28
ao formato de instrução onde essa
00:01:30
constante usada para fazer essa busca do
00:01:33
endereço nós falamos das instruções de
00:01:35
controle os desvios que tinha dois tipos
00:01:38
de desvio O desvio se igual e se
00:01:40
diferente Branch equal e not equal e as
00:01:42
instruções de jump que são os saltos
00:01:44
incondicionais nós falamos também que
00:01:47
nós temos diversos tipos e tamanhos de
00:01:50
operandos de dados né Então as
00:01:52
instruções do mips elas vão trabalhar
00:01:54
com byte meia palavra 16 bits ou a
00:01:57
palavra toda 32 bits e também a gente
00:02:00
tem instruções que lidam com sem sinal
00:02:03
do tipo unsigned ou seja considera todo
00:02:05
os 32 bits para representar um número e
00:02:09
nós falamos dos três formatos de
00:02:11
instrução Tipo R I E J né e o resumo das
00:02:15
características do conjunto de
00:02:17
instruções do mips está no cartão de
00:02:19
referência do mips que nós temos acesso
00:02:21
que é público bom que que a gente vai
00:02:24
conversar um pouquinho agora nós vamos
00:02:25
começar primeiro falando como é que a
00:02:27
gente transforma aquela nossa condição
00:02:31
um if por exemplo aqui em C pro código
00:02:34
em mips né como é que é esse processo o
00:02:37
que que eu tenho que pensar nessa
00:02:39
transformação bom primeiro aspecto né a
00:02:41
gente tem aqui uma condição se for
00:02:44
olhando do formato do fluxograma se I
00:02:47
for igual a j eu vou fazer essa operação
00:02:50
f = g + h se for diferente eu vou fazer
00:02:54
f = g - h então aqui eu tenho a condição
00:02:57
do c e aqui a condição do ELS tá então
00:03:02
primeira decisão que eu tenho que tomar
00:03:03
é como é que eu vou escrever essa
00:03:05
sequência de código porque eu posso
00:03:08
fazer uma comparação com igualdade ou
00:03:10
com diferença o Branch equal Branch not
00:03:12
equal se for quando a condição da
00:03:15
igualdade é verdade eu desvio para
00:03:18
aquele endereço tá para aquele rótulo
00:03:20
onde eu vou Executar a instrução então
00:03:22
eu tenho que se eu quero aqui no meu if
00:03:24
uma condição de igualdade e na sequência
00:03:28
eu vou escrever no código assembly essa
00:03:30
instrução eu vou ter que escolher uma
00:03:32
instrução que vai fazer um desvio quando
00:03:35
for diferente not equal então por isso
00:03:39
que aqui eu tô usando a instrução de
00:03:41
desvio se for diferente Branch not equal
00:03:44
dos valores de S3 e S4 que é justamente
00:03:47
Onde estão i e j
00:03:50
armazenados se for diferente Ou seja o
00:03:52
caso do ELS eu vou para esse rótulo aqui
00:03:55
de endereço onde vai tá a minha
00:03:57
instrução do ELS e no ELS tenho a
00:04:00
instrução de subtração de S1 e S2 ou
00:04:03
seja de g e
00:04:05
h armazenado em F que está armazenado em
00:04:09
s0 e aqui caso essa essa condição de
00:04:14
desvio fale ou seja porque igual eu vou
00:04:16
Executar a minha instrução que vem aqui
00:04:19
caso seja igual Ou seja eu vou somar g e
00:04:23
h que estão armazenados nos
00:04:24
registradores S1 e S2 e escrever o
00:04:28
resultado em s0
00:04:30
bom depois que eu executei essa
00:04:32
instrução eu tenho que continuar o meu
00:04:34
fluxo original do meu programa em C Ou
00:04:37
seja eu teria que passar pular essa
00:04:40
instrução de else que tá aqui então por
00:04:42
isso eu vou usar essa instrução de jump
00:04:44
que é incondicional que sempre ocorre
00:04:47
pro rótulo que vai est apontando pra
00:04:49
linha seguinte as instruções associadas
00:04:52
ao el Ou seja que eu chamei esse rótulo
00:04:54
de Exit então quando eu tô escrevendo
00:04:57
código em assembly correspondente a esse
00:04:59
em C ou quando o compilador vai fazer
00:05:02
essa tradução do do código em C pro
00:05:05
código em assembly ele vai utilizar
00:05:07
rótulos para reconhecer essas instruções
00:05:11
a gente vai discutir ISO melhor em outra
00:05:13
oportunidade mas na hora dear o código
00:05:15
binário código de máquina esses rótulos
00:05:18
vão ser traduzidos em endereços
00:05:21
Associados à instruções
00:05:24
bom a gente já viu o if como é que a
00:05:26
gente implementa um loop agora um Wi tá
00:05:30
então por exemplo se eu tiver aqui essa
00:05:31
condição while save de i = a k eu vou
00:05:35
incrementar o valor de I bom eu tenho
00:05:39
que lembrar que eu tô usando o valor de
00:05:42
save para acessar save é um vetor Então
00:05:45
o que eu tenho armazenado num
00:05:46
registrador é meu endereço base para eu
00:05:48
poder acessar a posição de memória
00:05:51
correspondente ao valor que eu quero eu
00:05:54
preciso fazer o fazer o cálculo do
00:05:56
endereço Lembrando que o endereço na
00:05:58
memória é é por byte então eu vou
00:06:00
precisar considerar a multiplicação por
00:06:02
4 bom aqui eu tenho i e i é um valor que
00:06:06
eu tô incrementando então eu sei que
00:06:09
esse valor de I ele vai ter que ser
00:06:11
multiplicado por 4 que é o número de
00:06:14
byes que eu tenho numa palavra para eu
00:06:16
poder saber qual é o a palavra correta
00:06:18
ou seja qual é a posição correta do
00:06:20
vetor que eu quero associar bom a
00:06:22
instrução de multiplicação tipicamente é
00:06:24
uma instrução mais lenta que a gente tem
00:06:26
né É uma instrução que demora mais
00:06:28
ciclos para ser executada então quando
00:06:30
eu quero um código eficiente eu procuro
00:06:32
usar Eu uso as instruções de shift left
00:06:35
Logical SL fazer o deslocamento de duas
00:06:39
posições de um valor em binário equivale
00:06:42
a multiplicar por 2 elevado a 2 ou seja
00:06:46
multiplicar por quatro que é exatamente
00:06:48
o que eu quero que aconteça aqui para eu
00:06:49
poder calcular o endereço que eu quero
00:06:52
obter da memória então tipicamente para
00:06:54
economizar a instrução a gente não usa
00:06:56
instrução de multiplicação Mas usa a
00:06:58
instrução de de shift Logical left
00:07:01
Logical aqui para que que vale a fazer
00:07:04
essa multiplicação por 4 então eu tenho
00:07:07
o meu valor de I em S3 então eu tô
00:07:10
deslocando S3 de duas posições que
00:07:13
equivale a multiplicar por 4 e
00:07:14
armazenando em T1 aí eu vou somar isso
00:07:17
ao meu endereço base que está em S6 e eu
00:07:22
vou obter o endereço de memória vou
00:07:25
armazenar em T1 o endereço de memória
00:07:27
que eu quero acessar para ter esse valor
00:07:30
aqui save de i e esse valor vai ser
00:07:32
feito o load pro registrador t0 aí então
00:07:36
agora eu posso fazer efetivamente a
00:07:38
comparação de save de I que tá
00:07:40
armazenado no registrador t0 com o valor
00:07:43
de k que está armazenado em
00:07:46
S5 se essa comparação for verdadeira ou
00:07:50
Desculpa se eles forem iguais eu quero
00:07:53
fazer essa operação Se eles forem
00:07:55
diferentes eu vou sair do meu loop Então
00:07:58
se eles for diferentes eu vou pro rótulo
00:08:01
de Exit Ou seja eu vou sair do loop Se
00:08:04
eles forem iguais eu vou pra instrução
00:08:06
seguinte que que eu quero fazer na
00:08:07
instrução seguinte incrementar o valor
00:08:10
de I fazer i = i + 1 o i tá em S3
00:08:14
portanto eu vou usar a instrução de
00:08:16
adicionar com imediato
00:08:19
S3 vai ser armazenado em S3 o próprio
00:08:22
resultado e eu vou incrementar aqui
00:08:23
justamente com o valor 1 se eu estou
00:08:26
dentro do meu loop eu preciso fazer o
00:08:28
desvio e vou voltar pro começo do loop
00:08:31
para recalcular o próximo valor de save
00:08:33
de i e fazer minha comparação então por
00:08:36
isso que depois aqui eu tenho esse Jump
00:08:37
pro loop para poder manter esse loop do
00:08:40
A então aqui a gente usou o desvio
00:08:43
condicional e duas vezes a e uma vez a
00:08:46
instrução de jump para manter o loop
00:08:52
rodando bom um outro aspecto importante
00:08:55
pra gente ver já que a gente já falou de
00:08:57
como faz o if como a gente faz o wi é
00:08:59
pensar nas diferentes condições que a
00:09:02
gente tem a a instrução o conjunto de
00:09:04
instruções do mips permite que eu
00:09:06
compare ser é igual ou diferente mas
00:09:08
muitas vezes nós queremos saber se é
00:09:09
maior ou menor a decisão de projeto
00:09:12
envolvida aqui foi que as instruções em
00:09:15
hardware de comparação de maioridade ou
00:09:18
se é maior se é menor elas são
00:09:20
instruções mais complexas que precisam
00:09:22
de mais ciclos precisam de maior área né
00:09:24
então vocês na disciplina de projeto
00:09:26
lógico digital vão discutir esses
00:09:28
aspectos de como implementar esses
00:09:30
comparadores e vocês vão poder entender
00:09:31
melhor esses aspectos mas a decisão de
00:09:34
projeto aqui é que eu posso ter uma
00:09:35
instrução que vai fazer a comparação e
00:09:38
vai gerar um resultado um ou zero se ela
00:09:41
for verdadeira ou falsa e aí eu uso esse
00:09:44
resultado um ou zero para fazer o desvio
00:09:46
Ou seja eu tenho por exemplo aqui a
00:09:48
instrução set less than né o resultado
00:09:53
se RD e RS forem iguais eu vou setar
00:09:59
o valor e com zero se for verdade
00:10:04
ou desculpa com um se for se a condição
00:10:07
for verdade zero se a condição for falsa
00:10:10
então eu tô comparando os registrad
00:10:12
Então essa essa instrução equivale a
00:10:14
fazer a comparação de menor aqui e se tá
00:10:17
um ou zero se for verdade ou se for
00:10:19
falso tá o que que eu como é que eu
00:10:21
posso implementar um desvio com essa
00:10:23
condição de maior eu vou primeiro fazer
00:10:26
o uso do Set less Dan por exemplo E aí
00:10:28
eu vou vou fazer o desvio usando o
00:10:30
resultado se for zero eu vou comparar se
00:10:34
o meu resultado for zero eu tô
00:10:35
comparando com zero eu vou desviar para
00:10:37
L senão eu não vou desviar então a
00:10:39
combinação dessas duas instruções
00:10:41
permite que eu tenha desvios com
00:10:43
condições diferentes de igualdade ou
00:10:49
diferença bom um outro aspecto
00:10:51
importante ainda falando em termos de
00:10:52
comparação tem relação justamente aos
00:10:55
meus tipos de variáveis que eu tenho a
00:10:57
tratar com variáveis com sinal
00:10:59
e sem sinal então se eu tenho um número
00:11:02
por exemplo que é positivo ou seja estou
00:11:04
representando um número como um número
00:11:06
negativo ele vai ter uma representação
00:11:09
diferente então por exemplo aqui né Se
00:11:12
eu tiver se eu quiser fazer se eu
00:11:14
tivesse esses dois valores aqui
00:11:15
armazenados são dois valores de 32 bits
00:11:18
no registrador s0 eu tenho todos os bits
00:11:21
setos para um no registrador S1 eu só
00:11:24
tenho o bit menos significativo aqui
00:11:26
setado para um os outros demais são para
00:11:28
zeros como eu vou interpretar essa
00:11:30
cadeia de bits Depende de eu saber o que
00:11:34
que ela quer dizer Depende se eu saber
00:11:35
se isso aqui é um número com sinal ou
00:11:37
sem sinal se S zer for um número inteiro
00:11:41
sem sinal eu sei que esse aqui é o maior
00:11:44
valor que eu posso armazenar em 32 bits
00:11:47
Portanto o valor de s0 é maior que o
00:11:49
valor de S1 por outro lado se eu falar
00:11:54
que esses valores s0 e S1 são valores e
00:11:57
de números inteiros com sinal o que eu
00:12:00
sei observando esses números é que esse
00:12:02
daqui é um número um positivo e que esse
00:12:04
daqui vai ser o número negativo né que
00:12:07
vai ser o número os1 tá então é muito
00:12:11
diferente eu comparar 1 com men1 que vai
00:12:15
fazer com que eu tenha uma uma condição
00:12:18
de retorno ou eu comparar com
00:12:22
quatro com 4 bilhões aqui com o número
00:12:25
um tá então eu tô comparando ordens de
00:12:29
ites muito diferentes que vai me gerar
00:12:31
um resultado de comparação muito
00:12:32
diferente então eu preciso determinar se
00:12:34
é com sinal ou sem sinal e usar a
00:12:37
instrução apropriada então slt compara
00:12:40
números com sinal sltu u u de unsigned
00:12:44
compara número sem sinal Então eu
00:12:46
preciso é importante eu reconhecer Qual
00:12:49
é o tipo adequado de instrução preciso
00:12:52
dar o significado pro valor que tá
00:12:54
armazenado no meu
00:12:57
registrador bom quarto assunto ou quatro
00:13:01
quarto aspecto pra gente tratar hoje é
00:13:03
relacionado a chamada de procedimento né
00:13:06
quando a gente tá implementando um
00:13:07
programa em se ou em Java a gente faz
00:13:09
uso de funções faz uso de classes né ah
00:13:13
e quando a gente tem essas funções eu
00:13:15
tenho variáveis locais eu tenho
00:13:16
variáveis globais eu posso ter passagem
00:13:19
de parâmetros eu posso ter retorno de
00:13:21
valores e tudo isso é natural numa
00:13:23
linguagem de alto nível mas como é que
00:13:25
isso é mapeado pro assembly como é que a
00:13:27
gente implementa isso no nosso
00:13:29
processador então pro processador fazer
00:13:33
né pro desculpa pro compilador fazer
00:13:35
essa tradução da linguagem de alto nível
00:13:37
pro assemble ou para nós escrevermos
00:13:40
esse programa em assemble a gente tem
00:13:41
que seguir uma série de parâmetros aqui
00:13:43
uma série de Passos primeiro os
00:13:46
parâmetros que eu vou passar para essa
00:13:47
função para esse procedimento tem que
00:13:49
utilizar esses registradores dólar a
00:13:52
zero dólar a um a do ou A TR Eu tenho
00:13:55
quatro registradores para passagem de
00:13:56
parâmetro então lembra lá dos 32
00:13:59
registradores do mips quatro são
00:14:01
específicos para passagem de parâmetros
00:14:03
de funções bom depois que eu coloquei os
00:14:07
meus parâmetros nos registradores
00:14:09
apropriados eu vou chamar o meu minha
00:14:12
função o meu procedimento isso é feito
00:14:14
através da instrução de jump and link
00:14:16
essa instrução de jump and link ela faz
00:14:19
o salto pro endereço que tá no que tá
00:14:21
indicado lá no no nos 26 bits de
00:14:24
endereço mas Além disso ela copia o que
00:14:27
tá no program Counter Ou seja no
00:14:29
contador de instruções para um outro
00:14:31
registrador especial que é o registrador
00:14:33
de retorno o dólar ra tá então é mais um
00:14:37
registrador reservado para uma função
00:14:38
específica Então essa instrução já vai
00:14:40
indicar para onde que essa função tem
00:14:43
que voltar depois Bom agora eu vou
00:14:46
Executar a minha função propriamente
00:14:48
dito mas antes de eu começar a Executar
00:14:50
a minha função propriamente dita eu
00:14:52
preciso cuidar dos registradores né nós
00:14:55
falamos lá que nós temos os
00:14:56
registradores do tipo t e do tipo s né
00:14:59
então nessa passagem de função o
00:15:01
registrador tipo T eu posso alterar o
00:15:03
valor que não vai ter nenhum problema
00:15:05
mas os registradores tipo S antes dessa
00:15:07
função que foi chamada utilizar um
00:15:09
registrador de tipo S ela precisa salvar
00:15:11
o conteúdo para poder restaurar depois
00:15:14
então por isso eu preciso salvar os
00:15:16
registradores tipo S que eu for utilizar
00:15:18
na pilha tá aí sim eu posso executar as
00:15:22
operações as instruções que fazem parte
00:15:24
do meu procedimento uma vez que eu
00:15:27
terminei de fazer esses cálculos eu vou
00:15:29
colocar os resultados de retorno nos
00:15:32
meus registradores de retorno Nós temos
00:15:33
dois registradores especiais dólar v0 e
00:15:36
dólar v1 para esse fim e aí eu tenho que
00:15:39
restaurar os valores de S Que eu
00:15:42
modifiquei Vou acessar a pilha para
00:15:45
recuperar os valores de S originais e aí
00:15:47
eu posso usar a instrução de jump return
00:15:50
Jr usando o ra o registrador ra com o
00:15:54
meu endereço de retorno bom vamos ver um
00:15:56
exemplo então aqui se eu tiver esse
00:15:59
código extremamente simples aqui em C
00:16:02
uma função chamada in folha né que
00:16:05
recebe como parâmetros aqui G H I J ela
00:16:09
tem uma variável local f e vai fazer a
00:16:12
conta aqui f = g + h - i + j e retornar
00:16:16
o valor de F Tá então vamos assumir né g
00:16:21
h e j são os parâmetros portanto eles
00:16:24
vão ser transferidos nos registradores a
00:16:26
0 a 1 a 2 e a tr F é uma variável
00:16:31
interna dessa minha função eu vou
00:16:32
colocar no meu registrador s0 se eu vou
00:16:35
colocar no registrador s0 primeiro eu
00:16:37
preciso Salvar esse registrador né antes
00:16:39
de poder usar e oado eu vou colar em V
00:16:42
zer o f aqui para eu poder retornar como
00:16:44
é que a gente implementem ISO em assem
00:16:46
bom eu tenho o meu rótulo aqui PR minha
00:16:48
função né folha primeiraa eu preciso que
00:16:52
a função tem que fazer depois que ela
00:16:54
foi chamada salvar os registradores que
00:16:57
ela vai usar então eu vou precisar abrir
00:17:00
espaço na pilha esse registrador SP ele
00:17:03
aponta pro topo da pilha de onde eu
00:17:06
posso salvar os valores essa pilha ela
00:17:08
funciona num sentido Ah que eu vou
00:17:10
precisar decrementar para poder liberar
00:17:13
espaço para utilizar aí eu vou fazer o
00:17:16
Store do meu valor de s0 na pilha então
00:17:19
o registrador SP aqui já está apontando
00:17:21
pro valor onde eu vou armazenar meu
00:17:22
valor por isso que o offset é zero e
00:17:25
agora eu posso então começar a executar
00:17:27
minha função que que eu vouer executar
00:17:29
na minha função a soma de g e h então eu
00:17:32
vou adicionar e colocar em t0 a 0 e a 1
00:17:35
eu tenho aqui a soma de i e j vou
00:17:37
adicionar e colocar em T1 A2 e A3 agora
00:17:41
eu vou fazer a subtração desses dois
00:17:43
valores vou armazenar em s0 que é o
00:17:46
registrador Justamente que eu liberei
00:17:48
espaço aqui em cima para eu poder
00:17:49
colocar essa
00:17:50
conta então aqui essas três linhas aqui
00:17:54
Ed Ed sub são as três linhas em que eu
00:17:57
tô executando a função
00:17:59
principal aqui a instrução da minha
00:18:01
função bom já executei agora eu preciso
00:18:04
configurar o valor de retorno eu vou
00:18:06
colocar no registrador v0 o conteúdo de
00:18:09
s0 como eu não tenho uma instrução de
00:18:11
movimentação eu vou somar o valor de s0
00:18:14
ao meu registrador zero para retornar
00:18:16
para
00:18:18
v0 bom posso retornar pra minha função
00:18:21
ainda não eu preciso restaurar o valor
00:18:23
que eu que eu liberei em s0 então eu vou
00:18:26
fazer um load de s0 usando aqui o
00:18:28
endereço da pilha pro meu Val pro para
00:18:31
recuperar esse valor original Agora eu
00:18:33
preciso ajustar o ponteiro da pilha se
00:18:36
aqui eu subtraí quatro aqui eu vou somar
00:18:38
quatro para voltar paraa posição
00:18:39
anterior e aí Finalmente eu posso dar um
00:18:42
Jump pro endereço que fez essa chamada
00:18:45
de função e retornar a minha posição
00:18:48
original e com isso eu tenho o código em
00:18:50
assembly equivalente a essa minha função
00:18:52
em
00:18:54
si bom o último aspecto aqui pra gente
00:18:57
discutir hoje é resumir os modos de
00:19:00
endereçamento que a gente tem no mips tá
00:19:03
primeiro modo de endereçamento né
00:19:06
pensando lá nas características da
00:19:07
arquitetura do conjunto de instruções é
00:19:09
o que a gente chama de o endereçamento
00:19:11
do imediato ou seja no momento em que eu
00:19:13
tenho uma variável aqui uma constante o
00:19:16
endereço escrito na própria instrução
00:19:19
esse endereço essa informação faz parte
00:19:21
da própria instrução por isso que eu
00:19:23
chamo de endereçamento imediato segunda
00:19:26
forma de endereçamento é através através
00:19:29
do uso de registradores a minha
00:19:30
instrução contém C bits aqui que estão
00:19:33
indicando um registrador onde eu tenho o
00:19:36
meu operando tá então por exemplo se
00:19:38
esse daqui for equivalente ao valor de
00:19:40
t0 eu vou ler o conteúdo de t0 para
00:19:43
poder executar uma instrução sobre esse
00:19:46
registrador então isso cobre as
00:19:48
instruções Lógico aritméticas tá e as
00:19:52
instruções E aí a gente vem então pra
00:19:54
instrução de load Store por exemplo tá
00:19:57
no caso das instruções de load Store eu
00:20:00
vou usar o conteúdo de um registrador
00:20:02
como base por exemplo naquele exemplo da
00:20:04
pilha era o registrador que apontava pro
00:20:06
endereço do topo da pilha e eu preciso
00:20:08
somar um offset aqui para poder chegar
00:20:11
na posição correta esse offset pode ser
00:20:14
zero ou pode ser um valor diferente no
00:20:16
caso das instruções Que A Gente Tá
00:20:18
acessando por exemplo com relação ao
00:20:20
registrador quarto modo de endereçamento
00:20:23
é o que é utilizado nas instruções de
00:20:25
desvio condicional no Branch equ Branch
00:20:28
not equ ao invés de somar com o
00:20:30
registrador geral da minha pilha eu vou
00:20:33
somar com o meu program Counter que é o
00:20:35
registrador que tá apontando PR
00:20:36
instrução e o quinto modo tem a ver com
00:20:39
a instrução de jump como a gente viu a
00:20:41
gente tem 26 bits de endereço aqui a
00:20:44
memória endereçada com 32 bits eu
00:20:46
preciso compor com os qu bits aqui do 28
00:20:49
ao 31 do program Counter aqui para
00:20:52
chegar nos 32 bits que eu vou chegar
00:20:55
para endereçar a memória
00:20:59
último aspecto aqui é a questão da
00:21:00
sincronização tá Ah muitas vezes a gente
00:21:04
tem que fazer algumas operações que são
00:21:05
atômicas por exemplo a troca de dois
00:21:07
valores de registrador se eu tiver dois
00:21:09
processos trabalhando com esses valores
00:21:11
um alimentando e outro lendo isso
00:21:14
implica que eu tenho que ter uma ordem
00:21:15
no acesso dessas informações tá essas
00:21:18
essas essa informação de load e de
00:21:20
história eu não posso atropelar essas
00:21:22
informações e eu preciso do suporte do
00:21:25
Hardware para isso tá no caso do mips a
00:21:28
gente tem duas instruções especiais load
00:21:30
linked e Store conditional essas
00:21:32
instruções elas vão são similares às
00:21:35
instruções de load Store Mas elas
00:21:38
verificam uma condição de mudança e elas
00:21:41
vão usar esse registrador RT para
00:21:44
indicar se houve sucesso ou falha nessa
00:21:46
condição então quando um processo fizer
00:21:48
o load linked né se se algum outro
00:21:53
processo intermediário tentar fazer um
00:21:55
load linked na mesma instrução quando
00:21:57
alguém for fazer um Store com sen isso
00:21:58
vai gerar um sinal de falha então para
00:22:00
fazer um Swap correto eu preciso ter um
00:22:03
código onde além de fazer o load eu vou
00:22:07
verificar a condição Eu tenho o load eu
00:22:10
tenho o Store e aí eu preciso verificar
00:22:13
se a minha condição houve sucesso para
00:22:15
ir poder dar continuidade se houve uma
00:22:17
falha eu tenho que repetir o processo e
00:22:20
refazer o load refazer o Store até que
00:22:22
eu tenha sucesso para garantir a
00:22:23
atomicidade dessa
00:22:26
operação com isso a gente conclui os as
00:22:29
características adicionais da
00:22:30
arquitetura do mips que ainda tá no
00:22:32
Capítulo dois do livro do henes e do
00:22:35
Patterson
00:22:51
[Música]
00:22:58
m
00:23:06
[Música]
