
Korean: 
안녕하세요. Carrie Anne입니다. Crash Course 컴퓨터 과학에 오신걸 환영합니다.
이 시리즈를 통해서 알아봤듯이,
컴퓨터는 1초에 1개 정도 계산할 수 있는
 기계적인 장치에서 부터
킬로헤르츠나 메가헤르츠의 속도로 동작하는
 CPU에 이르기까지 오랜 시간 동안 발전해왔습니다.
여러분이 지금 이 비디오를 보고 있는 장치는 
거의 다 기가헤르츠의 속도로 동작하고 있습니다.
매 초 수십억개의 명령어가 실행되지요.
어마어마한 계산량입니다.
전자식 컴퓨터의 초기에는
칩 내부의 트랜지스터의 스위칭 시간을 개선함으로써 
프로세서의 속도를 빠르게 했습니다.
칩 내부의 트랜지스터의 스위칭 시간을 개선함으로써 
프로세서의 속도를 빠르게 했습니다.
이전 에피소드들에서 배운 논리 게이트와 ALU를 포함한 모든 부품들이 트랜지스터들로 구성되기 때문입니다.
그런데, 트랜지스터를 빠르고 효율적으로 만드는 것만이 다가 아닙니다.
프로세서 개발자들은 단순히 명령어를 
빠르게 처리하는 것 뿐만 아니라,
훨씬 더 복잡한 동작을 통해서 성능을 늘릴 수 있는 
다양한 기술을 개발해왔습니다.
 

Portuguese: 
Oi, eu sou a Carrie Anne e sejam bem vindos ao Crash Course de Ciência da Computação!
Como mostramos durante esse curso, os computadores percorreram um longo caminho de dispositivos
mecânicos capazes de fazer algo como um cálculo por segundo para CPUs rodando a quilo-hertz ou mega-hertz
O dispositivo que você está usando agora para assistir esse vídeo quase certamente está rodando a velocidades
Gigahertz, ou seja bilhões de instruções a cada segundo. O que, acredite, é muita computação!
Nos primórdios da computação eletrônica, os processadores ficavam mais rápidos melhorando
o tempo de  chaveamento dos transistores contidos no chip – Responsáveis por todas portas
lógicas, ALUs e tudo mais que falamos nos últimos episódios.
Mas isso só é possível até certo ponto, então os projetistas de processadores
desenvolveram várias técnicas para melhores a performance permitindo não apenas que instruções simples fossem
executadas mais depressa, mas também executando operações bem mais sofisticadas
INTRODUÇÃO

English: 
Hi, I’m Carrie Anne and welcome to CrashCourse
Computer Science!
As we’ve discussed throughout the series,
computers have come a long way from mechanical
devices capable of maybe one calculation per second, to CPUs running at kilohertz and megahertz speeds.
The device you’re watching this video on
right now is almost certainly running at Gigahertz
speeds - that’s billions of instructions
executed every second.
Which, trust me, is a lot of computation!
In the early days of electronic computing,
processors were typically made faster by improving
the switching time of the transistors inside
the chip - the ones that make up all the logic
gates, ALUs and other stuff we’ve talked
about over the past few episodes.
But just making transistors faster and more
efficient only went so far, so processor designers
have developed various techniques to boost
performance allowing not only simple instructions
to run fast, but also performing much more
sophisticated operations.
INTRO

Korean: 
지난 에피소드에서 우리 CPU가 두 개의 숫자를 나누기 할 수 있는 작은 프로그램을 만들어 보았습니다.
연속으로 빼기를 여러번 해서 나누기를 만들었습니다.
예를 들어 16 나누기 4는 16 - 4, - 4, - 4, - 4 로
 쪼갤 수 있죠.
0이나 음수가 되면, 끝났다는 것을 알 수 있습니다.
그런데, 이 방법은 많은 클락 사이클이 소비되고,
 특별하게 효율적이지는 않습니다.
그래서 요즘 대부분 컴퓨터 프로세서는 ALU에서 하드웨어로 처리하는 하나의 명령어로 나누기를 갖고 있습니다.
그래서 요즘 대부분 컴퓨터 프로세서는 ALU에서 
하드웨어로 처리하는 명령어에 나누기를 갖고 있습니다.
물론 이런 부가 회로들이 ALU의 크기를 크게,
설계를 복잡하게 만들지요.
하지만 CPU를 더 능력있게 만들죠.
컴퓨터 역사에서 복잡도와 속도 사이의 협정(tradeoff)은 여러 번 있어왔습니다.
예를 들어, 현대 컴퓨터 프로세서는 
특수 회로들을 갖고 있습니다.
그래픽 처리, 압축 비디오 복원,
 파일 암호화 같은 일을 처리하는 것들이죠.
이런 모든 기능들은 표준적인 동작들로 수행하려먼 
어마어마한 클럭 사이클이 필요합니다.
MMX, 3DNow나 SSE 기능이 탑재된 
프로세서를 들어봤을 수도 있습니다.
이런 프로세서들은 게임이나 암호화 같은
 일들을 위해서 추가된

English: 
Last episode, we created a small program for
our CPU that allowed us to divide two numbers.
We did this by doing many subtractions in
a row... so, for example, 16 divided by 4
could be broken down into the smaller problem
of 16 minus 4, minus 4, minus 4, minus 4.
When we hit zero, or a negative number, we
knew that we we’re done.
But this approach gobbles up a lot of clock
cycles, and isn’t particularly efficient.
So most computer processors today have divide
as one of the instructions that the ALU can
perform in hardware.
Of course, this extra circuitry makes the
ALU bigger and more complicated to design,
but also more capable - a complexity-for-speed
tradeoff that has been made many times in
computing history.
For instance, modern computer processors now
have special circuits for things like graphics
operations, decoding compressed video, and
encrypting files - all of which are operations
that would take many many many clock cycles
to perform with standard operations.
You may have even heard of processors with
MMX, 3DNow!, or SSE.
These are processors with additional, fancy
circuits that allow them to execute additional,

Portuguese: 
No último episódio nós criamos um pequeno programa para nossa CPU que nos permitiu dividir dois números
Nós fizemos isso executando várias subtrações em sequência, então por exemplo 16 dividido por 4
pode ser dividido em vários problemas menores de 16 menos 4, menos 4, menos 4, menos 4
Quando chegamos a zero, ou a um número negativo, nós sabemos que terminamos
Mas essa abordagem consome muitos ciclos de processamento e isso não é muito eficiente
Então a maioria dos processadores hoje em dia tem a divisão como uma das instruções que a ALU pode executar via hardware
Claro que esses circuitos adicionais deixam a ALU maior e mais difícil de projetar
Mas também mais poderosa – uma escolha entre uma complexidade/velocidade que aparece várias vezes na
história da computação
Os processadores hoje em dia tem circuitos especiais para gráficos
decodificar vídeo, criptografar arquivos – Todas essas tarefas
tomariam muitos, mas muitos ciclos de processamento se fossem feitas com instruções convencionais
você deve ter ouvido falar de processadores com MMX, 3DNow! Ou SSE
Esses são processadores com circuitos extra que permitem que eles executem operações instruções

Portuguese: 
adicionais para coisas como jogos e criptografia
Essas extensões ao conjunto de instruções cresceram ao longo do tempo e uma vez que as pessoas escreveram programas
que a usavam é difícil removê-las
Então o conjunto de instruções tende a ir ficando cada vez maior por manter todos os opcodes antigos
para manter a compatibilidade com os programas antigos
A Intel 4004, a primeira CPU realmente integrada, tinha 46 instruções que eram suficientes
para construir um computador totalmente funcional
Mas um processador de computador moderno tem milhares de diferentes instruções que utilizam vários
tipos de circuitos inteligentes e complexos
Agora, altas velocidades de clock e conjuntos de instruções legais levaram a um outro problema – trazer e levar
dados de e para a CPU com velocidade suficiente
É como ter uma locomotiva muito poderosa, mas não conseguir jogar carvão rápido o suficiente
nesse caso o gargalo é a RAM
A RAM em geral é um módulo de memória que fica fora da CPU
Isso significa que os dados precisam ser transmitidos de e para a RAM em conjuntos de trilhas, chamados de barramentos
Essas vias tem apenas alguns centímetros de comprimento, mas lembrem-se que esses sinais elétricos
viajam quase na velocidade da luz, quando você funciona em velocidade gigahetz, ou seja

Korean: 
근사한 명령어들을 수행할 수 있는 근사한 회로들이 
같이 들어있는 것입니다.
이렇게 명령어 집합의 확장이 계속 이어 지고 있습니다.
확장된 명령어들을 사용해서 프로그램하는데 
이득을 한 번 보게 되면, 이것을 없애기는 힘들어집니다.
그래서 명령어 집합은 점점 커지는 경향이 있어요.
오래된 opcode들과 호환성을 유지하면서 말이죠.
최초의 진정한 집적 CPU인 Intel 4004는 46개의 명령어를 갖고 있었습니다.
완벽하게 동작하는 컴퓨터가 되기에 충분했습니다.
하지만 현대 컴퓨터 프로세서는 
수천개의 명령어를 갖고 있습니다.
똑똑하고 복잡한 내부 회로들이 모든 종류를 활용하고 있지요.
빠른 클럭 속도와 근사한 명령어 집합이 
이제 또다른 문제를 유발시킵니다.
CPU로 데이터를 가져오거나 내보내는 것이 
충분히 빠를 수 있냐는 것입니다.
마치 힘 센 증기기관차가 있지만,
석탄을 빠르게 삽질해서 넣지 못하는 것과 같습니다.
이 경우, RAM이 병목 지점 이지요.
RAM은 CPU 밖에 있는 메모리 모듈입니다.
즉, 데이터는 버스라고 하는 데이터 선들을 통해서 RAM으로 전달되거나 RAM으로 부터 가져와야 한다는 것입니다.
즉, 데이터는 버스라고 하는 데이터 선들을 통해서 RAM으로 전달되거나 RAM으로 부터 가져와야 한다는 것입니다.
버스의 길이는 몇 cm일수도 있지만, 기억해 보십시오. 
전기 신호는 빛의 속도로 움직이고,
CPU는 기가 헤르츠의 속도로 (초당 수십억개) 
작동하기 때문에,

English: 
fancy instructions - for things like gaming
and encryption.
These extensions to the instruction set have
grown, and grown over time, and once people
have written programs to take advantage of
them, it’s hard to remove them.
So instruction sets tend to keep getting larger
and larger keeping all the old opcodes around
for backwards compatibility.
The Intel 4004, the first truly integrated
CPU, had 46 instructions - which was enough
to build a fully functional computer.
But a modern computer processor has thousands
of different instructions, which utilize all
sorts of clever and complex internal circuitry.
Now, high clock speeds and fancy instruction
sets lead to another problem - getting data
in and out of the CPU quickly enough.
It’s like having a powerful steam locomotive,
but no way to shovel in coal fast enough.
In this case, the bottleneck is RAM.
RAM is typically a memory module that lies
outside the CPU.
This means that data has to be transmitted
to and from RAM along sets of data wires,
called a bus.
This bus might only be a few centimeters long,
and remember those electrical signals are
traveling near the speed of light, but when
you are operating at gigahertz speeds – that’s

Korean: 
이런 자그마한 지연도 문제를 발생시키게 됩니다.
게다가 RAM은 주소를 보고 데이터를 찾아와서
출력시키는데 시간이 필요합니다.
게다가 RAM은 주소를 보고 데이터를 찾아와서
출력시키는데 시간이 필요합니다.
그래서 "RAM에서 LOAD"하는 명령어는 완료되는데 
수십 클락 사이클이 필요할 수도 있고,
이 시간 동안 프로세서는 데이터를 기다리면서 
앉아서 놀고 있게됩니다.
이를 해결하는 방법으로 캐쉬(cache)라고 하는 
작은 RAM 조각을 CPU 안에 넣는 것입니다.
프로세서 칩의 공간이 그리 크지 않기 때문에, 대부분의 캐쉬는 kilobyte에서 megabyte의 크기를 갖습니다.
반면에 RAM은 gigabyte를 보통 사용하지요.
캐쉬를 갖게되면, 똑똑한 방법으로 스피드를 올릴 수가 있씁니다.
CPU가 메모리에 한 위치를 접근할 때, RAM은 전체 데이터 블록 중에 달랑 값 한개를 전달할 수 있습니다.
CPU가 메모리에 한 위치를 접근할 때, RAM은 전체 데이터 블록 중에 달랑 값 한개를 전달할 수 있습니다.
값 1개만 가져오는 것 보다 시간이 조금 더 걸릴 수 있지만, 캐쉬에 데이터 블럭 전체를 저장하도록 해봅시다.
값 1개만 가져오는 것 보다 시간이 조금 더 걸릴 수 있지만, 캐쉬에 데이터 블럭 전체를 저장하도록 해봅시다.
이게 굉장히 도움이 되는데요. 그 이유는 컴퓨터 데이터는 종종 잘 정리돼 있고 순차적으로 처리되기 때문입니다.
예를 들어, 프로세서가 식당의 일일 매상의 
총합을 계산하는 일을 한다고 합시다.
RAM의 주소 100번지로부터 첫번째 거래정보를 
fetch하는 것부터 시작합니다.
RAM은 값 1개만 보내지 않고 100번지에서 200번지까지의 데이터 블럭 전체를  보내서 캐쉬에 복사시킵니다.

Portuguese: 
bilionésimos de segundo, mesmo um pequeno atraso se torna problemático
Além disso a RAM leva tempo para procurar pelo endereço, buscar o dado e se configurar para enviar o resultado
Uma instrução 'load from ram'  pode levar dezenas de ciclos de processamento para ser executada e enquanto isso
o processador fica para esperando pelos dados
Uma solução é colocar uma pequena parte da RAM – chamada de cache - direto na CPU.
Não há muito espaço no chip do processador, por isso a maior parte dos caches tem apenas alguns kilobytes ou
megabytes de tamanho, enquanto a RAM normalmente tem Gigabytes
Um cache acelera a CPU de uma maneira bem inteligente
Quando a CPU solicita um endereço de memória da RAM, a RAM pode transmitir não um único valor, mas um bloco de dados
Isso toma apenas um pouco mais de tempo do que transmitir um único valor, mas permite
que esse bloco de dados seja guardado no cache
Isso é muito útil por que os dados frequentemente são organizados e processados de uma forma sequencial
Por exemplo, vamos imaginar que o processador está totalizando as vendas diárias de um restaurante
Ele começa buscando a primeira transação da RAM no endereço de memória 100
A RAM, ao invés de enviar apenas esse valor envia um bloco de dados, do endereço

English: 
billionths of a second – even this small
delay starts to become problematic.
It also takes time for RAM itself to lookup
the address, retrieve the data, and configure
itself for output.
So a “load from RAM” instruction might take
dozens of clock cycles to complete, and during
this time the processor is just sitting there
idly waiting for the data.
One solution is to put a little piece of RAM
right on the CPU -- called a cache.
There isn’t a lot of space on a processor’s
chip, so most caches are just kilobytes or
maybe megabytes in size, where RAM is usually
gigabytes.
Having a cache speeds things up in a clever
way.
When the CPU requests a memory location from
RAM, the RAM can transmit not just one single
value, but a whole block of data.
This takes only a little bit more time than
transmitting a single value, but it allows
this data block to be saved into the cache.
This tends to be really useful because computer
data is often arranged and processed sequentially.
For example, let say the processor is totalling
up daily sales for a restaurant.
It starts by fetching the first transaction
from RAM at memory location 100.
The RAM, instead of sending back just that
one value, sends a block of data, from memory

Portuguese: 
100 até o 200, todos os valores são copiados para o cache
Agora, quando o processador solicitar a próximo valor para adicionar ao subtotal
o valor do endereço 101 o cache vai dizer, Hum, já tenho esse valor aqui, então posso te mandar ele direto
E não é necessário ir até a RAM
Por que o cache está bem perto do processador, geralmente ele pode enviar o dado em um único
ciclo de processamento – não é preciso esperar
Isso acelera as coisas imensamente ao invés de ter que ficar indo e voltando à RAM toda vez
Quando os dados solicitados já estão armazenados no cache, isso se chama cache hit (Acertou o cache)
e se o dado não estiver no cache e você tiver que ir até a RAM isso é chamado de cache miss (Errou o cache)
O cache é usado também como uma área de rascunho, armazenando valores intermediários enquanto executa
algum cálculo longo ou complicado
Continuando nosso exemplo do restaurante, vamos dizer que o processador terminou de totalizar
todas as vendas do dia, e quer armazenar o valor no endereço 150
Como antes, ao invés de voltar à RAM para salvar esse valor ele pode armazenar
na cópia do cache, o que é mais rápido e também mais fácil para ler depois se mais algum cálculo for necessário

English: 
location 100 through 200, which are then all
copied into the cache.
Now, when the processor requests the next
transaction to add to its running total, the
value at address 101, the cache will say “Oh,
I’ve already got that value right here,
so I can give it to you right away!”
And there’s no need to go all the way to
RAM.
Because the cache is so close to the processor,
it can typically provide the data in a single
clock cycle -- no waiting required.
This speeds things up tremendously over having
to go back and forth to RAM every single time.
When data requested in RAM is already stored
in the cache like this it’s called a cache
hit,
and if the data requested isn’t in the cache,
so you have to go to RAM, it’s a called
a cache miss.
The cache can also be used like a scratch
space, storing intermediate values when performing
a longer, or more complicated calculation.
Continuing our restaurant example, let’s
say the processor has finished totalling up
all of the sales for the day, and wants to
store the result in memory address 150.
Like before, instead of going back all the
way to RAM to save that value, it can be stored
in cached copy, which is faster to save to,
and also faster to access later if more calculations
are needed.

Korean: 
RAM은 값 1개만 보내지 않고 100번지에서 200번지까지의 데이터 블럭 전체를  보내서 캐쉬에 복사시킵니다.
그러면, 프로세서가 총합을 계산하기 위해 
101번지에 있는 다음 거래 정보를 요청할 때
캐쉬는 "내가 이미 갖고 있으니까 바로 줄게" 라고 
CPU에 말할 것입니다.
캐쉬는 "내가 이미 갖고 있으니까 바로 줄게" 라고 
CPU에 말할 것입니다.
따라서, RAM까지 가야할 필요가 없습니다.
캐쉬는 프로세서에 딱 붙어 있기 때문에, 
데이터를 한 클럭 사이클에 보내줄 수가 있습니다.
기다릴 필요가 없지요.
이 방법이 매번 RAM을 왔다갔다할 때보다 무시무시하게 속도를 향상시킬 수 있습니다.
RAM에 요청할 데이터가 
이미 캐쉬에 저장되어 있는 경우를
캐쉬 히트 (Cache hit)라고 합니다.
반대로 캐쉬에 요청한 데이터가 없는 경우는 
RAM까지 가야만 합니다.
이것을 캐쉬 미스 (Cache miss)라고 합니다.
캐쉬는 길고 복잡한 계산을 할 때 중간 값들을 저장하는 임시 저장소로도 사용할 수가 있습니다.
캐쉬는 길고 복잡한 계산을 할 때 중간 값들을 저장하는 임시 저장소로도 사용할 수가 있습니다.
식당 예제를 계속해보지요. 프로세서가 하루 전체 매출 
계산을 끝냈다고 합시다.
그리고 결과를 150번지에 저장한다고 해보지요.
마찬가지로 이 값을 저장하기 위해서 RAM까지 가는 것 대신에, 캐쉬에 저장할 수 있습니다.
그게 저장이 더 빠르고, 나중에 계산이 더 필요하면 
더 빨리 접근할 수 있게 됩니다.
그게 저장이 더 빠르고, 나중에 계산이 더 필요하면 
더 빨리 접근할 수 있게 됩니다.

Korean: 
그런데, 이 상황이 흥미로운 문제를 일으킵니다.
캐쉬에 복사된 데이터와 
실제 RAM에 있는 데이터가 달라진 것이지요.
이렇게 발생한 불일치는 반드시 기록해 두어야지, 
특정 시간에 동기를 맞출 수가 있습니다.
이 목적으로, 캐쉬는 저장된 각 메모리 블럭에 대한 특별한 플래그가 있습니다.
dirty 비트라고 하는데요. 컴퓨터 과학자들이 만들어낸 
용어 중에 최고인 것 같아요.
캐쉬가 꽉 차있고, 
프로세서가 새로운 메모리 블락을 요청할 때
동기화가 제일 빈번하게 일어납니다.
캐쉬가 오래된 블럭을 지워서 공간을 확보하기 전에 
dirty 비트를 체크하고,
dirty 하면, 새 블럭을 옮겨오기 전에 우선 오래된 블록을 RAM에 옮겨 적습니다.
CPU 성능을 올릴 수 있는 다른 트릭은 
명령어 파이프라이닝이라는 것입니다.
여러분이 호텔 전체의 이불을 빨래해야 하는데
세탁기와 건조기가 한대 씩만 있다고 생각해 봅시다.
첫 번째 옵션은 모든 일을 순차적으로 하는 겁니다. 이불 한 묶음을 세탁기에 넣고 끝날 때까지 30분 기다립니다.
첫 번째 옵션은 모든 일을 순차적으로 하는 겁니다. 이불 한 묶음을 세탁기에 넣고 끝날 때까지 30분 기다립니다.
그리고 나서 젖은 이불을 꺼내서 건조기에 넣고 
끝날 때까지 30분을 또 기다리는 것이지요.
그리고 나서 젖은 이불을 꺼내서 건조기에 넣고 
끝날 때까지 30분을 또 기다리는 것이지요.
한 시간에 이불 한 묶음 처리할 수 있습니다.
여담이지만, 빨래 한 무더기를 30분 만에 건조할 수 있는 건조기가 있다면

Portuguese: 
Mas isso criar um problema interessante – a cópia do dado no cache agora é diferente da versão real, armazenada na RAM
Essa diferença tem que ser lembrada para que em algum ponto tudo possa ser sincronizado
Para isso o cache tem um sinalizador para cada bloco que ele armazena, chamado
de dirty bit (bit de sujeira), que deve ser o melhor nome que os cientistas da computação já inventaram.
Geralmente essa sincronização acontece quando o cache está cheio e um bloco de memória é solicitado pelo processador
Antes do cache apagar o bloco antigo para liberar espaço, ele verifica o dirty bit e se
estiver "sujo" (ligado)  o bloco antigo é gravado na RAM antes de carregar o novo
Outro truque para melhor o desempenho da CPU é chamado de enfileiramento de instruções
Imagine que você tem que lavar todos os lençóis de um hotel, mas você tem apenas uma lavadora e uma secadora
Uma opção seria fazer tudo em sequência: Colocar uma trouxa de lençóis na lavadora e esperar 30 minutos até ela terminar
Então tirar os lençóis e colocá-los na secadora e esperar outros 30 minutos até ela terminar
Dessa forma você vai terminar uma leva de lençóis por hora
Nota: Se você tiver uma secadora que pode secar uma leva de roupas em 30 minutos, por favor me diga

English: 
But this introduces an interesting problem
-- the cache’s copy of the data is now different
to the real version stored in RAM.
This mismatch has to be recorded, so that
at some point everything can get synced up.
For this purpose, the cache has a special
flag for each block of memory it stores, called
the dirty bit -- which might just be the best
term computer scientists have ever invented.
Most often this synchronization happens when
the cache is full, but a new block of memory
is being requested by the processor.
Before the cache erases the old block to free
up space, it checks its dirty bit, and if
it’s dirty, the old block of data is written
back to RAM before loading in the new block.
Another trick to boost cpu performance is
called instruction pipelining.
Imagine you have to wash an entire hotel’s
worth of sheets, but you’ve only got one
washing machine and one dryer.
One option is to do it all sequentially: put
a batch of sheets in the washer and wait 30
minutes for it to finish.
Then take the wet sheets out and put them
in the dryer and wait another 30 minutes for
that to finish.
This allows you to do one batch of sheets
every hour.
Side note: if you have a dryer that can dry
a load of laundry in 30 minutes, please tell

Portuguese: 
a marca nos comentários, por que a minha leva 90 minutos para secar, no mínimo
mas, mesmo com essa secadora mágica você pode acelerar as coisas ainda mais se você paralelizar o processo
você começa da mesma forma, colocando uma leva de roupas na lavadora, espera 30 minutos para ela terminar
pega as roupas molhadas e coloca na secadora
mas dessa vez ao invés de esperar a secadora terminar, você começa a lavar outra leva de roupas, simultaneamente
Assim você tem as duas máquinas trabalhando ao mesmo tempo
Espere 30 minutos e uma leva está pronta, outra está pela metade e a lavadora está pronta para começar uma terceira
Isso efetivamente dobra seu desempenho. Projetos de processadores podem aplicar a mesma ideia
No episódio 7, nosso processador de exemplo executava o ciclo busca-decodificação-execução sequencialmente
e em uma repetição contínua: busca-decodificação-execução, busca-decodificação-execução, busca-decodificação-execução
e assim por diante. Isso significa que nosso projeto de circuito precisa de três ciclos para executar uma instrução
Mas cada um desses estágios usa uma parte diferente da CPU, o que quer dizer que temos uma oportunidade para paralelizar!
Enquanto uma instrução é executada, a próxima instrução pode ser decodificada e a seguinte pode ser buscada da memória

Korean: 
회사와 모델 이름을 댓글에 달아주세요.
제꺼는 최소 90분 걸리니까요.
이 마법같은 건조기를 갖고 작업을 병렬로 처리하면 
속도를 올릴 수 있습니다.
이 마법같은 건조기를 갖고 작업을 병렬로 처리하면 
속도를 올릴 수 있습니다.
전과 같이 세탁기에 이불 한 묶음을 던져 넣습니다.
끝날 때까지 30분을 기다리죠.
그리고 젖은 이불을 건조기에 넣습니다.
바로 이때, 건조기가 끝날 때까지 30분 기다리지 말고
동시에 다른 이불 묶음을 세탁기에 돌리기 시작합니다.
자 이제 기계 2대를 동시에 돌리게 되었습니다.
30분을 기다리면, 한 묶음은 다 했고, 한 묶음은 반 진행했고, 다른 하나는 시작할 준비가 되어 있습니다.
30분을 기다리면, 한 묶음은 다 했고, 한 묶음은 반 진행했고, 다른 하나는 시작할 준비가 되어 있습니다.
이렇게 처리 속도를 효과적으로 두배 올렸습니다.
프로세서도 이런 아이디어가 적용되도록 설계 됩니다.
에피소드 7에서 우리 예제 CPU는 fetch-decode-execute 사이클을 순차적으로 수행했었습니다.
그리고 fetch-decode-execute, fetch-decode-execute, fetch-decode-execute를 계속 돌았습니다.
그리고 Fetch-decode-execute, fetch-decode-execute, fetch-decode-execute 루프를 계속 돌았습니다.
즉, 우리 설계는 명령어 하나 수행하는데 
3개의 클럭 사이클이 필요하다는 것입니다.
그런데 각 단계는 CPU의 서로 다른 부분을 사용합니다. 즉 병렬처리 할 수 있는 기회가 있다는 것이지요.
그런데 각 단계는 CPU의 서로 다른 부분을 사용합니다. 즉 병렬처리 할 수 있는 기회가 있다는 것이지요.
명령어 한개가 execute되고 있는 동안 
다음 명령어를 decode하고,
그 다음 명령어를 메모리에서 fetch할 수 있다는 것이죠.

English: 
me the brand and model in the comments, because
I’m living with 90 minute dry times, minimum.
But, even with this magic clothes dryer, you
can speed things up even more if you parallelize
your operation.
As before, you start off putting one batch
of sheets in the washer.
You wait 30 minutes for it to finish.
Then you take the wet sheets out and put them
in the dryer.
But this time, instead of just waiting 30
minutes for the dryer to finish, you simultaneously
start another load in the washing machine.
Now you’ve got both machines going at once.
Wait 30 minutes, and one batch is now done,
one batch is half done, and another is ready
to go in.
This effectively doubles your throughput.
Processor designs can apply the same idea.
In episode 7, our example processor performed
the fetch-decode-execute cycle sequentially
and in a continuous loop: Fetch-decode-execute,
fetch-decode-execute, fetch-decode-execute,
and so on.
This meant our design required three clock
cycles to execute one instruction.
But each of these stages uses a different
part of the CPU, meaning there is an opportunity
to parallelize!
While one instruction is getting executed,
the next instruction could be getting decoded,
and the instruction beyond that fetched from
memory.

English: 
All of these separate processes can overlap
so that all parts of the CPU are active at
any given time.
In this pipelined design, an instruction is
executed every single clock cycle which triples
the throughput.
But just like with caching this can lead to
some tricky problems.
A big hazard is a dependency in the instructions.
For example, you might fetch something that
the currently executing instruction is just
about to modify, which means you’ll end
up with the old value in the pipeline.
To compensate for this, pipelined processors
have to look ahead for data dependencies,
and if necessary, stall their pipelines to
avoid problems.
High end processors, like those found in laptops
and smartphones, go one step further and can
dynamically reorder instructions with dependencies
in order to minimize stalls and keep the pipeline
moving, which is called out-of-order execution.
As you might imagine, the circuits that figure
this all out are incredibly complicated.
Nonetheless, pipelining is tremendously effective
and almost all processors implement it today.
Another big hazard are conditional jump instructions
-- we talked about one example, a JUMP NEGATIVE,
last episode.
These instructions can change the execution
flow of a program depending on a value.

Portuguese: 
Todos esses processos separado podem se intercalar de fora que todas as partes da CPU pode estar ativas ao mesmo tempo
Dessa forma instrução é executada a cada ciclo o que triplica o fluxo
Mas da mesma forma que o cache isso pode levar a alguns problemas curiosos
Um grande empecilho é a dependência entre as instruções
Por exemplo, você pode buscar algo que a instrução que está sendo executada está prestes
a modificar, assim você vai acabar lendo o valor antigo
Para lidar com isso processadores com esse sequenciamento tem que procurar por dependência de dados
e se necessário, pausar o processamento para evitar problemas
Processadores mais avançados como os encontrados em laptops e smartphones vão além
e podem reordenar dinamicamente as instruções com dependência para minimizar as pausas e manter o fluxo
funcionando, o que é chamado de execução fora de ordem
Como você deve imaginar, os circuitos que fazem isso são incrivelmente complicados
Todavia, esse tunelamento é tremendamente efetivo e praticamente todos processadores atuais o implementam
Outro grande empecilho são instruções de saltos condicionais, falamos de uma delas no último episódio: a JUMP NEGATIVE
Essas instruções podem mudar o fluxo de execução de um programa dependendo de um valor

Korean: 
이렇게 분리된 과정들은 겹쳐져서 진행될 수 있어서, 언제나 CPU의 모든 부분이 동작할 수 있습니다.
이렇게 분리된 과정들은 겹쳐져서 진행될 수 있어서, 언제나 CPU의 모든 부분이 동작할 수 있습니다.
이런 파이프라인 형태에서, 명령어는 매 클럭 사이클마다 실행되어 처리 속도가 3배가 됩니다.
이런 파이프라인 형태에서, 명령어는 매 클럭 사이클마다 실행되어 처리 속도가 3배가 됩니다.
그러나 캐쉬에서 처럼, 여기서도 
약간의 어려운 문제들이 있습니다.
큰 해저드(위험)은 명령어 간의 의존성입니다.
예를 들어, 현재 실행 중인 명령어가 
막 수정한 무언가를 fetch할 수도 있습니다.
그렇다는 건 파이프라인 안에는
이전의 값이 있다는 것입니다.
이 문제를 보완하기 위해서, 파이프라인 형태의 프로세서는 데이터 의존성을 미리 내다볼 수 있어야 하고,
필요하다면 문제가 발생하지 않도록 
파이프라인을 지연시킬 수 있어야 합니다.
노트북과 스마트폰에 사용되는 고사양 프로세서들은 
한 단계 더 나아가서,
파이프라인이 지연되는 것을 
최소화 하고 이동을 유지하기 위해
상호 연관성이 있는 명령어들의 순서를
동적으로 바꿀 수 있습니다.
이것을 비순차적 (out-of-order) 실행이라고 합니다.
예상하시겠지만, 이런 모든 일을 수행하는 회로는
엄청나게 복잡하겠지요.
그럼에도 불구하고, 파이프라인은 
엄청나게 효과적이어서
오늘날 거의 모든 프로세서는 
파이프라인으로 구현됩니다.
또 다른 큰 위험(해저드)는 조건부 점프 명령어 입니다. 
지난 강의에서 얘기했던 JUMP_NEGATIVE 같은 거죠.
또 다른 큰 위험(해저드)는 조건부 점프 명령어 입니다. 지난 에피소드에서 얘기했던 JUMP_NEGATIVE 같은 거죠.
이런 명령어는 상태에 따라서 
프로그램의 실행 흐름을 바꿀 수 있습니다.

Korean: 
단순한 파이프라인 프로세서는 점프 명령어를 만나면 
오래 지연될 수 있습니다.
상태 값의 결정이 완료될 때까지 기다려야 하니까요.
점프의 결과를 알아야지 프로세서는 
파이프라인을 다시 채우기 시작합니다.
그러나, 이런 상황은 긴 딜레이를 만들기 때문에,
고사양 프로세서들은 이 문제들도 해결할 수 있는 
몇 가지 트릭을 갖고 있습니다.
점프 명령어를 갈림길이라고 생각합시다.
고급 CPU는 예측실행 (speculative execution)이라는 
기술로 어느 길로 갈지를 추측하고,
이 추측을 바탕으로 파이프라인에 
명령어들을 채우기 시작합니다.
점프명령어 실행이 완료됐을 때, CPU가 맞게 추측했다면, 지연 없이 진행할 수가 있습니다.
올바른 명령어 들이 파이프라인에 이미 채워져 있으니까요.
하지만, CPU가 추측한 것이 틀렸다면, 
예상했던 결과들을 전부 버리고
파이프라인 플러쉬라는 파이프라인을 싹 비우는 일을 합니다.
마치 교차로에서 길을 놓쳐서 왔던 길을 유턴해서 
되돌아 가야되는 상황하고 같은 겁니다.
그리고 고집스럽게 소리치는 GPS를 끄겠죠.
이런 플러쉬에 의한 영향을 최소화하기 위해서,
CPU 제조사들은
분기 예측(branch prediction)이라는 어느 갈림길로 갈지 정교하게 추측할 수 있는 방법을 개발해 왔습니다.
요즘 프로세서들은 50대 50 확률이 아니고, 
90% 이상의 정확도로 예측할 수가 있습니다.

English: 
A simple pipelined processor will perform
a long stall when it sees a jump instruction,
waiting for the value to be finalized.
Only once the jump outcome is known, does
the processor start refilling its pipeline.
But, this can produce long delays, so high-end
processors have some tricks to deal with this
problem too.
Imagine an upcoming jump instruction as a
fork in a road - a branch.
Advanced CPUs guess which way they are going
to go, and start filling their pipeline with
instructions based off that guess – a technique
called speculative execution.
When the jump instruction is finally resolved,
if the CPU guessed correctly, then the pipeline
is already full of the correct instructions
and it can motor along without delay.
However, if the CPU guessed wrong, it has
to discard all its speculative results and
perform a pipeline flush - sort of like when
you miss a turn and have to do a u-turn to
get back on route, and stop your GPS’s insistent
shouting.
To minimize the effects of these flushes,
CPU manufacturers have developed sophisticated
ways to guess which way branches will go,
called branch prediction.
Instead of being a 50/50 guess, today’s
processors can often guess with over 90% accuracy!

Portuguese: 
Um processador com um encadeamento simples fará uma longa pausa quando perceber uma instrução de salto
esperando que o valor seja calculado
Somente depois que o resultado do salto é conhecido é que o processador voltará ao enfileiramento
Mas isso pode produzir longas esperas, então os processadores mais sofisticados tem alguns truques para lidar com esse
problema também
Imagine uma instrução JUMP que esteja se aproximando como uma bifurcação na estrada – um galho
CPUs avançadas adivinham para qual caminho elas estão indo e começam a preencher o enfileiramento com
instruções baseadas nesse palpite – Uma técnica chamada de execução especulativa
Quando a instrução JUMP é resolvida, se a CPU adivinhou corretamente, então a fila
já está preenchida com as instruções corretas e pode seguir sem parada
Porém, se a CPU adivinhou incorretamente, todos os resultados da especulação são descartados e
o enfileiramento é descartado – Como quando você esquece de fazer uma curva e tem que fazer um retorno
para voltar a rota correta (e fazer seu Gps parar de reclamar)
Para minimizar os efeitos desses descartes, os fabricantes de CPU desenvolveram formas
sofisticadas de adivinhar para onde as bifurcações irão, chamadas Branch prediction
Ao invés de uma previsão meio a meio, os processadores atualmente podem frequentemente atingir com 90% de acerto

Portuguese: 
Em um modelo ideal, enfileira permite que se complete uma instrução a cada ciclo de processamento
mas com processadores superescalares pode-se executar mais de uma instrução por ciclo de processamento
Durante a fase de execução mesmo em um processador com pipeline, áreas inteiras do processador podem
estar totalmente paradas
por exemplo, enquanto executa uma instrução que busca um valor da memória a ALU
está lá sem fazer nada
Então por que não buscar e decodificar várias instruções de uma vez e sempre que possível executar instruções
que precisam de diferentes partes da CPU trabalhando ao mesmo tempo:
mas nós podemos ir um passo além e duplicar os circuitos para instruções muito comuns
Por exemplo, muitos processadores tem 4, 8 ou mais ALUs idênticas permitindo
assim que se execute várias instruções matemáticas em paralelo
Ok, as técnicas que discutimos até agora otimizam basicamente o resultado da execução
de um fluxo simples de instruções, mas outra forma de melhorar a performance é executar vários
fluxos de instruções de uma vez, com processadores multi-núcleos
Você já deve ter ouvido falar de processadores dual ou quad core

English: 
In an ideal case, pipelining lets you complete
one instruction every single clock cycle,
but then superscalar processors came along
which can execute more than one instruction
per clock cycle.
During the execute phase even in a pipelined design, whole areas of the processor might
be totally idle.
For example, while executing an instruction
that fetches a value from memory, the ALU
is just going to be sitting there, not doing
a thing.
So why not fetch-and-decode several instructions
at once, and whenever possible, execute instructions
that require different parts of the CPU all
at the same time!?
But we can take this
one step further and add duplicate circuitry
for popular instructions.
For example, many processors will have four,
eight or more identical ALUs, so they can
execute many mathematical instructions all
in parallel!
Ok, the techniques we’ve discussed so far
primarily optimize the execution throughput
of a single stream of instructions, but another
way to increase performance is to run several
streams of instructions at once with multi-core
processors.
You might have heard of dual core or quad
core processors.

Korean: 
이상적인 케이스에 파이프라인은 매 클럭 사이클마다 하나의 명령어 실행을 완료할 수 있습니다.
그러나, 매 클럭 한개 이상의 명령어를 실행할 수 있는 
슈퍼스칼라 (superscalar) 프로세서가 등장했습니다.
그러나, 매 클럭 한개 이상의 명령어를 실행할 수 있는 
슈퍼스칼라 (superscalar) 프로세서가 등장했습니다.
파이프라인 디자인에서도 execute 단계에서 프로세서 전체가 아무일도 하지 않을 수 있습니다.
파이프라인 디자인에서도 execute 단계에서 프로세서 전체가 아무일도 하지 않을 수 있습니다.
예를 들어 메모리에서 값을
fetch해야 하는 명령어를 실행하는 동안,
ALU는 아무 것도 하는 일 없이 그대로 앉아 있어야 합니다.
명령어 여러개를 한 번에 fetch하고 decode 해 놓고, 
가능한 시점에
CPU의 서로 다른 부분을 필요로 하는 명령어들을 
동시에 실행하는 건 어떨까요?
많이 사용하는 명령어들을 위해서 같은 회로를 추가해서 한 단계 더 나아갈 수 있습니다.
많이 사용하는 명령어들을 위해서 같은 회로를 추가해서 한 단계 더 나아갈 수 있습니다.
예를 들어, 많은 프로세서들은 4개, 8개 
또는 더 많은 동일한 ALU를 사용해서
많은 수학 연산을 병렬로 수행할 수 있습니다.
자, 우리가 지금까지 알아봤던 기술들은 하나의 명령어 흐름(stream)을 처리하는 속도를 최적화 하는 것들입니다.
하지만, 성능을 높이는 또 하나의 방법은
멀티 코어 프로세서를 가지고 여러개의 명령어 흐름들을 동시에 처리하는 것입니다.
듀얼 코어나 쿼드 코어란 말을 
들어 본 적이 있을 것입니다.

Korean: 
이것은 하나의 CPU 칩 안에 여러개의 독립적인 프로세싱 유닛이 들어가 있는 것입니다.
많은 측면에서 다수의 독립된 CPU를 
갖고 있는 것과 비슷해 보이지만,
멀티 코어는 한 칩에 직접되어 있기 때문에 
캐쉬와 같은 자원을 공유할 수 있고,
코어 들이 공통의 계산을 
같이 처리하는 것도 가능합니다.
코어를 더 사용하는 것만으로 충분하지 않다면,
컴퓨터에 여러개의 
독립된 CPU를 갖고 조립할 수 있습니다.
유튜브 데이터 센터에서 이 비디오를 
스트리밍 하는 서버 같은 고사양 컴퓨터들은
수백명의 사람들이 동시에 시청하더라도 비디오가 부드럽고 매끄럽게 유지되도록 특별한 능력이 필요합니다.
수백명의 사람들이 동시에 시청하더라도 비디오가 부드럽고 매끄럽게 유지되도록 특별한 능력이 필요합니다.
요즘은 2개, 4개 프로세서 구성이 가장 일반적이지만,
때때로 이 정도로 충분하지 않습니다.
우리 인간은 특별한 야심을 갖고 
슈퍼 컴퓨터를 만듭니다.
여러분이 우주의 형성에 관한 시뮬레이션 같은 진짜 괴물같은 계산이 필요하다면,
엄청나게 심각한 양의 컴퓨팅 파워가 필요할 것입니다.
데스크탑의 몇 개의 프로세서를 추가하는 것으로 
해결할 수 없습니다.
많은 프로세서가 필요할 겁니다.
아니아니, 많다 보다 더 많은
더 많은 보다 더 많은...
이 비디오가 만들어 질 때 (2017년),
세계에서 가장 빠른 컴퓨터는 중국 우시에 있는 National Supercomputing Center에 있었습니다.

English: 
This means there are multiple independent
processing units inside of a single CPU chip.
In many ways, this is very much like having
multiple separate CPUs, but because they’re
tightly integrated, they can share some resources,
like cache, allowing the cores to work together
on shared computations.
But, when more cores just isn’t enough,
you can build computers with multiple independent
CPUs!
High end computers, like the servers streaming
this video from YouTube’s datacenter, often
need the extra horsepower to keep it silky
smooth for the hundreds of people watching
simultaneously.
Two- and four-processor configuration are
the most common right now, but every now and
again even that much processing power isn’t
enough.
So we humans get extra ambitious and build
ourselves a supercomputer!
If you’re looking to do some really monster
calculations – like simulating the formation
of the universe - you’ll need some pretty
serious compute power.
A few extra processors in a desktop computer
just isn’t going to cut it.
You’re going to need a lot of processors.
No.. no... even more than that.
A lot more!
When this video was made, the world’s fastest
computer was located in The National Supercomputing
Center in Wuxi, China.

Portuguese: 
Isso significa que há várias unidades de processamento independente dentro de um único chip de CPU
De várias formas isso é muito parecido com ter várias CPUs separadas, mas por que elas
estão bastante integradas elas podem compartilhar recursos, como cache, permitindo que os núcleos trabalhem juntos
em cálculos compartilhados
mas, como se mais núcleos não fosse suficiente, nós podemos construir computadores com várias CPUs independentes!
Computadores avançados, como os que estão enviando esse video da central de processamento do Youtube, frequentemente
precisam de mais capacidade para manter o fluxo constante para as centenas de pessoas que estão assistindo
ao mesmo tempo
Configurações com 2 ou 4 processadores são as mais comuns hoje em dia, mas mesmo hoje
em dia esse poder de processamento não é suficiente
Então ficamos mais ambiciosos e construímos um supercomputador
Se você quer fazer cálculos realmente monstruosos – como simular a formação
do universo – a coisa vai ficar bem séria
Alguns processadores a mais em um computador de mesa não vão ser suficiente para resolver isso
Você vai precisar de muitos processadores, não, não, mais ainda. Muitos mais
Quando esse vídeo foi feito, o o computador mais rápido do mundo ficava no Centro Nacional de
Supercomputação em Wuxi na China

Korean: 
Sunway Taihulight는 40,960개의 CPU를 갖고 있고, 각 CPU는 256개 core를 포함합니다.
즉 총 천만개 이상의 코어가 있고, 
각 코어는 1.45GHz로 동작합니다.
이 머신은 93 Quadrillion FLOPS 부동소수점 연산을 할 수가 있습니다. (Quadrillion = 천조, 십억개가 백만개 )
(FLOPS = 초당 처리 가능한 부동소수점 연산 개수)
저를 믿으세요. 엄청난 FLOPS 입니다.
최고 설정으로 Crysis (게임 이름) 돌릴 수 있을지 없을지 언급은 없지만, 가능하겠지요.
복잡하지만 짧게 말하면, 컴퓨터 프로세서들은 
오랜 시간에 걸쳐
많이 빨라졌을 뿐만 아니라, 훨씬 더 정교해 졌습니다.
클럭 사이클당 점점 더 많은 연산을 할 수 있도록 짜내기 위해서 모든 종류의 영리한 트릭들을 동원하고 있고요.
클럭 사이클당 점점 더 많은 연산을 할 수 있도록 짜내기 위해서 모든 종류의 영리한 트릭들을 동원하고 있고요.
우리의 일은 이 엄청난 처리 능력을 
쿨하고 유익한 일을 하는데 쓰는 것입니다.
그게 프로그래밍의 본질이고, 
이 얘기는 다음 에피소드에서 할 것입니다.
다음 주에 봐요.

Portuguese: 
O Sunway TaihuLight contém 40.960 CPUs, cada uma com 256 núcleos
São mais de 10 milhões de núcleos no total e cada um desses núcleos roda a 1.45 Gigahertz
no total essa máquina pode processar 93 quadrilhões – Ou seja 93 milhões de bilhões – de instruções
de ponto flutuantes, conhecidas como FLOPs, por segundo
Acredite, são muitos FLOPs!!
Não disseram se dá para rodar Cyrsis no máximo, mas eu acho que sim
Simplificando, os processadores não só se tornaram muito mais rápidos com o passar dos anos
mas também ficaram muito mais sofisticados, usando vários truques para entregar
mais e mais computação por ciclo de processamento
Nosso trabalho é usar esse incrível poder de processamento para fazer coisas úteis e legais
Essa é a essência da programação, sobre a qual falaremos no próximo episódio
Nos vemos semana que vem

English: 
The Sunway TaihuLight contains a brain-melting
40,960 CPUs, each with 256 cores!
Thats over ten million cores in total... and
each one of those cores runs at 1.45 gigahertz.
In total, this machine can process 93 Quadrillion
-- that’s 93 million-billions -- floating
point math operations per second, knows as
FLOPS.
And trust me, that’s a lot of FLOPS!!
No word on whether it can run Crysis at max
settings, but I suspect it might.
So long story short, not only have computer
processors gotten a lot faster over the years,
but also a lot more sophisticated, employing
all sorts of clever tricks to squeeze out
more and more computation per clock cycle.
Our job is to wield that incredible processing
power to do cool and useful things.
That’s the essence of programming, which
we’ll start discussing next episode.
See you next week.
