EntÑo, agora vamos comeÑar a falar sobre as coisas fundamentais dentro de
arquitectura do conjunto de instruÑÑes e o coisas que vocÐ precisa para construir dentro de
arquitetura do conjunto de instruÑÑes. E, vamos comeÑar falando
sobre modelos de mÑquinas. EntÑo, eu tenho uma pergunta aqui.
Onde operandos vem? E, onde operandos, onde fazer resultados
ir? EntÑo, quando eu digo, operandos, estes sÑo os
valores de dados que vocÐ estÑ indo para operar em com uma Ð©nica instruÑÑo do processador
e os resultados sÑo em que, e em que os dados que sÑo calculadas, e em que
ele vai. E, este Ð¶ na verdade um conjunto de instruÑÑes
arquitetÐnico, arquitetura, grande oito preocupaÑÑo.
Fundamentalmente, vocÐ vai ter algum forma de unidade lÐ·gica aritmÐ¶tica ou alguma
tipo de unidade de cÑlculo. E vocÐ vai ter algum tipo de
armazenamento de memÐ·ria. E, em um, num processo provavelmente vocÐ estÑ
vai querer levar as coisas a partir do armazenamento, movÐ-lo para a ULA, calcular em
, e depois colocÑ-lo de volta para o armazenamento de alguma forma.
E isto Ð¶, o processador aqui que envolver a ULA, eo modelo de mÑquina
Ð¶, o que Ð¶ a implementaÑÑo, o que Ð¶ a semÐ ntica, ou desculpe-me, nÑo os
aplicaÑÑo, o que Ð¶ a organizaÑÑo dos registros?
Como vocÐ vai acessar a memÐ·ria? Que tipo de instruÑÑes e operaÑÑes
sÑo permitidos? E, vamos falar um pouco sobre,
onde os operandos vem? Onde Ð¶ que os resultados vÑo?
E, modelos de mÑquinas diferentes que as pessoas tÐm construÑdo.
EntÑo, isso Ð¶ diferente de conjunto de instruÑÑes arquiteturas e, e atÐ¶ mesmo mais do que
conjunto de instruÑÑes arquiteturas cuz arquiteturas de conjunto de instruÑÑes falar sobre
como vocÐ codificar instruÑÑes mesmo, este Ð¶ atÐ¶ mesmo um pouco mais fundamental de como
Ð¶ que vocÐ vai, o raciocÑnio sobre como mover dados da memÐ·ria para a ULA e costas.
E, como vocÐ vai fazer e armazenar os dados perto da ULA.
EntÑo, vamos comeÑar com uma muito simplista exemplo aqui, um processador muito simplista
que as pessoas tÐm realmente construÑdo. Acredite ou nÑo, vocÐ nÑo tem que ter
registra em seu processador, ou vocÐ nÑo faz tem que ter registros de nomes na sua
arquitetura do conjunto de instruÑÑes. Em vez disso, vocÐ pode ter uma pilha.
Uma pilha Ð¶ apenas um elemento de armazenamento, onde vocÐ coloca as coisas para a pilha, e depois
eles saem na ordem em que foi a um passado que foi colocado em que foi tomada,
que Ð¶ levado em primeiro lugar. Em vez disso, em um sentido muito bÑsico, sÐ·
tomar as duas melhores coisas na pilha. NÐ·s buscar os dois, operar sobre elas,
e, em seguida, colocar sobre o que seria a parte superior da a pilha.
Construindo, construindo a partir daÑ, pode-se pensar em algo como um acumulador
arquitetura. EntÑo, tipicamente em acumulador arquitetura,
se vocÐ tem um acumulador, entÑo nÑo hÑ apenas um registro, um dos operandos para
cada operaÑÑo que vocÐ faz Ð¶ sempre implÑcito. Tem que vir do acumulador.
A outra, vamos dizer, pode vir de, a partir da memÐ·ria.
EntÑo, vocÐ tem que nomear um dos operandos na arquitetura como essa.
Construindo a partir daÑ, podemos comeÑar pensando em talvez registrar a memÐ·ria
operaÑÑes em que vocÐ vai nomear, digamos, o oper operando, que Ð¶ a fonte,
vamos dizer, vindo de memÐ·ria, e vocÐ vai nome, digamos, um operando vindo
seu arquivo de registo. E, opcionalmente, vocÐ pode atÐ¶ nomear o
destino. Portanto, estes sÑo tudo, estes sÑo todas as opÑÑes,
e nÐ·s vamos chamar isso de um registro de memÐ·ria arquitetura.
Finalmente, temos algo como um registrar, registar arquitetura.
EntÑo, ninguÐ¶m quer apostar um palpite aqui, como muitos operandos nomeados que temos aqui?
TrÐs. Ok, sim.
E assim, esta foto aqui, vamos ter algo de um registo, algo
de outro registo, e nÐ·s temos que nomear para onde ir colocÑ-lo.
EntÑo, Ð¶ isso, Ð¶ isso, eu queria salientar aqui, na verdade, o nÐ©mero de explicitamente
chamado operandos. Para alguns destes, Ð¶, Ð¶ um pouco
mais questionÑvel do que outros. EntÑo, como vocÐ vÐ aqui, temos zero, temos
um pouco de algo mais complicado, onde que tÐm um, dois, ou trÐs.
Agora, como eu, por que eu dizer duas ou trÐs aqui?
Assim, nÑo hÑ, alguns desses arquiteturas ou modelos de arquitetura nÑo necessariamente
citar a resultante, ou o resultado localizaÑÑo.
Alguns deles implicitamente nomear o resultar.
EntÑo, algo como 86 por exemplo, o operando fonte Ð¶ sempre o primeiro
destino. EntÑo, tem que apenas citar duas coisas.
Algo como MIPS, ou mais de risco, a maioria arquiteturas realmente o nome de todos
trÐs. E vocÐ pode pensar sobre isso acontecendo para
memÐ·ria e um registrador, registar arquitetura.
EntÑo, um bom exemplo de um operando trÐs memÐ·ria de memÐ·ria, que eu nÑo tenho desenhado
aqui. Este Ð¶ apenas, eu sÐ· tenho a memÐ·ria de registo
feita aqui. Mas a memÐ·ria de memÐ·ria, que basicamente diz:
todos os seus operandos vir da memÐ·ria e tudo seus destinos estÑo na memÐ·ria Ð¶
algo como a arquitetura VAX que era popular nos anos 70.
VocÐ realmente pode ter todos os seus operandos vir da memÐ·ria, fazer alguma operaÑÑo em
eles, e armazenÑ-lo de volta na memÐ·ria. EntÑo, um comÐ¶rcio interessante aqui Ð¶ que fora
uma vez que vocÐ comeÑar a ter mais operandos que explicitamente nomeado, vocÐ precisa de mais de codificaÑÑo
espaÑo para isso. E este Ð¶ um dos mais importantes
trade-offs. Okay.
EntÑo, vamos, vamos entrar em um pouco de profundidade sobre pilha arquitetura baseada.
Assim, alguns exemplos disso sÑo, na verdade, Burrough de 5000.
As mÑquinas foram Symbolics baseada em pilha, e estes sÑo uma espÐ¶cie de mÑquinas da
passado. HÑ alguns moderno ou mais moderno
exemplos disso. Por exemplo, o Java Virtual Machine Ð¶
na verdade arquitectura de uma pilha. E depois, tambÐ¶m, da Intel ponto flutuante de idade
sistema, x87. Desde entÑo eles espÐ¶cie de, depreciado isso,
mas ainda Ð¶ relativamente moderna como um pilha de arquitetura baseada em conjunto de instruÑÑes.
Vamos ter um conjunto de instruÑÑes baseado em pilha arquitetura e olhada em como vocÐ pode ir
sobre a avaliaÑÑo de uma expressÑo. EntÑo, temos aqui uma expressÑo, um b mais
c vezes, todos em parÐnteses, que todo quantidade, dividido por um d mais vezes c
e de menos. EntÑo, Ð¶ uma matemÑtica complexa, em,
operaÑÑo de instruÑÑo, ou matemÑtica que precisa fazer.
Aqui, nÐ·s realmente quebrar isso em um analisar desta Ñrvore.
VocÐ pode ver, este Ð¶ preservar SRO operaÑÑes.
NÐ·s temos uma vantagem, esta quantidade sub-aqui, b c vezes.
E, vocÐ tomar tudo isso e dividi-lo por esta subexpressÑo aqui.
E pouco, pouco de um regresso aqui, este Ð¶ um caminho que vamos tomar a
operaÑÑes. E, se fizermos essas operaÑÑes em uma pilha
modelo de mÑquina, nÐ·s estamos indo para obter o resultado certo.
EntÑo, o que isto significa Ð¶, colocar um sobre o empilhar, colocar b na pilha, colocar no c
pilha, e depois multiplicar. B vezes c, e em seguida, adicione as vezes os resultados
um. E, vocÐ pode ver que nÐ·s vamos construir
esta expressÑo em uma, sobre uma pilha. EntÑo, Ð¶ uma espÐ¶cie de caminho, diferente para classificar
de, repensar sobre os problemas. E, vamos, vamos percorrer um exemplo
aqui. EntÑo, aqui, temos uma pilha de avaliaÑÑo.
E, no topo da pilha serÑ tudo o que Ð¶ em cima aqui neste
imagem. EntÑo, primeira coisa, nÐ·s vamos fazer Ð¶
vamos dizer, empurrar um. Assim, mostra-se uma sobre a pilha.
EntÑo, nÐ·s estamos indo para empurrar b, vamos para empurrar c, e entÑo nÐ·s vamos fazer uma
multiplicar. EntÑo, nÐ·s vamos tomar as duas entradas
que estÑo no topo da pilha, multiplicar -los e colocÑ-los em esta entrada no
empilhar. EntÑo, vamos dizer, acrescentar, e Ð¶
vai adicionar as duas coisas principais em uma pilha aqui, e colocar o resultado aqui.
E, vocÐ pode ver que se vocÐ executar algo como este, vocÐ pode realmente fazer pleno
cÑlculos sobre uma pilha muito pequena. E, o que tambÐ¶m Ð¶ bom aqui Ð¶ que vocÐ nÑo
tem que explicitamente nomear qualquer um dos operandos.
Assim, este modelo de equipamento permite, para executar programas reais.
E, uma das coisas que eu quero toda aqui Ð¶ que a pilha Ð¶ parte do
o estado do processador, e Ð¶ normalmente, entÑo que Ð¶ a instruÑÑo Um grande, grande ou uma
arquitetura, ou o conjunto de instruÑÑes arquitetura.
VocÐ tem uma pilha, e muitas vezes Ð¶ ilimitada na arquitetura Um grande.
Mas, na vida real, ele precisa ser limitado de alguma forma, porque vocÐ nÑo pode ter infinitamente
longos, pilhas fÑsicas em sua mÑquina. EntÑo, Ð¶ conceitualmente ilimitado, mas vocÐ
provavelmente vai querer ter transbordar a principal memÐ·ria, se vocÐ colocar muitas coisas no
empilhar. E este Ð¶, este Ð¶ um importante
caracterÑsticos vezes cuz outros, caso contrÑrio, existem certas computaÑÑes VocÐ nÑo pode
fazer. Se, por exemplo, a Ñrvore de anÑlise Ð¶ demasiado
desde aqui, ou a, a profundidade da Ñrvore Ð¶ muito tempo, o de pilha pode, pode crescer
muito longo. Okay.
EntÑo, vamos dizer, nÐ·s temos um micro-arquitetura de implementaÑÑo de um
arquitectura do conjunto de instruÑÑes, o qual Ð¶ um baseado em pilha arquitetura.
E, os dois primeiros elementos da pilha sÑo mantida em registros, eo resto estÑ na principal
memÐ·ria, e ele derrama e preenchimentos. Bem, cada impulso tem uma referÐncia de memÐ·ria.
EntÑo, quando vocÐ coloca algo na pilha, ele tem uma referÐncia de memÐ·ria.
E, cada pop, tem uma memÐ·ria de referÐncia cuz vocÐ sÐ· precisa colocar algo de novo
memÐ·ria principal. Mas, mais do que isso, vocÐ pode ter
extras referÐncias de memÐ·ria aqui, como a pilha transborda para a memÐ·ria principal, e vocÐ
pode ter que puxar algo de volta a partir memÐ·ria principal.
EntÑo, isso nÑo Ð¶, porque nÑo Ð¶ muito bom vocÐ pode acabar com um empurrÑo ter mais de
um nÐ©mero de referÐncia. EntÑo, uma otimizaÑÑo de um
micro-arquitetura perspectiva, vocÐ poderia pensar em ter N elementos do seu
empilhar em registos muito perto do processador, e sÐ· tem que ir de acesso principal
memÐ·ria quando a pilha estoura registro e underflows.
Assim, em vez de ter que fazer uma memÐ·ria referÐncia, basicamente, a cada momento
vocÐ faz uma operaÑÑo ou a cada momento vocÐ faz um empurrÑo ou um pop, vocÐ fazÐ-lo apenas
quando a profundidade da pilha fica muito grande, que vocÐ nÑo pode caber tudo no seu stack.
EntÑo, vamos, vamos caminhar por um breve exemplo aqui.
NÐ·s temos a mesma expressÑo de cÑlculo, que estamos fazendo antes.
E, vocÐ pode ver, o que podemos fazer, empurrar, empurrar, empurrar, multiplicar, somar, empurrar, empurrar, empurrar,
multiplicar, somar, empurrar e, subtrair e fazer todas as divisÑes no final.
Mas, se temos uma pilha de dois, o que vai acontecer aqui Ð¶, ao
comeÑando, estamos apenas indo, vocÐ sabe, quando fazemos um esforÑo, nÐ·s vamos fazer um
carregar de um, empurrar, vamos fazer uma carga a partir de b.
Agora, nÐ·s fazemos um esforÑo de carga de c, mas a nossa pilha jÑ tem duas coisas sobre ele.
EntÑo, se estamos a tentar empurrar a terceira coisa, nÐ·s ter de transbordamento na parte inferior da pilha
em algum lugar. EntÑo, nÐ·s estamos realmente vai fazer uma pilha
salvar de uma para a memÐ·ria principal. Aqui, fazemos isso se multiplicam, e nÐ·s realmente
se buscar uma pilha de um e obtÐ-lo de volta a memÐ·ria principal.
EntÑo, Ð¶ uma sÐ¶rie de operaÑÑes de memÐ·ria extra. Assim, vocÐ pode querer pensar em um diferente
micro-arquitetura. E se vocÐ espÐ¶cie de, caminhar por este
exemplo inteiro aqui, vamos ver que temos quatro lojas e quatro obtÐ¶m
a partir da memÐ·ria principal, os quais sÑo todos implÑcita, mais explÑcitas as que nÐ·s estamos tentando
a ver com o empurra e pops. Hm, bem que Ð¶ oito memÐ·ria extra
operaÑÑes. Quando pensamos sobre como construir um
micro-arquitetura que tem menos, mas tem o conjunto de instruÑÑes exatamente o mesmo
arquitetura. Bem, vamos dizer, temos uma mÑquina que
tem um tamanho de pilha de quatro. Bem, se o tamanho da pilha Ð¶ um quatro, no
pior caso aqui, nÐ·s vamos sempre tem que caber quatro coisas na nossa pilha.
EntÑo, nÐ·s nunca temos que, derramar a principal memÐ·ria de nossa pilha.
Empurra e aparece ainda tem para acessar memÐ·ria, mas isso Ð¶ o que eles estÑo tentando
fazer. Eles estÑo realmente tentando acessar a memÐ·ria.
EntÑo, para resumir aqui sobre baseada em pilha modelos de mÑquinas, eles olham, olham
muito legal. Mas, nÑo, nem todas as coisas sÑo, sÑo em grande
todas as vezes. EntÑo, um dos, as coisas interessantes
aqui para ver Ð¶ que nÐ·s realmente empurrar, e nÐ·s empurrar um novo.
EntÑo, nÐ·s estamos fazendo um trabalho redundante. E nÐ·s empurrar c, e nÐ·s empurrar C novamente.
C e A tÐm o mesmo valor em ambas as vezes nÐ·s empurrÑ-los.
EntÑo, de repente, estamos fazendo extras trabalho e talvez poderÑamos ter feito menos
trabalhar se tivÐ¶ssemos uma arquitetura ou mÑquina modelo, uma arquitetura Um grande, o que permite
armazenar vÑrias coisas e nome operandos diferentes.
EntÑo, o que eu quero passar aqui Ð¶, enquanto uma arquitetura baseada em pilha Ð¶ muito
simples, as instruÑÑes sÑo muito densa, o, pode nÑo ser bom para o desempenho
porque vocÐ pode acabar tendo que recarregar valores vÑrias vezes.
Versus, conjunto de instruÑÑes se vocÐ tivesse arquitetura, algo como MIPS, onde
vocÐ realmente tem 32 de uso geral registros e vocÐ pode citar qualquer registro
para qualquer instruÑÑo, que poderia ter carregado a, b, c, d, e e todos no registo
espaÑo, uma vez, e em seguida, fez todo o seu operaÑÑes e nunca tive que recarregar.
E, esta Ð¶ realmente uma instruÑÑo sett questÑo e nÑo, ou uma mÑquina fundamentais
questÑo do modelo, e nÑo uma arquitetura de micro- questÑo.
Okay. Assim, para resumir modelos de mÑquinas diferentes,
temos a nossa pilha, acumulador, registo e memÐ·ria, e se inscrever, registrar,
por vezes chamado de arquitetura armazenamento de carga. Se queremos levar alguma expressÑo aqui,
gosta, c Ð¶ igual a um b mais, podemos olhar para as instruÑÑes que teriam de ser
gerado em uma arquitetura abstrata. EntÑo, aqui, nÐ·s vamos ter um empurrar, empurre
b, adicionar, pop c. â medida que adicionar mais nomes, nÐ·s realmente podemos,
potencialmente, tÐm menos registros, ou menos instruÑÑes, desculpe-me.
EntÑo, temos de carregar um, adicione b. Note-se aqui, nÑo temos para citar o que
estamos adicionando com cuz estamos adicionando com acumulador.
E entÑo, loja c. ComeÑam a ficar um pouco mais compacto.
Se temos registar memÐ·ria, podemos carregar um dos valores, adicionar, armazenar, Ð¶ muito
simples. Se queremos carregar arquitetura loja, nÐ·s
realmente tem que fazer um pouco mais trabalhar.
Temos que carregar, carregar, adicionar, armazenar. Mas, o que, o que parece ser ineficiente, mas
se vocÐ tiver que reutilizar qualquer desses valores a, b, vocÐ nÑo tem que ir recarregÑ-los.
Versus, nestas duas arquiteturas vocÐ tem que ir recarregar o valor.