
English: 
In a previous video, we looked at how CPU's can use caches to speed up accesses to memory.
So, the CPU has to fetch things from memory; it might be a bit of data, it might be an instruction
And it goes through the cache to try and access it.
And the cache keeps a local copy in fast memory to try and speed up the accesses
But what we didn't talk about is:
What does a CPU do with what it's fetched from memory
what is it actually doing and how does it process it?
So the CPU is fetching values from memory.
We'll ignore the cache for now, because it doesn't matter if the CPU has a cache or not
it's still gonna do roughly the same things
And we're also gonna look at very old CPU's
the sort of things that are in 8-bit machines
purely because they're simpler to deal with
and simpler to see what's going on
The same idea is still applied to an ARM CPU today or an X86 chip
or whatever it is you got in your machine.
Modern CPU's use what's called 
the Van Neumann architecture
and what this basically means is
that you have a CPU

Thai: 
ในวิดีโอก่อนหน้านี้ เราได้รู้ว่าซีพียูสามารถใช้แคช(caches)เพื่อเพิ่มความเร็วในการเข้าถึงหน่วยความจำ (memory)
ดังนั้น CPU ต้องดึงบางสิ่งมาจากหน่วยความจำ; มันอาจจะเป็นข้อมูล(data) มันอาจจะเป็นคำสั่ง(instruction)
และมันจะไปสู่แคชและมันพยายามอ่านสิ่งที่ดึงมา
และแคชเก็บสำเนามันไว้ในหน่วยความจำแบบรวดเร็ว เพื่อพยายามเพิ่มความเร็วในการเข้าถึง
แต่สิ่งที่เราไม่ได้พูดถึง คือ:
CPU ทำอะไร มันทำอย่างไรกับสิ่งที่มันดึงมาจากหน่วยความจำ
แท้จริงแล้ว มันทำอะไร และวิธีการดำเนินการ
CPU จะเรียกค่าจากหน่วยความจำ
เราจะไม่สนใจแคชเพราะ ตอนนี้ มันไม่สำคัญว่า CPU จะมีแคชหรือไม่
ก็ยังคงจะทำงานทำนองเดียวกัน
และเราจะไปดูที่ CPU แบบเก่า
ชนิดที่อยู่ในเครื่อง 8 บิต
เพราะว่าพวกมันง่ายกว่าที่จะจัดการอธิบาย
และง่ายกว่าที่จะเข้าใจสิ่งที่เกิดขึ้น
ไอเดียนี้ยังคงถูกนำไปใช้ในซีพียูแบบ ARM ทุกวันนี้ หรือชิป X86
หรือสิ่งที่คุณได้มีอยู่ในเครื่องของคุณ
CPU แบบทันสมัย ใช้สิ่งที่เรียกว่า  
สถาปัตยกรรมแบบ Von Neumann
โดยทั่วไป สิ่งนี้หมายถึงว่า 
คุณมีซีพียู

Turkish: 
Önceki bir videoda, CPU'ların belleğe erişimi hızlandırmak için önbellekleri nasıl kullanabileceğini inceledik.
Öyleyse, CPU şeyleri bellekten almak zorundadır; biraz veri olabilir, bir talimat olabilir
Ve denemek ve erişmek için önbellekten geçer.
Ve önbellek, erişimleri denemek ve hızlandırmak için yerel bir kopyayı hızlı bellekte tutar.
Ama konuşmadığımız şey şu:
Bir CPU bellekten aldığı ile ne yapar?
aslında ne yapıyor ve onu nasıl işliyor?
Böylece CPU bellekten değer alıyor.
Şimdilik önbelleği görmezden geleceğiz, çünkü CPU'nun önbelleği olup olmaması önemli değil.
hala aynı şeyleri yapacak
Ayrıca çok eski CPU'lara da bakacağız.
8 bit makinelerde olan şeyler
Tamamen sorun çünkü onlar başa çıkmak daha basit
ve neler olduğunu görmek için daha basit
Aynı fikir bugün hala bir ARM CPU'ya veya bir X86 yongasına uygulanmaktadır.
ya da makinenizde ne varsa.
Modern CPU'nun adı ne kullanılır 
Van Neumann mimarisi
ve bunun temel olarak ne anlama geldiği
Bir CPU'nuz olduğunu

French: 
Dans une vidéo précédente, nous avons vu comment les processeurs utilisent les caches pour accélérer l'accès à la mémoire.
Le processeur doit récupérer des choses de la mémoire, ça peut être des données, ça peut être des instructions,
et il passe par le cache pour essayer d'y accéder et le cache garde une copie locale en mémoire rapide pour essayer d'accélérer les accès.
Mais ce dont nous n'avons pas parlé c'est,
que fait le processeur avec ce qui est récupéré de la mémoire, que fait-il concrètement et comment le traite-t-il ?

Le processeur récupère des valeurs à partir de la mémoire, on va ignorer le cache pour l'instant,
parce que ça n'a pas d'importance si le processeur a un cache ou non,
il va quand même faire à peu près la même chose.
On va aussi regarder de très vieux processeurs qui étaient des machines 8 bits,
 
simplement parce qu'ils sont plus simples à gérer et c'est plus simple de voir ce qu'il se passe,
mais la même idée s'applique à un processeur ARM d'aujourd'hui ou même une puce x86 ou n'importe quel processeur vous avez dans votre machine.
Les processeurs modernes utilisent ce qu'on appelle l'architecture «Von Neumann»,
ce que ça veut simplement dire c'est que

Thai: 
และคุณมีบล็อกของหน่วยความจำ
และหน่วยความจำนี้เชื่อมต่อกับซีพียู
โดยบัส 2 สาย
บัสแต่ละสาย เป็นเพียงกลุ่มของหลายๆเส้นที่มีการเชื่อมต่อ
และอีกครั้ง ที่เรากำลังมองดูแมชชีนแบบสมัยเก่า 
ในเครื่องแบบทันสมัยจะซับซ้อนมากขึ้นกว่านี้
แต่อยู่บนหลักการที่เหมือนกัน
ดังนั้นเรามี บัสที่อยู่ (address bus)
และไอเดียที่ว่าซีพียูสามารถสร้างตัวเลขที่อยู่ในนี้ ในแบบไบนารี(เลขฐานสอง)
เพื่อการเข้าถึงค่าโดยเฉพาะในที่นี่
ดังนั้นเราจึงบอกว่าอันแรกคือ ที่ ที่อยู่ 0
และเราจะใช้ 6502 เป็นตัวอย่าง
เราจะบอกว่า ที่อยู่อันดับสุดท้ายคือ 65535 ในฐานสิบ หรือ FFFF ในเลขฐานสิบหก
ดังนั้นเราสามารถสร้างตัวเลขเหล่านี้บนบัสที่อยู่แบบ16 บิตนี้
ในการเข้าถึงใด ๆ ของแต่ละไบต์ 
ในหน่วยความจำนี้
เราจะได้ข้อมูลอย่างไรระหว่างสองอันนี้ ?
อืม เรามีบัสอีกสาย
ซึ่งเรียกว่าบัสข้อมูล
ซึ่งเชื่อมต่อทั้งสองร่วมกัน
ตอนนี้เหตุผลที่ว่า ทำไมนี้เป็นเครื่องแบบ Von Neumann

Turkish: 
ve bir hafıza bloğunuz var.
Ve bu hafıza CPU'ya bağlı.
iki otobüsle
Her biri birbirine bağlanan birkaç kablodan oluşan bir koleksiyondur.
Ve yine eski moda makamlara bakıyoruz. 
Modern bir makinede biraz daha karmaşık hale geliyor
Fakat fikir, ilke aynı.
Yani bir ek otobüsümüz var
ve fikir CPU'nun burada ikili bir sayı oluşturabilmesidir.
Buradaki herhangi bir özel değere erişmek için.
Diyelim ki ilki adres 0
ve bir 6502'yi örnek olarak kullanacağız
Sonuncunun ondalık basamakta 65535 adresinde veya onaltılık bölümde FFFF olduğunu söyleyeceğiz.
Böylece bu adreslerden herhangi birini bu adres yolunun 16 bitinde üretebiliriz.
tek tek baytların herhangi birine erişmek için 
bu hafızada
İkisi arasındaki verileri nasıl elde ederiz?
Başka bir otobüsümüz var
buna veri yolu denir,
ikisi birbirine bağlayan
Şimdi bunun bir Van Neumann makinesi olması sebebi

French: 
vous avez un processeur et vous avez un bloc de mémoire
et cette mémoire est connectée au processeur par 2... enfin c'est plus une collection de plusieurs fils connectés
mais là aussi, on regarde de vieilles machines, sur les machines modernes ça devient plus compliqué mais le principe reste le même.
Donc on a un bus d'adresse,
l'idée c'est que le processeur peut générer un nombre en binaire pour accéder à n'importe quelle valeur là dedans,
on va dire que la première est à l'adresse 0
et on va utiliser un 6502 (microprocesseur 8-bit)
comme exemple,
on va dire que la dernière est à l'adresse 65535 en décimal ou bien FFFF en hexadécimal.
Donc on peut générer n'importe quel nombre sur ce bus d'adresse de 16 bits
pour accéder individuellement à n'importe quel octet dans cette mémoire.
Comment on récupère les données entre les 2 ?
Et bien on a un autre bus, qui s'appelle le bus de données et qui connecte les 2 ensemble.
La raison pour laquelle c'est une machine Von Neumann,

English: 
and you have a block of memory.
And that memory is connected to the CPU
by two buses
Each is just a collection of several wires that are connecting
And again we're looking at old-fashioned macines. 
On a modern machine it gets a bit more complicated
But the idea, the principle, is the same.
So we have an addess bus
and the idea is that the CPU can generate a number in here in binary
to access any particular value in here.
So we say that the first one is at adress 0
and we're gonna use a 6502 as an example
We'll say that the last one is at address 65535 in decimal, or FFFF in hexadecimal
So we can generate any of these numbers on 16 bits of this address bus
to access any of the individual bytes 
in this memory
How do we get the data between the two?
Well we have another bus
which is called the data bus,
which connects the two together
Now the reason why this is a Van Neumann machine

French: 
c'est parce que cette mémoire peut contenir à la fois le programme
(qui sont les octets qui contiennent les instructions que le processeur va exécuter)
et les données.
Donc le même bloc de mémoire contient quelques octets qui contiennent les instructions et quelques octets qui contiennent des données
et le processeur, s'il le voulait, pourrait traiter le programme comme des données et les données comme un programme.
S'il le faisait, probablement qu'il crasherait.
Ce qu'on a là est un vieux BBC Micro qui utilise un processeur 6502
et on va juste écrire un programme très simple en langage machine
qui utilise un des opérateurs pour afficher la lettre C pour computerphile.
Donc si je le désassemble, on utilise l’hexadécimal,
on a démarré notre programme à 084C,
c'est l'adresse où notre programme a été créé et
ce programme est très simple,
il charge un des registres du processeur,
qui est basiquement un endroit pour stocker temporairement des données,
celui là s'appelle l'accumulateur
avec le code ASCII 67 qui représente le C majuscule et dit: «saute vers le sous-programme à cette adresse»

Thai: 
เป็นเพราะหน่วยความจำนี้ 
สามารถมีทั้งโปรแกรม
เช่น กลุ่มไบต์ ที่ประกอบขึ้นเป็นคำสั่ง
ที่ซีพียูสามารถดำเนินการ
และ มีข้อมูล
ดังนั้นบล็อกเดียวกันของหน่วยความจำ
ประกอบด้วยบางกลุ่มไบต์
ซึ่งเป็นโปรแกรม(คำสั่ง)
บางกลุ่มไบต์ที่ประกอบเป็นข้อมูล
และ CPU ซึ่งถ้าคุณต้องการที่จะทำ
ให้โปรแกรมเป็นข้อมูล
หรือให้ข้อมูลเป็นโปรแกรม
อืมม ถ้าคุณทำแบบนั้นแล้วมันจะผิดพลาด
ดังนั้น สิ่งที่เรามีที่นี่เป็น BBC Micro แบบเก่า
ใช้ CPU 6502
และเราจะเป็นแค่เขียน
รหัสโปรแกรมเครื่องแบบง่าย
ที่ใช้
คำสั่งเพียงเพื่อพิมพ์ตัวอักษร C 
สำหรับ computerphile
ดังนั้น หากคุณประกอบมัน
เรากำลังใช้เลขฐานสิบหก
เราได้เริ่มต้นโปรแกรมของเราที่ 084C
เพื่อให้เป็นที่อยู่
ที่โปรแกรมของเราจะถูกสร้างขึ้น
และโปรแกรมของเราง่ายมาก
มันโหลดหนึ่งในเลขที่อยู่เรจิสเตอร์(register) ของ CPU
ซึ่งเป็นเพียงพื้นเก็บข้อมูลชั่วคราว
ที่คุณสามารถใช้
และนี่ เรียกว่า accumulator (ตัวสะสมเป็นหน่วยความจำ)
ด้วย รหัส ASCII 67 ซึ่งหมายถึง
ตัวพิมพ์ใหญ่ C
และจากนั้นมัน:
ข้ามไปยังชุดคำสั่งประจำย่อย(subroutine) ตำแหน่ง ที่อยู่นี้
ซึ่งจะพิมพ์ตัวอักษรที่เฉพาะออกมา

English: 
is because this memory can 
contain both the program
i.e. the bytes that make up the instructions
that the CPU can execute
and the data
So the same block of memory
contain some bytes
which contain program instructions
some bytes which contain data
And the CPU if you wanted to could 
treat the program as data
or treat the data as program
Well if you do that then it would probably crash
So what we've got here is an old BBC Micro
using a 6502 CPU
and we're gonna just write a very, very simple
machine code program
that uses
well the operation is saying just to
print out the letter C for computerphile
So if you assemble it,
we're using hexadecimal
we've started our program at 084C
So that's the address,
were our program is being created
And our program is very simple
It loads one of the CPU's registers
which is just basically a temporary data store
that you can use
and this one is called the accumulator
with the ascii code 67 which represents
a capital C
and then it says:
jump to the subroutine at this address
which will print out that particular character

Turkish: 
çünkü bu hafıza olabilir 
her iki programı da içer
yani talimatları oluşturan baytlar
CPU'nun çalıştırabileceği
ve veri
Yani aynı hafıza bloğu
bazı baytlar içeren
program talimatlarını içeren
veri içeren bazı baytlar
Ve eğer istersen cpu 
programı veri olarak kabul et
veya verileri program olarak kabul edin
Eğer bunu yaparsan, muhtemelen çökecek
Yani burada sahip olduğumuz eski bir BBC Micro.
6502 işlemci kullanarak
ve çok çok basit bir yazı yazacağız
makine kodu programı
kullanan
iyi operasyon sadece diyor ki
computerphile için C harfi yazdırmak
Eğer toparlarsan,
onaltılık kullanıyoruz
programımıza 084C'de başladık
Demek adres burası.
programımız yaratılıyordu
Ve programımız çok basit
CPU'nun kayıtlarından birini yükler
hangi sadece temelde geçici bir veri deposu
kullanabileceğini
ve buna akümülatör denir
temsil eden ascii kodu 67 ile
büyük C
ve sonra diyor ki:
bu adreste alt rutine atla
bu belirli karakteri yazdıracak

English: 
And then we tell it we want to stop
so we gotta return
from subroutine.
And if we run this
and type in the address,
so we're at ... 84C
then you'll see that it prints out the letter C
and then we get a prompt
to carry on doing things
So our program,
we write it in assembly language
which we can understand as humans
-ish, LDA: Load Accumulator
JSR: Jump to subroutine
RTS: Return to subroutine
You get the idea once you've done it a few times
And the computer converts this
into a series of numbers, in binary
The CPU is working in binary but to make it easier to read we display it as hexadecimal
So our program becomes:
A9, 43
20 EE FF
60
That's the program we've written
And the CPU, when it runs it
needs to fetch those bytes from memory
into the CPU
Now, how does it do that?
To get the first byte we need to 
put the address: 084C on the address bus

Thai: 
แล้วเราบอกมันว่า เราต้องการที่จะหยุด
ดังนั้นเราจึงต้อง return กลับมา
จาก subroutine
และถ้าเรารันงานนี้
และพิมพ์ที่อยู่
ดังนั้น เราจึงอยู่ที่ ... 84C
แล้วคุณจะเห็นว่ามันพิมพ์ตัวอักษร C ออกมา
และจากนั้นเราได้ ตัวพร้อม (prompt)
เพื่อจะดำเนินการสิ่งต่างๆ
ดังนั้น โปรแกรมของเรา
เราเขียนในภาษาแอสเซมบลี (assembly)
ซึ่งมนุษย์เราสามารถเข้าใจได้
LDA: Load accumulator
JSR: Jump to subroutine
RTS: Return to subroutine
คุณจะเข้าใจไอเดียมัน เมื่อคุณได้ทำมันสองสามครั้ง
และคอมพิวเตอร์แปลงสิ่งนี้
เป็นชุดของตัวเลขในไบนารี
ซีพียูจะทำงานแบบไบนารี แต่เพื่อให้มันง่ายต่อการอ่านเราแสดงเป็นเลขฐานสิบหก
ดังนั้นโปรแกรมของเรากลายเป็น:
A9, 43
20 EE FF
60
นั่นเป็นโปรแกรมที่เราได้เขียน
และ CPU เมื่อมันได้รัน
มันต้องการที่จะดึงกลุ่มไบต์เหล่านั้นจากหน่วยความจำ
เข้าไปในซีพียู
ตอนนี้ วิธีทำการมันทำอย่างไร?
เพื่อจะได้ไบต์แรก เราต้อง 
ใส่ที่อยู่: 084C บน บัสที่อยู่

French: 
qui affichera ce caractère en particulier et enfin on lui dit qu'on veut arrêter et revenir du sous-programme.
Et si on lance ça, et qu'on tape l'adresse 084C
alors on voit qu'il affiche la lettre C et on a le prompt qui continue de faire des choses.
Donc notre programme, on l'a écrit en langage assembleur que l'on peut comprendre en tant qu'humain ou presque,
LDA: Charge l'Accumulateur
JSR: Saute vers le Sous-Programme
RTS: Retourne du Sous-Programme
Vous saisissez l'idée une fois que vous l'avez fait plusieurs fois,
et l'ordinateur convertit ça en série de nombres en binaire,
le processeur fonctionne en binaire mais pour le rendre plus lisible, on l'affiche en hexadécimal.
Donc notre programme devient
A9 43 20 EE FF 60,
c'est le programme qu'on a écrit
et le processeur, quand il l'exécute, a besoin de ramener les octets en mémoire jusqu'à lui
Maintenant, comment fait-il tout ça ?
Pour avoir la première partie, il faut mettre l'adresse 084C sur le bus d'adresse,

Turkish: 
Ve sonra durdurmak istediğimizi söyleriz.
bu yüzden geri dönmeliyiz
alt yordamdan.
Ve eğer bunu çalıştırırsak
ve adresi yazın,
öyleyse biz ... 84C
sonra göreceksin ki C harfi basılıyor
ve sonra bir istemi alırız
bir şeyler yapmaya devam etmek
Yani programımız,
assembly dilinde yazıyoruz
insanlar olarak anlayabildiğimiz
-ish, LDA: Yük Akümülatörü
JSR: Alt rutine atla
RTS: Alt rutine dön
Birkaç kez yaptıktan sonra fikri anlarsın
Ve bilgisayar bunu dönüştürür
bir sayı dizisine, ikili olarak
CPU ikili olarak çalışıyor ancak okunmasını kolaylaştırmak için onaltılık olarak görüntülüyoruz
Böylece programımız olur:
A9, 43
20 EE FF
60
Yazdığımız program bu
Ve CPU çalıştığında
Bu baytları bellekten almak gerekiyor.
CPU'ya
Şimdi, bunu nasıl yapıyor?
İlk baytı almak için bizim 
adresi yaz: 084C adres veri yoluna

French: 
et un peu plus tard, la mémoire va renvoyer l'octet qui représente l'instruction A9.
Maintenant, comment le processeur sait où aller chercher l'instruction ?
C'est assez simple, dans le processeur, il y a un registre qui s'appelle le Compteur Ordinal (Program Counter).
Sur un 6502 ou sur des marchines comme les x86 il s'appelle le Pointeur d'Instruction (Instruction Pointer),
il a plusieurs noms, ça ne fait aucune  différence.
Et tout ce que ça fait c'est de stocker l'adresse de la prochaine instruction à exécuter.
Donc si on l'initialise, il aurait la valeur 084C, l'adresse de l'instruction qu'on veut exécuter.
Donc quand le processeur veut aller chercher l'instruction qu'il va exécuter,
il met cette adresse dans le bus d'adresse et la mémoire renvoie alors l'instruction au processeur.
Donc la première chose que le processeur doit faire pour exécuter notre programme,
c'est d'aller récupérer ces instructions et la façon dont il le fait
est en mettant l'adresse du Compter Ordinal dans sur le bus d'adresse
et après il récupère les instructions.
Donc la mémoire lui donne puis le processeur lit ces instructions en entrée sur le bus de données

Thai: 
และบิตต่อๆ มา หน่วยความจำจะส่งไบต์ที่
แสดงถึง คำสั่ง: A9 กลับไป
ตอนนี้ ซีพียูรู้ได้อย่างไรว่ารับคำสั่งเหล่านี้มาจากไหน?
อืม ก็ค่อนข้างง่าย 
ภายในซีพียู
มีระบบทะเบียน (เรจิสเตอร์) ที่เราเรียกว่า
program counter หรือ PC ใน ซีพียูแบบ 6502
หรือสิ่งที่ต้องการทำนองเดียวกัน ในเครื่อง X86 มัน
เป็นที่รู้จักกันว่า คือ ตัวชี้คำสั่ง (instruction pointer)
และมันจัดเก็บอยู่
เพื่อคำสั่งถัดไปที่จะดำเนินการ
ดังนั้น เมื่อเราได้เริ่มต้น  ที่นี่ 
มันจะมี 084C ในนั้น
นั่นเป็นที่อยู่สหรับคำสั่งที่เราต้องการจะดำเนินการ
เมื่อ CPU ต้องการ เรียก 
คำสั่งที่มันจะดำเนินการ
มันใส่อยู่ที่นั่น บนบัสที่อยู่
และแล้ว หน่วยความจำส่งคำสั่ง 
กลับไปที่ซีพียู
นั่นเป็น สิ่งแรกที่ซีพียู 
จะทำเพื่อเรียกรันโปรแกรมของเรา
คือการดึงคำสั่ง
และวิธีที่มันทำ คือ โดย 
ใส่ที่อยู่จาก
program counter ไปบน
บัสที่อยู่
แล้วเรียก คำสั่ง จริง
ซึ่งหน่วยความจำมีให้มัน
แต่ CPU อ่านมันเข้ามา
เป็นอินพุตบนบัสข้อมูล

English: 
and a bit later on, the memory will send back
the byte that represents the instruction: A9
Now, how does the CPU know where to get these instructions from?
Well, it's quite simple. 
Inside the CPU
there is a register, which we call
the program counter, or PC on a 6502
or something like an X86 machine it's
known as the instruction pointer.
And all that does is store the address
to the next instruction to execute
So when we were starting up here, 
it would have 084C in it
That's the address to the instruction we want to execute
So when the CPU wants to fetch the 
instruction it's gonna execute
It puts that address on the address bus
and the memory then sends the instruction 
back to the CPU
So the first thing the CPU is 
gonna do to run our program
is to fetch the instruction
and the way it does that is by 
putting the address from
the program counter onto
the address bus
and then fetching the actual instruction
So the memory provides it,
but the CPU then reads that in
on it's input on the data bus

Turkish: 
ve biraz sonra, hafıza geri gönderir
talimatı temsil eden bayt: A9
Şimdi, CPU bu talimatları nereden alacağını nereden biliyor?
Eh, oldukça basit. 
CPU içinde
aradığımız bir kayıt var
6502’de program sayacı veya PC
ya da bir X86 makinesi gibi bir şey
talimat gösterici olarak bilinir.
Ve tüm bunlar adresi saklamak
yürütmek üzere bir sonraki talimata
Yani, buraya başlarken, 
içinde 084C olurdu
Çalıştırmak istediğimiz komutun adresi bu
CPU ne zaman almak isterse 
talimat yürütecek
Bu adresi adres yoluna koyar.
ve hafıza daha sonra talimatı gönderir. 
CPU'ya geri dön
İşlemci ilk iş 
programımızı çalıştırmak için yapacağım
talimatı getirmek
ve bu şekilde olduğu 
adresi koymak
programın karşısına
adres veriyolu
ve sonra asıl talimatın alınması
Yani hafıza onu sağlar,
ancak CPU sonra okur
veri yolundaki girişi

Thai: 
ตอนนี้ มันต้องมีการดึงคำสั่งทั้งหมด 
ที่ซีพียูจะดำเนินการ
และตัวอย่างที่เราเห็น
มันก็ค่อนข้างตรงไปตรงมา
เพราะคำสั่งเป็น
เพียงไบต์เดียว
CPU ทั้งหมดไม่ได้ เรียบง่ายแบบนี้
CPU จะแตกต่างกันไปในขั้นตอนพวกนี้
ดังนั้น ฮาร์ดแวร์นี้จะค่อนข้างซับซ้อนได้
มันจำเป็นที่จะต้องกำหนดว่า
คำสั่งยาวได้แค่ไหน
ดังนั้นมันอาจจะสั้นเท่าหนึ่งไบต์
มันอาจจะยาวในบาง CPU
มี 15 ไบต์
และบางครั้งคุณไม่ทราบว่ามันยาวได้แค่ไหน จนกว่าคุณจะได้อ่านสองสามไบต์ได้
ดังนั้นฮาร์ดแวร์นี้ค่อนข้างปลีกย่อยได้
ซีพียู ARM ออกแบบทำให้มันง่ายมากๆ
มันบอกว่า: คำสั่งทั้งหมดยาว 32 บิต
ดังนั้น สามารถดึงข้อมูล
คำสั่ง
32 บิต เรียบง่ายมากๆ
ในสิ่งที่เป็นพวก x86 ก็สามารถมี
ความยาวไม่เกิน 15 ไบต์ หรือไม่ก็
และอื่น ๆ นี้จะกลายเป็นความซับซ้อนมากขึ้น
คุณต้องคิดออกมาให้ทำงานได้
ว่ามันคืออะไร จนกะทั่ง คุณได้มัน
แต่ เราดึงคำสั่ง
ดังนั้น ในตัวอย่าง ที่เราได้มี, 
เราได้มี A9 ที่นี่
ดังนั้นตอนนี้เราจะต้องคิดออกมา A9 ทำอะไร

English: 
Now it needs to fetch the whole 
instruction that the CPU is gonna execute
and on the example we saw there 
it was relatively straightforward
because the instruction was only
a byte long
Not all CPU's are that simple
Some CPU's will vary these things,
so this hardware can actually be quite complicated
so it needs to work out how long 
the instruction is
So it could be as short as one byte
it could be as long on some CPU's
as 15 bytes
and you sometimes don't know how long it's gonna be until you've read at few of the bytes
So this hardware can be relatively trivial
So an ARM CPU makes it very, very simple
it says: all instructions are 32 bits long
So the Archimedes over there
can fetch the instruction very, very simply
32 bits
On something like an x86, it can be
any length up to 15 bytes or so
and so this becomes more complicated,
you have to sort of work out
what it is utnil you've got it
But we fetch the instruction
So in the example we've got, 
we've got A9 here
So we now need to work out what A9 does

Turkish: 
Şimdi bütün almak gerekiyor 
CPU'nun yürüteceğine dair talimat
ve orada gördüğümüz örnekte 
nispeten basitti
çünkü talimat sadece
uzun bir bayt
Tüm CPU'lar bu kadar basit değil
Bazı CPU'lar bu şeyleri değiştirecek,
bu yüzden bu donanım aslında oldukça karmaşık olabilir
bu yüzden ne kadar zaman çalışması gerekiyor 
talimat
Yani bir bayt kadar kısa olabilir
bazı CPU'larda olduğu gibi olabilir
15 bayt olarak
ve bazen baytların bir kaçını okuyana kadar ne kadar süreceğini de bilmiyorsun.
Yani bu donanım nispeten önemsiz olabilir
Öyleyse bir ARM CPU çok basit hale getirir
diyor ki: tüm talimatlar 32 bit uzunluğunda
Arşimet orada
talimatı çok basit bir şekilde alabilir
32 bit
Bir x86 gibi bir şey üzerinde olabilir
15 byte kadar herhangi bir uzunluk
ve böylece bu daha karmaşık hale gelir,
Bir çeşit iş yapmalısın.
neyin var onun
Ama talimatı alıyoruz
Yani elimizdeki örnekte, 
burada A9 var
Bu yüzden şimdi A9'un ne yaptığını çözmemiz gerekiyor

French: 
Maintenant, il a besoin de récupérer toute l'instruction qu'il va exécuter
et sur l'exemple c'est relativement simple parce que l'instruction n'avait qu'une taille d'un octet.
Pas tous les processeurs sont aussi simples.
Certains processeurs peuvent être très différents
et cette partie matérielle peut devenir très compliquée
parce qu'ils ont besoin de savoir quelle taille fait l'instruction.
Donc ça peut être aussi court qu'un octet mais peut être aussi long, sur certains processeurs, que 15 octets.
Et parfois, on ne sait pas de quelle taille elle va être tant qu'il n'a pas lu quelques octets.
Donc cette partie matérielle peut être relativement triviale,
par exemple un processeur ARM rend les choses très faciles, il dit que toutes les instructions font 32 bits.
Donc l'ordinateur juste là peut récupérer les instructions très simplement, 32 bits.
Sur un x86, ça peut être n'importe quelle taille jusqu'à 15 octets et devient donc plus compliqué
et vous devez en quelque sorte vous débrouiller avec jusqu'à ce que vous sachiez quelle est elle.
Mais on va récupérer ces instructions, dans l'exemple, on a A9 ici
donc on a maintenant besoin de savoir qu'est-ce que fait A9.

Turkish: 
Tamam, onu çözmemiz gerek 
İşlemcinin aslında ne yapmasını istiyoruz
Bu yüzden başka bir bit olmalı 
CPU donanımımız
buna adadık
komutun kodunu çözme
Öyleyse CPU’nun bir parçası var. 
getiriliyor
ve o zaman olan CPU'nun bir kısmı
çözme
Böylece içine A9 alır:
Böylece A9 kod çözme işlemine giriyor
Ve diyor ki: Peki tamam, bu bir yükleme talimatı.
Bu yüzden bellekten bir değer getirmem gerekiyor
hangisi 43
C büyük harf için ASCII kodu
daha önce gördüğümüz
Bu yüzden başka bir şey almalıyız. 
hafızadan
Belleğe tekrar erişmeliyiz,
ve hangi adresi bulmamız gerekiyor
Bu olacak.
Ayrıca o zaman ihtiyacımız var.
bir kere bu değeri elde ettikten sonra,
doğru kayıt defterini güncelle 
bu değeri saklamak
Yani sırayla bir şeyler yapmalıyız.
Yani Kod Çözme mantığının bir parçası
tek komut baytını almak,
veya ne kadar süreceği
ve CPU'nun diğer parçalarını yapmak için kullanmamız gereken dizinin ne olduğunu hesaplayın.
Ve bu da bizim sahip olduğumuz anlamına gelir.
CPU'nun başka bir kısmı
bu şeyleri yapan asıl şeydir,

Thai: 
อืม เราต้องถอดรหัสมันเป็น 
สิ่งที่เราต้องการให้ CPU ทำจริงๆ
ดังนั้นเราจึงจำเป็นต้องมีสิ่งอื่นอีกใน
ฮาร์ดแวร์ CPU ของเรา
ซึ่งเราทุ่มเทเพื่อ
ถอดรหัสคำสั่ง
ดังนั้น เราจึงมีส่วนหนึ่งของ CPU ซึ่ง
ดึงเรียกมัน
และอีกส่วนหนึ่งของ CPU ซึ่งทำการ
ถอดรหัสมัน
จึงได้รับ A9 เข้ามาในมัน:
ดังนั้น A9 เข้ามาในการถอดรหัส
และบอกว่า: อืมม โอเค นี่คือ โหลดคำสั่ง
ดังนั้น ผมต้องการเรียกค่าจากหน่วยความจำ
ซึ่งเป็น 43
รหัส ASCII สำหรับตัวอักษรตัวพิมพ์ใหญ่ C
ที่เราเห็นก่อนหน้านี้
ดังนั้น เราจึงจำเป็นต้องเรียกบางสิ่งอีก 
จากความทรงจำ
เราจำเป็นต้องเข้าถึงหน่วยความจำอีกครั้ง
และเราจำเป็นต้องคิดให้ออกว่า ที่อยู่
ที่จะเป็นคืออะไร
เมื่อเราได้มีค่านั้นแล้ว
เรายังจำเป็นต้อง
อัปเดตเรจิสเตอร์ที่ถูกต้อง 
ในการจัดเก็บค่านั้น
ดังนั้นเราจึงต้องทำสิ่งที่อยู่เป็นลำดับ
ดังนั้นส่วนหนึ่งของตรรกะถอดรหัส(decode logic) 
คือการเอาคำสั่งไบต์เดียว
หรือความยาวหลายไบต์เข้ามา
และการทำงานออกมาว่า อะไรคือสิ่งคือลำดับต่อไปที่เราต้องการที่จะทำในบิตอื่น ๆ ของ CPU
และนั่นก็หมายความว่าเรามี
บิตของ CPU อีก
ซึ่งเป็นบิตจริงที่ทำสิ่งต่างๆ

English: 
Well, we need to decode it into 
what we want the CPU to actually do
So we need to have another bit 
of our CPU's hardware
which we're dedicating to
decoding the instruction
So we have a part of the CPU which is 
fetching it
and part of the CPU which is then
decoding it
So it gets A9 into it:
So the A9 comes into the decode
And it says: Well okay, that's a load instruction.
So I need to fetch a value from memory
which was the 43
the ASCII code for the capital letter C
that we saw earlier
So we need to fetch something else 
from memory
We need to access memory again,
and we need to work out what address
that's gonna be.
We also then need to,
once we've got that value,
update the right register 
to store that value
So we've gotta do things in sequence.
So part of the Decode logic is to
take the single instruction byte,
or how long it is,
and work out what's the sequence that we need to drive the other bits of the CPU to do
And so that also means that we have
another bit of the CPU
which is the actual bit that does things,

French: 
Donc pour ça on doit le décoder en ce qu'on veut que le processeur fasse,
on doit avoir une autre partie matérielle du processeur qui est dédiée au décodage de l'instruction.
Donc une partie qui récupère (Fetch) et une partie qui décode (Decode).
Donc il récupère A9 qui arrive dans la partie «Décoder» et il dit:
«Ok, c'est une instruction «Charger» (Load Instruction) donc j'ai besoin d'aller récupérer une valeur en mémoire
qui était 43, le code ASCII pour le C majuscule qu'on a vu plus tôt.
Donc on doit récupérer autre chose de la mémoire donc on doit accéder à la mémoire à nouveau
et on doit trouver quelle adresse ça sera.
On a aussi besoin, une fois qu'on a récupéré la valeur, de mettre à jour le bon registre pour stocker cette valeur.
Il va faire les choses en séquence, la partie qui décode va prendre l'instruction d'un octet
et va chercher quelle est la séquence qui doit piloter ce que doivent faire les autres bits du processeur.
ça veut aussi dire qu'on a une autre partie du processeur qui est la partie qui fait des choses

English: 
which is gonna be all the logic 
which actually executes instructions
So we start off by fetching it
and then once we've fetched it
we can start decoding it
and then we can execute it
And the decode logic is responsible for saying:
Put the address for where you want to get the value,
that you can load into memory from
and then store it,
once it's been loaded into the CPU
So you're doing things in order:
We have to fetch it first
and we can't decode it until we've fetched it
and we can't execute things 
until we've decoded it
So, at any one time, 
we'll probably find on a simple CPU
that quite a few of the bits of the 
CPU wouldn't actually be doing anything
So, while we're fetching the value
from memory
to work out how we're gonna decode it
the decode and the execute logic 
aren't doing anything
They're just sitting there, waiting for their turn
And then, when we decode it,
it's not fetching anything
and it's not executing anything
So we're sort of moving through these different
states one after the other
And that takes different amounts of time
If we're fetching 15 bytes it's gonna take longer than
if we're fetching one
decoding it might well be shorter
than if we're fetching something from memory,
cos' this is all inside the CPU
And the execution depends on 
what's actually happening

French: 
qui va être toute la logique qui exécute les instructions.
Vous commencez par le récupérer et une fois qu'on l'a on peut commencer à le décoder puis l'exécuter.
Et la partie logique de décodage est responsable de l'adresse où on va aller chercher la valeur en mémoire
puis la stocker une fois qu'elle est chargée dans le processeur.
Donc on fait les choses dans l'ordre.
On doit récupérer d'abord car on ne peut pas décoder tant qu'on ne l'a pas récupéré
et on ne peut pas l'exécuter tant qu'on ne l'a pas décodé.
Donc à n'importe quel moment, on verrait probablement dans les processeurs assez simples que
que pas mal de bits du processeur ne bougeraient pas quand on fait quoi que ce soit.
Donc quand on récupère la valeur en mémoire pour voir comment on va décoder,
la partie logique de "Décodage" ne fait rien du tout. Il reste juste là à attendre son tour.
Quand il décode, il ne récupère rien et n'exécute rien.
Donc il bouge en quelque sort d'un état après l'autre.
Et ça prend différentes durées, récupérer 15 octets sera plus long qu'en récupérer un seul.
Si on décode, ça sera plus court qu'aller récupérer quelque chose en mémoire
parce que ça reste à l'intérieur du processeur.
Et l'exécution dépend de ce qu'il est en train de se passer.

Thai: 
ซึ่งเป็นตรรกะทั้งหมด
อันจริงที่ดำเนินการคำสั่ง
ดังนั้น เราจึงเริ่มต้นโดยเรียกดึงมัน
และจากนั้นเมื่อเราได้เรียกมัน
เราสามารถเริ่มต้นการถอดรหัสมัน
และแล้วเราสามารถดำเนินการได้
และตรรกะถอดรหัสเป็นผู้รับผิดชอบสำหรับการบอกว่า:
ใส่ที่อยู่สำหรับตำแหน่งที่คุณต้องการที่จะดึงค่า
แล้วคุณสามารถโหลดสู่หน่วยความจำ
แล้วเก็บมัน
เมื่อมันได้รับการโหลดลงในซีพียู
ดังนั้น คุณกำลังทำสิ่งต่างๆเป็นลำดับ:
เราต้องดึงมันมาเป็นอย่างแรก
และเราไม่สามารถถอดรหัสได้จนกว่าเราจะได้เรียกมัน
และเราไม่สามารถทำให้มันดำเนินการ ได้
จนกว่าเราจะได้ถอดรหัสมัน
ดังนั้นที่เวลาหนึ่งใด 
ที่เราอาจจะพบใน CPU ที่เรียบง่าย
ที่มีบิตของซีพียูไม่มาก
อาจไม่ได้ทำอะไรได้มาก
ดังนั้นในขณะที่เรากำลังเรียกค่า
จากความหน่วยจำ
ที่จะทำงานออกมา เราจะถอดรหัสมันอย่างไร
ตัวถอดรหัสและตรรกะดำเนินการ 
ไม่ได้ทำอะไร
พวกมันเพียงแค่อยู่ตรงที่นั่นรอการกลับ
และจากนั้น เมื่อเราถอดรหัสมัน
มันไม่ได้เรียกอะไร
และยังไม่ได้ดำเนินการอะไร
ดังนั้นเราได้เคลื่อนผ่านสถานะแตกต่างเหล่านี้
หนึ่งอันถัดไปเรื่อย
และต้องใช้ปริมาณเวลาที่แตกต่างกัน
ถ้าเราดึง 15 ไบต์มันจะใช้เวลานานกว่า
ถ้าเรากำลังเรียกหนึ่งไบต์
ถอดรหัสมัน อาจจะใช้เวลาสั้นกว่า
ถ้าเราจะเรียกอะไรบางอย่างจากหน่วยความจำ
เพราะ นี่คือทั้งหมดที่อยู่ภายในซีพียู
และการดำเนินการขึ้นอยู่กับ 
สิ่งที่เกิดขึ้นจริงๆ ตอนนั้น

Turkish: 
ki bütün mantık olacak 
hangi aslında talimatları yürütür
Bu yüzden onu getirerek başlıyoruz
ve sonra onu bir kez aldık
çözmeye başlayabiliriz
ve sonra onu çalıştırabiliriz
Kod çözme mantığı şöyle demekten sorumludur:
Değeri almak istediğiniz yerin adresini girin,
belleğe yükleyebileceğiniz
ve sonra sakla,
bir kez CPU'ya yüklendiğinde
Yani sırayla işler yapıyorsun:
Önce onu almalıyız.
ve onu alana kadar çözemeyiz.
ve bir şeyleri yürütemeyiz 
biz çözene kadar
Yani, herhangi bir zamanda, 
muhtemelen basit bir CPU'da bulacağız
bu bitlerin epeyce 
CPU aslında hiçbir şey yapmazdı
Yani, değeri alırken
hafızadan
nasıl çözeceğimizi öğrenmek için
kod çözme ve yürütme mantığı 
hiçbir şey yapmıyor
Sadece orada oturuyorlar, sırasını bekliyorlar
Ve sonra, onu çözdüğümüzde,
hiçbir şey almıyor
ve hiçbir şey yürütmüyor
Yani biz bu farklı arasında ilerliyoruz
birbiri ardına
Ve bu farklı zaman alır
Eğer 15 byte alıyorsak, bundan daha uzun sürecek.
eğer birini alıyorsak
çözme işlemi daha kısa olabilir
bellekten bir şey alıyorsak,
çünkü bu hepsi işlemcinin içinde
Ve yürütme bağlıdır 
gerçekte ne oluyor

English: 
So your CPU will work like this:
It will go through each phase,
then once it's done that, 
it'll start on the next clock tick
all the CPU's are synchronized to a clock,
which just keeps things moving in sequence
and you can build a CPU. 
Something like the 6502 worked like that
But, as we said, lots of the CPU aren't actually 
doing anything at any time
which is a bit wasteful of the resources
So is there another way you can do this?
And the answer is yes!
You can do what's called
a sort of pipe-lined model of a CPU
So what you do here is,
you still have the same 3 bits of the CPU
But you say: Okay, so we gotta fetch (f)
instruction one
In the next bit of time,
I'm gonna start decoding this one
So, I'm gonna start decoding instruction one
But I'm gonna say: I'm not using 
the fetch logic here,
so I'm gonna have this start to get things ready
and, start to do things ahead of schedule
I'm also at the same time
gonna fetch instruction 2
So now I'm doing two things,
two bit's of my CPU in use the same time
I'm fetching the next instruction,
while decoding the first one

Thai: 
ดังนั้น CPU ของคุณจะทำงานเช่นนี้
มันจะผ่านไปแต่ละเฟส
จากนั้นเมื่อมีการได้ทำสิ่งนั้นเสร็จ
มันจะเริ่มต้นในสัญญาณนาฬิกาถัดไป
ทั้งหมดของ CPU จะถูกเข้าจังหวะกับนาฬิกา
ซึ่งก็ช่วยให้สิ่งต่างๆ ที่เคลื่อนไปเป็นลำดับ
และคุณสามารถสร้างซีพียู 
แบบ 6502 ให้ทำงานเช่นเดียวกันนี้
แต่ ที่เรากล่าวว่า CPU จำนวนมากไม่ได้
ทำอะไรในเวลาใดก็ได้จริง ๆ
ซึ่งเป็นอะไรที่สิ้นเปลืองทรัพยากร
มีวิธีการอะไรคุณสามารถทำเช่นนี้อีกมั้ย?
และคำตอบคือ มี!
คุณสามารถทำสิ่งที่เรียกว่า
รูปแบบท่อเรียงรายของซีพียู (pipe-lined model)
ดังนั้นสิ่งที่คุณทำที่นี่ คือ
คุณยังคงมีเหมือนกันใน CPU 3 บิต
แต่คุณบอกว่า: เอาล่ะเราต้องดึง (f)
คำสั่งหนึ่ง
ในบิตถัดไปของเวลา
ฉันจะเริ่มต้นการถอดรหัสอันนี้
ดังนั้น ผมจะเริ่มต้นการถอดรหัสคำสั่งหนึ่ง
แต่ผมจะบอกว่า: ฉันไม่ได้ใช้ 
ตรรกะดึง (fetch logic) ที่นี่
ดังนั้น ผมต้องมีสิ่งเริ่มต้นที่จะได้สิ่งที่พร้อม
และเริ่มต้นที่จะทำสิ่งนำหน้ากำหนดการ (schedule)
ผมจะยังสามารถดึงคำสั่งที่สอง
ในเวลาเดียวกันด้วย
ดังนั้น ตอนนี้ผมทำสองสิ่ง
สองบิตของ CPU ของผม ในการใช้งานในเวลาเดียวกัน
ผมเรียกคำสั่งต่อไปมา
ขณะถอดรหัสคำสั่งแรก

Turkish: 
Böylece CPU'nuz bu şekilde çalışacaktır:
Her aşamadan geçecek,
o zaman bir kere yapıldığında, 
Bir sonraki saat kene başlayacak
Tüm CPU'lar bir saat ile senkronize edilir,
hangi şeyler sırayla hareket ediyor
ve bir işlemci oluşturabilirsiniz. 
6502 gibi bir şey böyle çalıştı
Ancak, dediğimiz gibi, pek çok CPU aslında değil 
herhangi bir zamanda bir şey yapmak
bu biraz kaynak israfıdır
Peki bunu yapmanın başka bir yolu var mı?
Ve cevap evet!
Ne denirse yapabilirsin
bir çeşit CPU'lu boru hattı modeli
Yani burada ne iş yapıyorsun?
hala CPU'nun aynı 3 bitine sahipsin
Ama sen diyorsun ki: Tamam, öyleyse getirmeliyiz (f).
birinci talimat
Bir sonraki zaman diliminde
Bunu çözmeye başlayacağım
Yani, bir tane kod çözme başlayacağım
Ama diyeceğim: Kullanmıyorum 
buraya getir mantığı
bu yüzden işleri yoluna sokmaya başlayacağım
ve programın öncesinde bir şeyler yapmaya başla
Bende aynı zamanda
2. talimatı alacak
Şimdi iki şey yapıyorum.
CPU'mun iki biti aynı anda kullanılıyor
Bir sonraki talimatı alıyorum.
ilki şifresini çözerken

French: 
Donc votre processeur travaillera comme ça, il va passer par chaque phase et une fois qu'il aura terminé,
il recommencera sur le prochain tick d'horloge.
Tous les processeurs sont synchronisés à une horloge qui garde les composants en séquence
et vous pouvez construire un processeur un peu de la façon comment le 6502 fonctionne, de cette manière.
Mais comme on l'a dit la plupart des processeurs ne font en réalité pas grand chose à un moment donné.
Ce qui est en fait un gaspillage de ressources.
Donc y a-t-il une autre façon de faire ça ?
Et la réponse est oui, vous pouvez faire ce qu'on appelle en quelque sorte le modèle Pipeline pour un processeur.
Ce que vous faites ici, c'est que vous avez toujours les 3 mêmes composants du processeur.
Mais vous dites: «On va récupérer l'instruction 1»
je vais utiliser un F. (pour Fetch)
«Dans la prochaine unité de temps, je vais commencer par décoder celle là,
donc on commence à décoder l'instruction 1.»
Mais je vais dire que je n'utilise pas la logique de récupération qu'on a vu
donc je vais commencer à avoir les choses prête à l'avance.
«Et dans le même temps
je vais récupérer l'instruction 2.»
Donc là je fais 2 choses en même temps, 2 composant du processeur sont utilisés.

Turkish: 
Bir kere kod çözmeyi yaptıktan sonra başlayabilirim.
ilk talimatın yerine getirilmesi
Bu yüzden onu yürütmek
Ama aynı zamanda başlayabilirim
kod çözme talimatı 2
ve umutla, 
Talimat almaya 3 başlayabilirim
Ne olmuş yani? Hala aynı alıyor
bu ilk talimatı yerine getirmek için gereken süre
Yani güzellik o zaman 
komut iki yürütmeye geliyor
tam olarak bir tane tamamlar 
birbiri ardına döngü
gitmek için beklemek zorunda kalmak yerine 
getirme ve kod çözme ve döngüleri yürütme
en kısa sürede çalıştırabiliriz
tamamlanmış öğretim
Yani her talimat hala 
aynı zaman miktarı
Örneğin, üç saat döngüsü alacak
CPU üzerinden gitmek için
çünkü onu bir araya getirdik.
aslında birbiri ardına infaz ediyor gibi görünüyorlar
bu yüzden bir saat döngüsü yürütmek gibi görünüyor
birbirinden sonra
Ve bunu tekrar yapabiliriz
Böylece kod çözmeye başlayabiliriz
burada talimat 3
aynı anda ikinci talimatı yerine getirirken
Şimdi problemler olabilir
Bu bazı talimatlar için çalışır,
ama bu talimatı söyle
"bu değeri hafızada sakla" dedi
Şimdi bir problemin var

French: 
En fait je vais récupérer la prochaine instruction pendant que je décode la première
et on une fois qu'on a fait le décodage, je peux commencer à exécuter la première instruction,
donc je vais exécuter ça.
Mais au même moment je peux commencer à décoder l'instruction 2
et on espère pouvoir commencer à récupérer l'instruction 3.
Et alors ?
On prend toujours la même durée pour exécuter cette première instruction.
La beauté c'est que quand on veut exécuter l'instruction 2, ça s'exécute exactement un cycle après l'autre
plutôt que d'attendre qu'il passe par les cycles de récupération, décodage et exécution,
on peut juste l'exécuter dès qu'on a fini l'instruction 1.
Donc chaque instruction prend toujours la même durée, disons 3 cycles d'horloge pour traverser le processeur
mais parce qu'on les a en quelque sorte enchaînées, il semble qu'elles s'exécutent les unes après les autres.
Donc il semble que qu'elle s'exécutent un cycle d'horloge après celui de la précédente.
Et on peut recommencer, on peut commencer à décoder l'instruction 3 en même temps qu'on exécute la 2.
Maintenant, le problème qu'on peut avoir c'est que ça marche pour certaines instructions
mais, disons que cette instruction stocke une valeur en mémoire, on a un problème.

Thai: 
และเมื่อเราได้ทำถอดรหัส ผมสามารถเริ่มต้น
การดำเนินการทำคำสั่งแรกได้
ดังนั้นผมจึงดำเนินการทำมัน
แต่ในเวลาเดียวกัน ผมสามารถเริ่มต้น
การถอดรหัสคำสั่งที่สองได้ด้วย
และหวังว่า 
ผมจะเริ่มต้นดึงคำสั่งที่สาม
ดังนั้นอะไร? มันยังคงใช้ระยะเวลา
ในการดำเนินการที่เท่าที่ทำคำสั่งแรก
ดังนั้นความงดงามคือ เมื่อมัน 
มาถึงการดำเนินการทำคำสั่งที่สอง
มันเสร็จสิ้นที่ 
หนึ่งรอบ
แทนที่จะต้องรอให้มันผ่านไป ดึงข้อมูลและ
ถอดรหัสและดำเนินการทำเป็นลำดับรอบ
เราก็สามารถดำเนินการได้ทันทีที่เราได้
เสร็จสิ้นการเรียกคำสั่งที่หนึ่ง
ดังนั้น ในแต่ละคำสั่งยังคงใช้
ระยะเวลาเหมือนกัน
มันใช้เวลา, พูดง่ายๆว่า 
สามรอบนาฬิกาซีพียูผ่านไป
แต่เป็นเพราะเราทำไปป์ไลน์มันเข้าด้วยกัน
พวกมันปรากฏในการดำเนินทำสิ่งหนึ่งหลังจากสิ่งหนึ่ง
จึงปรากฏว่าการดำเนินการทำในหนึ่งรอบสัญญาณนาฬิกาหนึ่ง
ต่อจากการดำเนินการทำคำสั่งก่อนหน้า
และเราสามารถทำเช่นนี้ อีกครั้ง
ดังนั้น เราจึงสามารถเริ่มต้นการถอดรหัส
คำสั่งที่สาม ที่นี่
ในเวลาเดียวกับที่เรากำลังดำเนินการทำคำสั่งที่สอง
ตอนนี้อาจมีปัญหา
งานนี้สำหรับบางคำสั่ง
แต่ บอกว่าคำสั่งนี้
บอกว่า "การจัดเก็บค่านี้ในหน่วยความจำ"
ตอนนี้คุณได้มีปัญหา

English: 
And once we've done decoding, I can start
executing the first instruction
So I execute that
But at the same time, I can start
decoding instruction 2
and hopefully, 
I can start fetching instruction 3
So what? It is still taking the same
amount of time to execute that first instruction
So the beauty is when it 
comes to executing instruction two
it completes exactly one 
cycle after the other
rather than having to wait for it to go through 
the fetch and decode and execute cycles
we can just execute it as soon as we've
finished instruction one
So each instruction still takes the 
same amount of time
it's gonna take, say, three clock cycles
to go through the CPU
but because we've sort of pipelined it together
they actually appear to execute one after each other
so it appears to execute one clock cycle
after each other
And we could do this again
So we could start decoding
instruction 3 here
at the same time as we're executing instruction two
Now there can be problems
This works for some instructions,
but say this instruction
said "store this value in memory"
Now you've got a problem

English: 
You've only got one address bus 
and one data bus
so you can only access or store
one thing in memory at a time
You can't execute a store instruction and fetch a value from memory
So you wouldn't be able to fetch it until the next clock cycle
So we fetch instruction four there
while executing instruction three
But we can't decode anything here
So in this clock cycle, we can 
decode instruction four
and fetch instruction five
but we can't execute anything
We've got what's called a "bubble"
in our pipelines,
or pipeline store
because at this point,
the design of the CPU doesn't let us
fetch an instruction
and execute an instruction at the same time
it's ... what is called "pipeline hazards"
that you can get when designing a pipeline CPU
because the design of the CPU
doesn't let you
do the things you need to 
do at the same time
at the same time.
So you have to
delay things, which means that 
you get a bubble
So, you can't quite get up to 
one instruction per cycle
efficiency
But you can certainly get closer
than you could if you 
just had everything
to do one instruction at a time.

Turkish: 
Sadece bir adres yolunuz var 
ve bir veri yolu
böylece yalnızca erişebilir veya depolayabilirsiniz
bir seferde hafızada bir şey
Bir mağaza talimatı uygulayamaz ve bellekten bir değer alamazsınız.
Yani bir sonraki saat döngüsüne kadar getiremezsin
Öyleyse orada dördüncü talimatı alıyoruz.
üçüncü talimatı yürütürken
Ama burada hiçbir şeyi çözemiyoruz
Yani bu saat döngüsünde 
dördüncü kod çözme
ve talimat 5'i getir
ama hiçbir şey yapamayız
"Kabarcık" denilen şeye sahibiz.
Boru hatlarımızda
veya boru hattı mağazası
çünkü bu noktada,
CPU tasarımı bize izin vermiyor
talimat getir
ve aynı anda bir talimat yürütmek
bu ... "boru hattı tehlikesi" denir
bir boru hattı CPU tasarlarken elde edebileceğiniz
cpu tasarımı çünkü
sana izin vermiyor
ihtiyacınız olan şeyleri yapın 
aynı anda yapmak
aynı zamanda.
Yani zorundasın
işleri geciktirmek, yani 
bir balonun olsun
Yani, tam olarak kalkamıyorsun 
döngü başına bir talimat
verim
Ama kesinlikle yaklaşabilirsin
eğer yapabilirsen 
sadece her şeye sahiptim
Bir seferde bir talimat yapmak için.

Thai: 
คุณได้มีเพียงบัสที่อยู่หนึ่ง 
และบัสข้อมูลหนึ่ง
แต่ละครั้ง คุณเลยสามารถเข้าถึงหรือไม่ก็หรือเก็บ
สิ่งหนึ่งในหน่วยความจำ
คุณไม่สามารถดำเนินการทำการจัดเก็บและเรียกค่าจากหน่วยความจำ พร้อมกัน
ดังนั้นคุณจะไม่สามารถดึงมันได้จนกว่ารอบสัญญาณนาฬิกาถัดไป
ดังนั้นเราดึงคำสั่งที่สี่ ที่นี่
ในขณะที่ดำเนินการทำคำสั่งที่สาม
แต่เราไม่สามารถถอดรหัสอะไรได้ ที่นี่
ดังนั้น ในวงรอบสัญญษณนาฬิกานี้เราสามารถ 
ถอดรหัสคำสั่งที่สี่ได้
และเรียกคำสั่งที่ห้าเข้ามา
แต่เราไม่สามารถดำเนินการอะไรได้
เรามีสิ่งที่เรียกว่า "ฟอง"
ในท่อ
หรือไปป์ไลน์ของเรา
เพราะที่จุดนี้
การออกแบบของ CPU ที่ไม่ได้ยอมให้เรา
ดึงคำสั่ง
และดำเนินการทำคำสั่งในเวลาเดียวกัน
มันเป็น ... สิ่งที่เรียกว่า "pipeline hazards"
ที่คุณจะได้เจอ เมื่อมีการออกแบบซีพียูท่อ
เพราะการออกแบบของ CPU
ไม่ยอมให้คุณ
ทำในสิ่งที่คุณจำเป็นต้องทำ 
ในเวลาเดียวกันได้
ดังนั้น ในเวลาเดียวกัน.
คุณต้อง
ทำให้เกิดการล่าช้า 
ซึ่งหมายความว่า คุณจะได้รับฟอง
ดังนั้นคุณไม่สามารถได้ทำหนึ่งคำสั่ง
ในหนึ่งรอบนาฬิกา
อย่างมีประสิทธิภาพเสียทีเดียว
แต่คุณสามารถได้เข้าใกล้ความประสิทธิภาพอย่างแน่นอน
มากกว่ากว่าที่คุณจะทำได้
ถ้าคุณเพียงแค่มีทุกอย่าง
ที่จะกระทำการทีละสิ่งต่อเนื่องกันไปเป็นลำดับ

French: 
On ne peut récupérer ou stocker qu'une seule valeur au même moment.
Vous ne pouvez pas exécuter une instruction de stockage et récupérer une valeur en mémoire.
Donc on ne pourrais pas être capable de récupérer la valeur avant le prochain cycle d'horloge
donc récupérer l'instruction 4 ici pendant l'exécution de l'instruction 3, mais on ne peut rien décoder.
Donc dans ce cycle d'horloge, on décode l'instruction 4 et récupére l'instruction 5 mais on ne peut rien exécuter.
On a ce qu'on appelle une «bulle» dans notre pipeline (ou «Pipeline Stall»)
parce qu'à cet instant, le design du processeur ne nous permet pas de récupérer et exécuter en même temps.
C'est ce qu'on appelle un risque de pipeline que l'on peut obtenir quand un designe un pipeline de processeur
parce que le designer du processeur ne vous laisse pas faire ce que vous avez besoin de faire en même temps au même moment.
Vous devez donc retarder les choses, ce qui signifie que vous obtenez une bulle
donc vous ne pouvez pas arriver strictement à une efficacité d'une instruction par cycle.
Mais vous pouvez certainement plus vous en approcher que si vous le faites une instruction à la fois.

French: 
Extrait de la vidéo sur l'hololens:
[...] qu'il a ajouter ce contenu est vraiment étroit.
Je pense que c'est l'équivalent d'un écran 15 pouces à une distance normale.
Donc vraiment mon champ de vision a du contenu augmenté et ça sonne mal mais c'est pas si mal.

Thai: 
บรรยายไทยโดย ytuaeb sciencemath
