Video
Đăng bởi Ban biên tập OpenER ·
Tác giả giữ toàn bộ bản quyền (All Rights Reserved) — không phải giấy phép mở. Bạn vẫn xem và học miễn phí trên OpenER; muốn tái sử dụng cần xin phép tác giả.
Right. Hello everyone. So welcome to the fourth discussion session for EECS 151/251A.
Được rồi. Xin chào mọi người. Chào mừng các bạn đến với buổi thảo luận thứ tư của môn EECS 151/251A.
So today we're going to, we're going to talk about the RISC-V ISA and basically how to make a CPU, the baby steps for that.
Hôm nay chúng ta sẽ nói về RISC-V ISA và về cơ bản là cách xây dựng một CPU, những bước đầu tiên.
So let's talk about what really RISC-V is, and then talk about how to implement a CPU that runs RISC-V, which is going to be these four things.
Trước hết hãy nói xem RISC-V thực sự là gì, rồi nói về cách hiện thực một CPU chạy RISC-V, gồm bốn phần này.
We're going to talk about control signals, ALU, pipeline exercises, and some hazards.
Chúng ta sẽ nói về tín hiệu điều khiển, ALU, các bài tập về đường ống và một số hazard.
All right, so RISC-V. RISC-V is a type of instruction set architecture. Right.
Được rồi, RISC-V. RISC-V là một loại kiến trúc tập lệnh. Đúng không.
And what instruction set architecture is, also called ISA, you can think of it as kind of a manual to talk to hardware. All right.
Kiến trúc tập lệnh, còn gọi là ISA, là gì? Bạn có thể xem nó như một cuốn sổ tay để giao tiếp với phần cứng. Được rồi.
So if you have like a program, say like a .exe file, that's going to be in binary format, right? It's going to be in a bunch of zeros and ones.
Giả sử bạn có một chương trình, chẳng hạn một tệp .exe, thì nó ở dạng nhị phân, đúng không? Nó là một chuỗi các số không và số một.
But we need to have a way to tell what those zeros and ones mean. Right.
Nhưng ta cần có cách để biết những số không và số một đó có nghĩa là gì.
We want to have the program make the sense out of it, you know, to tell if this program is about adding something, loading something from the memory and so on.
Ta muốn chương trình hiểu được ý nghĩa của chúng, để biết chương trình này làm phép cộng, hay nạp một giá trị từ bộ nhớ, v.v.
And the same way, you know, the hardware has to understand it the same way, obviously, right? So that the software and hardware are running the same thing.
Và tương tự như vậy, phần cứng rõ ràng cũng phải hiểu theo đúng cách đó, đúng không? Để phần mềm và phần cứng cùng chạy một thứ như nhau.
So you can think of the ISA as kind of a structured way of interpreting these binary bits. And also you can think of it as kind of an instruction barrier between hardware and software.
Vì vậy bạn có thể xem ISA như một cách có cấu trúc để diễn giải các bit nhị phân này. Bạn cũng có thể xem nó như một ranh giới lệnh giữa phần cứng và phần mềm.
So the cool thing about the instruction set architecture is a program that is written in one ISA is going to be able to run in different hardwares that implement the same ISA.
Điều thú vị của kiến trúc tập lệnh là một chương trình viết cho một ISA có thể chạy trên nhiều phần cứng khác nhau hiện thực cùng ISA đó.
So say we have a bunch of CPUs that's from other companies like SiFive or some other processors that's actually made here in Berkeley.
Giả sử ta có nhiều CPU của các công ty như SiFive hoặc một số bộ xử lý khác thực ra được chế tạo ngay tại Berkeley.
Or, you know, some other companies like say Intel, if they ever make a RISC-V chip. Because all of these chips implement the RISC-V ISA, we don't have to worry about any compatibility issues, right?
Hoặc một số công ty khác như Intel, nếu họ có làm chip RISC-V. Vì tất cả các chip này đều hiện thực RISC-V ISA, nên ta không phải lo về vấn đề tương thích, đúng không?
It's the same program, and all the hardware talks the same ISA.
Cùng một chương trình, và mọi phần cứng đều dùng chung một ISA.
So there are some examples of the ISAs that we actually use a lot in our life. You guys think of the most popular ISA that we use currently?
Có một số ví dụ về các ISA mà ta dùng rất nhiều trong đời sống. Các bạn nghĩ ISA phổ biến nhất hiện nay là gì?
It's one of the ISAs that you use on your x86 computers, right? Well, it's literally called x86. So x86 is developed by Intel and AMD.
Đó là một trong các ISA bạn dùng trên máy tính x86, đúng không? Thì nó tên đúng là x86. x86 do Intel và AMD phát triển.
And that's going to be pretty much the ISA that has the most popularity right now. But some other examples are ARM.
Và đó gần như là ISA phổ biến nhất hiện nay. Một số ví dụ khác là ARM.
So that's what the Apple's M1 chip runs, right? And the chip that goes into iPhone, things like Bionic. And RISC-V is just one example of that.
Đó là thứ mà chip M1 của Apple chạy, đúng không? Và cả chip trong iPhone, như Bionic. Còn RISC-V chỉ là một ví dụ như vậy.
So you might ask, why specifically RISC-V? What are we learning about? So the thing about RISC-V is, first of all, it's a free and open source project.
Vậy bạn có thể hỏi, tại sao lại cụ thể là RISC-V? Vậy chúng ta đang học về điều gì? Điều đáng nói về RISC-V là trước hết, nó là một dự án miễn phí và mã nguồn mở.
Meaning that, first of all, it's free of charge for using it. You don't have to pay any fees for that.
Nghĩa là trước hết, sử dụng nó không mất phí. Bạn không phải trả bất kỳ khoản phí nào cho việc đó.
And also it's open source, meaning everyone can contribute to the project and modify it to their own needs.
Và nó còn là mã nguồn mở, nghĩa là ai cũng có thể đóng góp cho dự án và sửa đổi nó theo nhu cầu riêng.
So basically, if you want RISC-V to do some of the custom operations that you can think about, like video decoding, machine learning inference, or ray tracing, that kind of thing, you can just go ahead, fork the repository, and add your own modifications.
Về cơ bản, nếu bạn muốn RISC-V thực hiện một số phép toán tùy biến mà bạn có thể nghĩ tới, như giải mã video, suy luận của học máy (machine learning inference), hay dò tia (ray tracing), kiểu như vậy, thì bạn cứ việc fork repository, rồi thêm các sửa đổi của riêng mình.
So that's a pretty cool thing about RISC-V. That makes it very good for education, because we don't have to worry about any licensing fees. And RISC-V is gaining more and more adoption in industry.
Đó là một điểm khá thú vị của RISC-V. Điều đó khiến nó rất phù hợp cho giáo dục, vì chúng ta không phải lo về phí cấp phép. Và RISC-V ngày càng được ngành công nghiệp áp dụng nhiều hơn.
So more and more vendors are building chips for RISC-V. And pretty much the most prominent effort for that is the company called SiFive.
Ngày càng có nhiều nhà cung cấp chế tạo chip cho RISC-V. Và nỗ lực nổi bật nhất trong lĩnh vực này gần như là của công ty có tên SiFive.
So any question about RISC-V, the instructions?
Vậy có câu hỏi nào về RISC-V, về các lệnh không?
If it gets confusing about things like how jalr works, when do we set the least bits to zero, and all kinds of that, just look at the spec.
Nếu bạn thấy khó hiểu về những thứ như jalr hoạt động thế nào, khi nào thì đặt các bit thấp nhất về 0, và đủ thứ như vậy, thì cứ xem bản đặc tả.
That's going to be the definitive source here. And it's also written in a very readable format. And it also explains a lot of the reasons behind the design choice.
Đó sẽ là nguồn tham khảo chuẩn xác nhất ở đây. Nó cũng được viết ở dạng rất dễ đọc. Và nó còn giải thích nhiều lý do đằng sau các lựa chọn thiết kế.
So yeah, anything, especially when you get to implement your own RISC-V core in your project, you will get to read a lot of the spec there.
Vậy nên, bất cứ điều gì, đặc biệt khi bạn bắt tay vào cài đặt lõi RISC-V của riêng mình trong đồ án, bạn sẽ phải đọc bản đặc tả đó rất nhiều.
And obviously, that's going to be the basis of the course project.
Và hiển nhiên, đó sẽ là cơ sở của đồ án môn học.
So let's point out some of the glossaries that we're going to use for talking about RISC-V. The ISA we talked about, Instruction Set Architecture.
Giờ hãy điểm qua một số thuật ngữ mà chúng ta sẽ dùng khi nói về RISC-V. ISA thì chúng ta đã nói rồi, là Instruction Set Architecture (kiến trúc tập lệnh).
ALU, which is pretty much the calculator that goes in the CPU, the thing that adds the numbers, multiplies, subtracts, and all of that. It's called Arithmetic Logic Unit.
ALU, gần như là chiếc máy tính bỏ túi nằm trong CPU, thành phần thực hiện cộng, nhân, trừ các số và đủ thứ như vậy. Nó được gọi là Arithmetic Logic Unit (đơn vị số học và logic).
Program Counter is a register that stores a number or an address in the memory that points to exactly which point in the program we're currently executing.
Program Counter là một thanh ghi lưu một số hay một địa chỉ trong bộ nhớ trỏ chính xác tới vị trí nào trong chương trình mà chúng ta đang thực thi.
We have to keep track of exactly which part, which instruction we're executing currently in the program. And as the clock cycle moves on, we're going to move on in the program.
Chúng ta phải theo dõi chính xác phần nào, lệnh nào trong chương trình đang được thực thi. Và khi chu kỳ xung nhịp trôi qua, chúng ta sẽ tiến tiếp trong chương trình.
So the Program Counter keeps track of it. Immediate Values, that means when you want to encode a value inside the instruction itself. Usually you're going to work with the registers.
Program Counter theo dõi điều đó. Immediate Values (giá trị tức thời), nghĩa là khi bạn muốn mã hóa một giá trị ngay bên trong chính lệnh. Thông thường bạn sẽ làm việc với các thanh ghi.
You're going to store the values in the registers and you're going to read from them to get the actual numbers.
Bạn sẽ lưu các giá trị trong thanh ghi và đọc từ chúng để lấy các số thực sự.
But you can also store the actual numbers inside the instruction itself, and that's going to be called Immediate Values. Byte is simply an 8-bit value.
Nhưng bạn cũng có thể lưu các số thực sự ngay trong chính lệnh, và đó gọi là Immediate Values. Byte đơn giản là một giá trị 8 bit.
So if there are 8 bits, they go to form a byte. And the word for RISC-V is a 4-byte value or 32-bit value.
Tức là 8 bit gộp lại tạo thành một byte. Còn word trong RISC-V là một giá trị 4 byte, hay 32 bit.
And all of the instructions are going to be one word size. So that's going to be the size of the instruction. Now, there are some optimizations for the RISC-V ISA.
Và tất cả các lệnh đều có kích thước bằng một word. Đó sẽ là kích thước của một lệnh. Bây giờ, có một số tối ưu hóa cho RISC-V ISA.
You can have something called Compressed Format, where each instruction can be 2 bytes long. But in these slides, we're going to just talk about the default configuration, where everything is 4 bytes.
Bạn có thể có một thứ gọi là Compressed Format, trong đó mỗi lệnh có thể dài 2 byte. Nhưng trong các slide này, chúng ta chỉ nói về cấu hình mặc định, trong đó mọi thứ đều là 4 byte.
Path Forward, obviously, is 16-bit value or 2 byte value.
Path Forward, hiển nhiên, là giá trị 16 bit hay giá trị 2 byte.
Let's talk about some of the instruction formats. Like I said, ISA can be seen as a structured way to interpret the bits.
Hãy nói về một số định dạng lệnh. Như tôi đã nói, ISA có thể được xem là một cách có cấu trúc để diễn giải các bit.
And here are some of the different ways of interpreting those bits in a single instruction, which is 32 bits.
Và đây là một số cách khác nhau để diễn giải các bit đó trong một lệnh duy nhất, dài 32 bit.
Depending on these types, RISC-V, UJ, you can think of, say, this specific field as either the destination register or some part of the Immediate Values.
Tùy vào các kiểu này, RISC-V, UJ, bạn có thể xem chẳng hạn trường cụ thể này là thanh ghi đích hoặc một phần của các giá trị tức thời.
And one thing to note about these instruction formats is, although it's named after some of those alphabets that kind of imply what they do, they don't always follow the actual instruction.
Và một điều cần lưu ý về các định dạng lệnh này là, mặc dù chúng được đặt tên theo một số chữ cái gợi ý chúng làm gì, chúng không phải lúc nào cũng khớp với lệnh thực tế.
So, for example, the I-type, you can think of it as doing mostly arithmetic. It's used for the arithmetic instructions, but it's not always used for arithmetic. Also, JOM instructions sometimes use I-type.
Ví dụ, kiểu I, bạn có thể nghĩ nó chủ yếu làm các phép số học. Nó được dùng cho các lệnh số học, nhưng không phải lúc nào cũng dùng cho số học. Ngoài ra, đôi khi các lệnh JOM cũng dùng kiểu I.
So you can think of it as kind of a separate thing as to what the instruction actually does. And that can be confusing.
Vì vậy bạn có thể xem đó là một điều tách biệt với việc lệnh thực sự làm gì. Và điều đó có thể gây nhầm lẫn.
All right, so let's look at some of the details of what these instructions do. So now we're going to talk about what instructions actually, how they actually behave.
Được rồi, hãy xem một số chi tiết về việc các lệnh này làm gì. Bây giờ chúng ta sẽ nói về việc các lệnh thực sự hoạt động như thế nào.
So the first type is the arithmetic instructions, right? And they use either R-type or I-type.
Loại đầu tiên là các lệnh số học, đúng không? Và chúng dùng kiểu R hoặc kiểu I.
It depends on if you want to do arithmetic operation on the registers, so like RS1 and RS2, those are going to be the operand registers, where those are the values that we use to do computing.
Điều đó tùy vào việc bạn có muốn thực hiện phép toán số học trên các thanh ghi hay không, như RS1 và RS2, đó sẽ là các thanh ghi toán hạng, là các giá trị mà ta dùng để tính toán.
And then we're going to store that somewhere, right, to use that value later in the program. And that's going to be the destination register. So that's the R-type instruction.
Rồi ta sẽ lưu kết quả đó ở đâu đó, đúng không, để dùng giá trị đó sau này trong chương trình. Và đó sẽ là thanh ghi đích. Đó là lệnh kiểu R.
And I-type is when you want to just use one register and use an immediate value That's simply encoded inside the instruction, okay? So that's going to be for the I-type.
Còn kiểu I là khi bạn chỉ muốn dùng một thanh ghi và một giá trị tức thời được mã hóa ngay bên trong lệnh, được chứ? Đó sẽ là kiểu I.
Load and store, those are the memory instructions, right, when we read or write something from the memory. And they're going to be using I-type and S-type.
Load và store là các lệnh bộ nhớ, đúng không, khi ta đọc hoặc ghi một thứ gì đó từ bộ nhớ. Và chúng sẽ dùng kiểu I và kiểu S.
Again, you can see that the I-type is used both in arithmetic and load-store. Usually load instructions use I-type and store uses the S-type.
Một lần nữa, bạn thấy kiểu I được dùng cho cả số học lẫn load-store. Thông thường lệnh load dùng kiểu I còn store dùng kiểu S.
So the difference between load and store is whether we want to keep track of the resulting value or not.
Sự khác biệt giữa load và store là ở việc ta có muốn theo dõi giá trị kết quả hay không.
So if we load data from the memory, right, we want to store that to a register, obviously, because we just read that value from the memory and we have to keep track of it.
Nếu ta load dữ liệu từ bộ nhớ, đúng không, ta muốn lưu nó vào một thanh ghi, hiển nhiên, vì ta vừa đọc giá trị đó từ bộ nhớ và ta phải theo dõi nó.
So that's why for the load, we're going to use something like read from the memory, where the address is RS1 plus immediate.
Vì vậy với load, ta sẽ dùng thứ như đọc từ bộ nhớ, trong đó địa chỉ là RS1 cộng giá trị tức thời.
But for the store, we're going to simply store the value to the memory, right? So we're going to just do something like RS2 to mem.
Nhưng với lệnh store, ta chỉ đơn giản lưu giá trị vào bộ nhớ, đúng không? Vậy ta sẽ chỉ làm một thứ như RS2 vào mem.
And we're not going to store anything into the registers, right? So that's the reason why we use different types for load and store. We're going to use a byte address memory model.
Và ta sẽ không lưu gì vào các thanh ghi cả, đúng không? Đó là lý do ta dùng các kiểu lệnh khác nhau cho load và store. Ta sẽ dùng mô hình bộ nhớ đánh địa chỉ theo byte.
And what that means is we view the memory as at least like one-dimensional array where we have multiple slots, right? And each of those slots, there's going to be one byte value.
Điều đó có nghĩa là ta xem bộ nhớ như ít nhất là một mảng một chiều gồm nhiều ô, đúng không? Và mỗi ô như vậy sẽ chứa một giá trị một byte.
So say we address something, we have a number that represents an address. We're going to think that in that address, a one byte lives in there. And that's called byte addressing.
Giả sử ta đánh địa chỉ một vị trí, ta có một con số biểu diễn địa chỉ. Ta sẽ coi rằng tại địa chỉ đó có một byte. Và đó gọi là đánh địa chỉ theo byte.
We're going to use little-endian system. Now, what this means is usually you're going to load and store data that is longer than one byte, right?
Ta sẽ dùng hệ little-endian. Điều này có nghĩa là thông thường bạn sẽ load và store dữ liệu dài hơn một byte, đúng không?
Say if you're going to store like an invalid, the C program, there can be four bytes long.
Chẳng hạn nếu bạn lưu một biến int, trong chương trình C, nó có thể dài bốn byte.
So the endianness, little-endian or big-endian, defines the order of those bytes that we're going to store in the memory. So say there's a number that we want to store, which is four bytes long.
Vậy endianness, little-endian hay big-endian, xác định thứ tự các byte đó khi ta lưu vào bộ nhớ. Giả sử có một số cần lưu, dài bốn byte.
From 31st bit to 0th bit, we have A, B, C, B byte. How our little-endian works is that the least significant byte is going to go to the lower address.
Từ bit 31 đến bit 0, ta có các byte A, B, C, D. Little-endian hoạt động như sau: byte có trọng số thấp nhất sẽ nằm ở địa chỉ thấp hơn.
So we're going to store D first. Imagine we're going to store it to the 2 address. We're going to store D first and then C, B, A.
Vậy ta sẽ lưu D trước. Hình dung ta lưu nó vào địa chỉ 2. Ta lưu D trước, rồi đến C, B, A.
So that might be a little confusing, but it's just one way of storing multi-byte value.
Điều này có thể hơi khó hiểu, nhưng nó chỉ là một cách lưu giá trị nhiều byte.
The other system is big-endian, obviously, where we're going to store them to the reverse order, where the most significant byte comes to the lower address and the least significant goes to the higher address.
Hệ còn lại tất nhiên là big-endian, trong đó ta lưu theo thứ tự ngược lại, byte có trọng số cao nhất nằm ở địa chỉ thấp hơn và byte có trọng số thấp nhất nằm ở địa chỉ cao hơn.
Little-endian is used popular in both RISC-V and also x86. And that's the standard we're adopting.
Little-endian được dùng phổ biến ở cả RISC-V và x86. Và đó là chuẩn mà ta áp dụng.
Also, like I said, load and store granularity will vary by the bytes.
Ngoài ra, như tôi đã nói, độ chi tiết của load và store sẽ thay đổi theo số byte.
You can either load and store just one byte, which we write by something like store byte or load byte, or we can load and store a one-half word or a word.
Bạn có thể load và store chỉ một byte, mà ta viết là store byte hoặc load byte, hoặc ta có thể load và store nửa từ hoặc một từ.
And you might think, what are these U characters there?
Và bạn có thể thắc mắc các ký tự U ở đó là gì?
The thing is, if we're going to load a byte value, we're going to store that to this destination register, but the destination register is actually four-byte large.
Vấn đề là nếu ta load một giá trị byte, ta sẽ lưu nó vào thanh ghi đích này, nhưng thanh ghi đích thực ra rộng bốn byte.
So we have to have a way of extending that one byte to four-byte value.
Vì vậy ta cần một cách mở rộng một byte đó thành giá trị bốn byte.
If there's no U in there, we're going to do a sign extension, meaning if we read this one byte from the memory and the Rd register is four-byte, depending on the sign bit there, if it's one, then we're going to extend all the remaining bits with one.
Nếu không có U, ta sẽ mở rộng dấu (sign extension), nghĩa là nếu ta đọc một byte này từ bộ nhớ và thanh ghi Rd rộng bốn byte, tùy vào bit dấu ở đó, nếu nó là một, thì ta sẽ mở rộng toàn bộ các bit còn lại bằng một.
So that's the sign extension.
Đó là mở rộng dấu.
If we do LBU, then we do unsigned extension, meaning even though the sign bit of that one byte was one, we're going to ignore that and just extend everything with zero.
Nếu ta dùng LBU, thì ta mở rộng không dấu, nghĩa là dù bit dấu của byte đó là một, thì ta sẽ bỏ qua nó và chỉ mở rộng toàn bộ bằng bit 0.
Those are obviously different operations, and we need a distinction between them. So load byte and load byte U.
Rõ ràng đây là hai phép toán khác nhau, và ta cần phân biệt chúng. Vậy có load byte và load byte U.
Let's talk about branches.
Bây giờ nói về các lệnh rẽ nhánh.
So branches, you learned from the lecture that it's doing a comparison between two values, and depending on the result, we're going to jump to a completely different address in the program.
Với lệnh rẽ nhánh, các bạn đã học trong bài giảng rằng nó so sánh hai giá trị, và tùy vào kết quả, ta sẽ nhảy tới một địa chỉ hoàn toàn khác trong chương trình.
So naturally, it's going to have to use two register values with which we're going to do the comparison, and depending on the result, if it's taken, we're going to jump to PC plus IMM, where the immediate value actually means the offset, offsets from the current location we are in in the program.
Vì vậy, đương nhiên nó phải dùng hai giá trị thanh ghi để thực hiện phép so sánh, và tùy vào kết quả, nếu nhánh được thực hiện (taken), ta sẽ nhảy tới PC cộng IMM, trong đó giá trị tức thời (immediate) thực chất là độ lệch, tính từ vị trí hiện tại của ta trong chương trình.
If the branch is not taken, then we're going to just move to PC plus 4, which is simply the next enabling instruction in the program, and the 4 comes from the fact that each instruction is 4 bytes.
Nếu nhánh không được thực hiện, ta chỉ chuyển sang PC cộng 4, tức đơn giản là lệnh kế tiếp trong chương trình, và số 4 xuất phát từ việc mỗi lệnh dài 4 byte.
That's going to be the B type. Also note that there's no RD there because we're not storing anything to the destination register. Jumps, now jumps have RD.
Đó là dạng B. Cũng lưu ý là ở đây không có RD vì ta không lưu gì vào thanh ghi đích. Còn lệnh nhảy thì có RD.
The reason for that is when we jump to some position in the program, we always want to remember where to come back to.
Lý do là khi nhảy tới một vị trí nào đó trong chương trình, ta luôn muốn nhớ nơi để quay trở lại.
So that's going to be used for things like, say, we have in a main function or something, we call a function, right?
Nó được dùng cho những trường hợp như, giả sử trong hàm main, ta gọi một hàm, đúng không?
Then we have to jump to that function, which actually lives in a different location in the program.
Khi đó ta phải nhảy tới hàm đó, mà hàm này nằm ở một vị trí khác trong chương trình.
So we can do that using jal or jalr, but at the end of the function, we're going to have to return back to where we are, using return in the C program.
Ta có thể làm vậy bằng jal hoặc jalr, nhưng ở cuối hàm, ta sẽ phải quay trở lại chỗ ban đầu, bằng return trong chương trình C.
So it's useful to really keep track of where we jump from, and that's going to be stored in the RD, so that in that return, we're going to simply do jump to RD, Which will bring us back right after the function.
Vì vậy rất hữu ích khi theo dõi được ta đã nhảy từ đâu, và địa chỉ đó sẽ được lưu vào RD, để khi return, ta chỉ cần nhảy tới RD, và nó đưa ta về ngay sau lời gọi hàm.
So that's why we need the RD value.
Đó là lý do ta cần giá trị RD.
And depending on the different types, the jal will simply update the PC to PC plus IMM, and jalr will be about jump to the PC with RS1 plus IMM,
Còn tùy từng loại, jal đơn giản sẽ cập nhật PC thành PC cộng IMM, còn jalr là nhảy tới PC với RS1 cộng IMM,
and both of these operations are going to update the RD with PC plus 4.
và cả hai phép toán này đều cập nhật RD bằng PC cộng 4.
I know in my lecture, you were talking about how we have it, we don't have the zero bit, so we can, it's basically RD2.
Em biết trong bài giảng của thầy, thầy có nói về việc ta không có bit 0, nên về cơ bản nó là RD2.
If you end up jumping to a half instruction, like the, the confessed instruction, how will that cause the alignment for the next instructions to change?
Nếu cuối cùng ta nhảy tới giữa một lệnh, như lệnh nén ấy, thì điều đó làm căn chỉnh của các lệnh tiếp theo thay đổi thế nào?
Because I'm guessing you're still going to be implementing your PC plus 4. Yeah, that's a good point. Yeah, that's going to be an illegal instruction.
Vì em đoán là ta vẫn sẽ thực hiện PC cộng 4. Vâng, câu hỏi hay. Đó sẽ là một lệnh không hợp lệ.
So you can have that kind of instruction that uses a multiple of 2-byte address in a 4-byte instruction format, and that's going to pretty much mess up the operation of the program.
Vậy là bạn có thể có loại lệnh dùng một bội số của địa chỉ 2 byte trong định dạng lệnh 4 byte, và điều đó gần như sẽ làm hỏng hoạt động của chương trình.
So that's something that the software programmer has to be careful about, but usually we don't have to worry about it because we just use the compiler.
Vì vậy đó là điều mà lập trình viên phần mềm phải cẩn thận, nhưng thường thì chúng ta không phải lo về nó vì chúng ta chỉ dùng trình biên dịch.
The compiler knows the type of the hardware, and if it's a 4-byte hardware, they're not going to generate any half-word address things, right?
Trình biên dịch biết loại phần cứng, và nếu là phần cứng 4 byte, nó sẽ không sinh ra những địa chỉ nửa từ nào, đúng không?
But that's going to be an illegal instruction, and we don't want to do that. So we'll never run into a condition where we have to jump to a half. Yeah, yeah.
Vì đó sẽ là một lệnh không hợp lệ, và chúng ta không muốn như vậy. Nên chúng ta sẽ không bao giờ gặp trường hợp phải nhảy tới một nửa lệnh. Vâng, vâng.
So the other type of the instruction is operate-immediate, and this is used for just encoding the upper byte of the immediate value.
Vậy loại lệnh còn lại là operate-immediate, và loại này chỉ dùng để mã hóa byte cao của giá trị immediate.
So you might have noticed that for all the previous instruction formats, we just encode the lower few bits of the immediate, right?
Có thể bạn đã nhận thấy rằng với tất cả các định dạng lệnh trước đó, chúng ta chỉ mã hóa vài bit thấp của immediate, đúng không?
Because the immediate value, what we want is the full 4-byte value, which is the size of the register.
Vì với giá trị immediate, thứ chúng ta muốn là giá trị đầy đủ 4 byte, tức là kích thước của thanh ghi.
But then the instruction itself is only 4 bytes large, and if you exclude the part where we put the opcode and RS1, We're not left with a lot of bits.
Nhưng bản thân lệnh chỉ có kích thước 4 byte, và nếu trừ phần chúng ta đặt opcode và RS1, thì không còn lại nhiều bit.
So then we're going to use this operate-immediate format to set the remaining bits of the register with the higher bits of the immediate.
Vì vậy chúng ta sẽ dùng định dạng operate-immediate này để đặt các bit còn lại của thanh ghi bằng các bit cao của immediate.
So say if we have already set the lower bytes, the lower bits, then you're going to use the operate-immediate to set the remaining bits, and that's where the high bits of immediate encoding is used.
Ví dụ, nếu chúng ta đã đặt xong các byte thấp, các bit thấp, thì bạn sẽ dùng operate-immediate để đặt các bit còn lại, và đó là chỗ dùng cách mã hóa các bit cao của immediate.
Okay. Any other questions so far? Yeah. What's the difference between AUIPC and AUIPC? Oh, AUIPC is for storing the PC.
Được rồi. Còn câu hỏi nào nữa không? Vâng. Khác nhau giữa AUIPC và AUIPC là gì? À, AUIPC dùng để lưu PC.
Yeah, AUIPC is for storing the PC. They always add to it. It doesn't zero out the lower bits. AUIPC? Yes, AUIPC.
Vâng, AUIPC dùng để lưu PC. Chúng luôn cộng vào nó. Nó không xóa về 0 các bit thấp. AUIPC? Vâng, AUIPC.
So I think what I know is... Yeah, I think they don't zero out the lower bits. So it's an add-in to the previous state and setup.
Theo tôi biết thì... Vâng, tôi nghĩ chúng không xóa về 0 các bit thấp. Nên nó là phép cộng thêm vào trạng thái trước đó.
Yeah, that's what I recall, but I think you better check the spec to make sure, yeah.
Vâng, tôi nhớ là như vậy, nhưng tốt hơn bạn nên kiểm tra lại đặc tả cho chắc, vâng.
All right. So move on. Okay, let's now think about how to make this into CPU. So here we have the datapath diagram, where you're pretty much looking at a circuit, right?
Được rồi. Chúng ta tiếp tục. Bây giờ hãy nghĩ cách biến cái này thành CPU. Đây là sơ đồ datapath, mà về cơ bản là bạn đang nhìn một mạch, đúng không?
But at a higher level. We're not going to draw the actual AND gates or OR gates. We're going to abstract them out into these blocks with certain shapes.
Nhưng ở mức cao hơn. Chúng ta sẽ không vẽ các cổng AND hay OR thực sự. Chúng ta sẽ trừu tượng hóa chúng thành các khối có hình dạng nhất định.
And you might notice that some of the parts are colored differently. And those are the different stages of the datapath that does different things.
Và bạn có thể thấy một số phần được tô màu khác nhau. Đó là các giai đoạn khác nhau của datapath, mỗi giai đoạn làm một việc khác nhau.
First stage is going to be fetch, because we got to have an instruction that we're going to work with. And we're going to fetch that from outside the CPU, which is the memory.
Giai đoạn đầu tiên sẽ là fetch, vì chúng ta phải có một lệnh để làm việc với nó. Và chúng ta sẽ lấy lệnh đó từ bên ngoài CPU, tức là bộ nhớ.
And so after that, we're going to have the 4-byte value, which is going to be the instruction we're going to work in.
Sau đó, chúng ta sẽ có giá trị 4 byte, chính là lệnh mà chúng ta sẽ xử lý.
And on the next stage, we're going to actually decode that instruction to make sense of what it does.
Và ở giai đoạn tiếp theo, chúng ta sẽ giải mã lệnh đó để hiểu nó làm gì.
Depending on the different types that we talked about, We're going to extract the RS1 value, RS2, or immediate values in that stage. And obviously, that's going to take some more combinational logic.
Tùy theo các loại khác nhau mà chúng ta đã nói tới, Ở giai đoạn đó, chúng ta sẽ trích xuất giá trị RS1, RS2 hoặc các giá trị immediate. Và rõ ràng là việc đó sẽ cần thêm một ít logic tổ hợp.
So we need a separate stage for that. Also, we're going to do register read here. If the instruction has something like RS1, we have to actually read the RS1 value from the register.
Vì vậy chúng ta cần một giai đoạn riêng cho việc này. Ngoài ra, chúng ta cũng sẽ thực hiện đọc thanh ghi ở đây. Nếu lệnh có một thành phần như RS1, thì chúng ta phải đọc giá trị RS1 từ thanh ghi.
So we're going to do things like go to the RS1 register in the file and read it. Next, we're going to do the actual computation, which is the execute stage.
Nên chúng ta sẽ đi tới thanh ghi RS1 trong tệp thanh ghi và đọc nó. Tiếp theo, chúng ta sẽ thực hiện phép tính thực sự, đó là giai đoạn thực thi.
Now, we have all the numbers that we need. We have the register contents. We have the immediate values and everything.
Bây giờ, chúng ta đã có tất cả các số cần thiết. Chúng ta có nội dung của các thanh ghi. Chúng ta có các giá trị immediate và mọi thứ khác.
So we're going to use that to actually do things like additions, multiplications, also branch comparisons, and so on. So that's going to be where the actual work happens.
Vì vậy chúng ta sẽ dùng chúng để thực hiện các phép như phép cộng, phép nhân, cũng như so sánh rẽ nhánh, v.v. Đó chính là nơi công việc thực sự diễn ra.
Next, we have a separate stage for memory access. Because, say, if the instruction is load or store, then we need to access the memory, right?
Tiếp theo, chúng ta có một giai đoạn riêng cho truy cập bộ nhớ. Vì giả sử lệnh là load hoặc store, thì chúng ta cần truy cập bộ nhớ, đúng không?
But the first part that we access the memory was just for the instruction part. We have to read what we are going to do the instruction.
Nhưng lần đầu tiên chúng ta truy cập bộ nhớ chỉ là để lấy lệnh. Chúng ta phải đọc xem mình sẽ thực hiện lệnh gì.
But then, depending on that, we're going to actually have to access the memory again if it's a load or store.
Nhưng sau đó, tùy vào lệnh đó, chúng ta sẽ thực sự phải truy cập bộ nhớ một lần nữa nếu đó là load hoặc store.
So that's going to be a separate stage here. Now, we have a write back. That's like a really, really bunch up there. It actually happens in the register stage.
Vì vậy đó sẽ là một giai đoạn riêng ở đây. Bây giờ, chúng ta có write back. Nó nằm dồn hẳn lại ở phía đó. Nó thực sự diễn ra tại khối thanh ghi.
Because, like I said, if things are like R type or I type, where we store back to the destination register, we're going to have to look into the register again and write things back, right?
Vì như tôi đã nói, nếu là các lệnh kiểu R hoặc kiểu I, nơi chúng ta lưu kết quả trở lại thanh ghi đích, thì chúng ta sẽ phải truy cập lại thanh ghi và ghi dữ liệu trở lại, đúng không?
So that's going to be happening at a separate stage. But at the same register file in that block.
Vì vậy việc đó sẽ diễn ra ở một giai đoạn riêng. Nhưng vẫn tại cùng tệp thanh ghi trong khối đó.
So the components you notice here are, first of all, there's data path, which is these blocks and arrows connected together. And that literally shows how the data moves along these paths, right?
Vậy các thành phần các bạn thấy ở đây, trước hết là đường dữ liệu (data path), tức là các khối và mũi tên nối với nhau này. Và nó thể hiện đúng nghĩa đen cách dữ liệu di chuyển dọc theo các đường này, đúng không?
It's about the data movement. But we still have these kind of like muxes. We have to find a way to route those data, path of the data, depending on the actual type of instruction.
Nó nói về sự di chuyển của dữ liệu. Nhưng chúng ta vẫn có những mux như thế này. Chúng ta phải tìm cách định tuyến dữ liệu, đường đi của dữ liệu, tùy theo loại lệnh thực tế.
So we're going to have to have a separate control logic, which decides these selection signals for those muxes or commands the ALU to do a specific operation like addition and subtraction, depending on the instruction type.
Vì vậy chúng ta sẽ phải có một khối logic điều khiển riêng, quyết định các tín hiệu chọn cho những mux đó hoặc ra lệnh cho ALU thực hiện một phép toán cụ thể như cộng và trừ, tùy theo loại lệnh.
Also, we have external memory, which we just abstracted out using these blocks, right? So these are actually outside the CPU.
Ngoài ra, chúng ta có bộ nhớ ngoài, mà chúng ta vừa trừu tượng hóa bằng các khối này, đúng không? Vì vậy những khối này thực ra nằm ngoài CPU.
We're going to have to have a large capacity of memory, say like 4 gigabytes or 8 gigabytes that we're going to work with, because we're going to store a lot of data and read a lot of data.
Chúng ta sẽ phải có một bộ nhớ dung lượng lớn, chẳng hạn như 4 gigabyte hoặc 8 gigabyte để làm việc, vì chúng ta sẽ lưu rất nhiều dữ liệu và đọc rất nhiều dữ liệu.
And we don't want to put that inside the CPU, because that's going to be a very large block.
Và chúng ta không muốn đặt nó bên trong CPU, vì đó sẽ là một khối rất lớn.
So we're just going to abstract that into this memory block, which is really like a memory interface, and the actual memory is going to live outside the CPU.
Vì vậy chúng ta chỉ trừu tượng hóa nó thành khối bộ nhớ này, mà thực chất giống như một giao diện bộ nhớ, và bộ nhớ thực sự sẽ nằm bên ngoài CPU.
So like I said, the control signals is about how to reroute those paths and command those blocks to do specific operations.
Như tôi đã nói, các tín hiệu điều khiển là để định tuyến lại những đường đi đó và ra lệnh cho các khối đó thực hiện những phép toán cụ thể.
And some of the, first of all, the inputs of that control signal is obviously going to be instruction, because we have to find out which type, you know, R, I, S, B, or whatever.
Và một số, trước hết, các đầu vào của tín hiệu điều khiển đó hiển nhiên sẽ là lệnh, vì ta phải xác định xem nó thuộc loại nào, R, I, S, B, hay gì đó.
We have to find out the type of the instruction to figure out the mux signals and everything.
Ta phải xác định loại của lệnh để tìm ra các tín hiệu mux và mọi thứ khác.
Another input here is actually the result of the branch comparison, because depending on the branch comparison, we're going to decide things like, are we going to jump to PC plus 4, PC plus immediate, and that kind of thing.
Một đầu vào khác ở đây là kết quả của phép so sánh rẽ nhánh, vì tùy thuộc vào phép so sánh rẽ nhánh, ta sẽ quyết định những việc như ta sẽ nhảy tới PC cộng 4, PC cộng immediate, hay những thứ tương tự.
So those are going to be additional inputs. Some of the outputs, really all kinds of signals that we're going to, you know, input to those data blocks are going to be control signals.
Vậy đó sẽ là những đầu vào bổ sung. Về các đầu ra, thực ra mọi loại tín hiệu mà ta đưa vào các khối dữ liệu đó đều sẽ là tín hiệu điều khiển.
But some of the examples are PC sel.
Nhưng một số ví dụ là PC sel.
Like I said, depending on the branch comparison, we're going to set PC to either PC plus 4 or PC plus immediate, and that's going to be what the PC cell does.
Như tôi đã nói, tùy thuộc vào phép so sánh rẽ nhánh, ta sẽ đặt PC bằng PC cộng 4 hoặc PC cộng immediate, và đó chính là việc mà PC sel làm.
Likewise, ALU cell will select which mode of operation the ALU will do: addition, subtraction, multiplication, and so on.
Tương tự, ALU sel sẽ chọn chế độ hoạt động mà ALU sẽ thực hiện: cộng, trừ, nhân, v.v.
All right, so speaking of ALU, let's look at an example of how you can implement an ALU. You're going to write the ALU as a Verilog module, right?
Được rồi, nói đến ALU, hãy xem một ví dụ về cách bạn có thể hiện thực một ALU. Bạn sẽ viết ALU dưới dạng một module Verilog, đúng không?
And I think that's the part of lab 4 that you're going to do. And the ALU is an arithmetic unit, which means it's going to do all kinds of different arithmetic and logic operations.
Và tôi nghĩ đó là phần của lab 4 mà các bạn sẽ làm. ALU là một đơn vị số học, nghĩa là nó sẽ thực hiện đủ loại phép toán số học và logic khác nhau.
And let's say we have like 10 modes of that. We're going to do things like addition, subtractions, bit shifts, or bitwise AND, which are the Boolean algebra, and so on.
Giả sử ta có khoảng 10 chế độ như vậy. Ta sẽ làm những việc như cộng, trừ, dịch bit, hoặc AND theo bit, vốn là đại số Boolean, v.v.
So the easiest way of writing this in Verilog is using a case statement, right?
Cách dễ nhất để viết điều này trong Verilog là dùng câu lệnh case, đúng không?
I'm going to just define these constants and use a case statement, and depending on those case clauses, you're going to just use these nice Verilog operators.
Tôi sẽ chỉ định nghĩa các hằng số này và dùng câu lệnh case, và tùy theo các nhánh case đó, bạn sẽ chỉ cần dùng các toán tử Verilog tiện lợi này.
You're not going to actually write how the addition works in terms of AND, NOT, OR gates. The Verilog operations will take care of that.
Bạn sẽ không phải viết phép cộng hoạt động thế nào theo các cổng AND, NOT, OR. Các phép toán của Verilog sẽ lo việc đó.
And you have to just worry about what this operator does, and you can use things like these ternary operations to implement those.
Bạn chỉ cần quan tâm toán tử này làm gì, và bạn có thể dùng những thứ như toán tử ba ngôi này để hiện thực chúng.
All right, so again, this is the RISC-V data path, but right now we just had a glimpse of it.
Được rồi, một lần nữa, đây là đường dữ liệu RISC-V, nhưng hiện giờ ta mới chỉ thoáng nhìn qua nó.
We don't really know how each of these parts works, so let's do some exercise here. Let's say we have an ADD instruction.
Ta chưa thực sự biết từng phần này hoạt động ra sao, nên hãy làm một bài tập ở đây. Giả sử ta có một lệnh ADD.
So ADD is an R-type instruction, and it's going to have the RD field, which is going to be working with the RS1 field and the RS2 field, right?
ADD là lệnh kiểu R, và nó sẽ có trường RD, làm việc với trường RS1 và trường RS2, đúng không?
So what happens in the data path? Which of these wires are we going to actually use?
Vậy điều gì xảy ra trong đường dữ liệu? Ta sẽ thực sự dùng những đường dây nào trong số này?
So we're going to start with reading PC, because obviously we have to figure out which location in the program we're currently in.
Ta sẽ bắt đầu bằng việc đọc PC, vì hiển nhiên ta phải tìm ra chúng ta hiện đang ở vị trí nào trong chương trình.
We're going to get the PC and input that to the memory block to read the actual 4 bytes value that's stored in that PC. So now we have the instruction.
Chúng ta sẽ lấy PC và đưa vào khối bộ nhớ để đọc giá trị 4 byte thực sự được lưu tại PC đó. Vậy là bây giờ chúng ta đã có lệnh.
Now, like I said, we need RS1, RS2, and RD fields from that instruction. So that's going to be the RS1, RS2, and RD, right?
Giờ thì, như tôi đã nói, chúng ta cần các trường RS1, RS2 và RD từ lệnh đó. Vậy đó sẽ là RS1, RS2 và RD, đúng không?
And depending on those RS1 and RS2, the register will actually read the contents in the RS1 and RS2 and put that on this wire, data A, data B.
Và tùy thuộc vào RS1 và RS2 đó, tệp thanh ghi sẽ đọc nội dung trong RS1 và RS2 rồi đặt lên các dây này, data A, data B.
That's going to go to the ALU to actually do the addition, right? Now, obviously, we have to set these selection signals for those MUXes to the correct one.
Chúng sẽ đi tới ALU để thực hiện phép cộng, đúng không? Dĩ nhiên, chúng ta phải đặt các tín hiệu chọn của những MUX đó về đúng giá trị.
So again, that's what the control signal does.
Một lần nữa, đó chính là việc của tín hiệu điều khiển.
It controls things like the MUXes, the operations of ALUs, that the register is going to do a read, not write, and it's going to figure that all out by reading the instruction itself.
Nó điều khiển những thứ như các MUX, phép toán của ALU, việc thanh ghi sẽ thực hiện đọc chứ không phải ghi, và nó xác định tất cả những điều đó bằng cách đọc chính lệnh.
So the output of the ALU, now we have the RS1 plus RS2 value there, right?
Vậy đầu ra của ALU, bây giờ ở đó có giá trị RS1 cộng RS2, đúng không?
That's going to get routed all the way back to the register because we're going to have to store that to RD, right? And obviously, another control signal has to come from the control logic.
Giá trị đó sẽ được dẫn ngược trở lại thanh ghi vì chúng ta phải lưu nó vào RD, đúng không? Và dĩ nhiên, một tín hiệu điều khiển khác phải đến từ logic điều khiển.
Now, one thing we missed here is we have to update the PC with a new one because the sequential logic, and you always have to provide sequential logic with the next state.
Bây giờ, một thứ chúng ta còn thiếu ở đây là phải cập nhật PC bằng giá trị mới vì đây là logic tuần tự, và bạn luôn phải cung cấp trạng thái kế tiếp cho logic tuần tự.
So for addition, we're going to just simply move on to the next one, right? The next neighboring instruction.
Với phép cộng, chúng ta chỉ đơn giản chuyển sang lệnh kế tiếp, đúng không? Tức là lệnh liền kề.
So we're going to set the PC with PC plus 4, which are going to happen in this additional block.
Vậy chúng ta sẽ đặt PC bằng PC cộng 4, việc này diễn ra trong khối cộng bổ sung này.
This is different from the ALU block because the ALU actually does the addition of those data and we're doing addition on the address, which is a different thing.
Nó khác với khối ALU vì ALU thực sự thực hiện phép cộng các dữ liệu đó, còn ở đây chúng ta cộng trên địa chỉ, đó là một việc khác.
So the PC plus 4 are going to be fed into the D input port of the PC. Does this make sense?
Vậy PC cộng 4 sẽ được đưa vào cổng đầu vào D của PC. Mọi người có hiểu không?
All right, Let's look at JAL. So let's recall what JAL does. JAL was about...
Được rồi, hãy xem JAL. Hãy nhắc lại JAL làm gì. JAL là...
It's a J type instruction where we simply have RD and immediate. We're omitting the other fields like opcodes.
Đó là lệnh kiểu J, trong đó chúng ta chỉ có RD và giá trị tức thời. Chúng ta bỏ qua các trường khác như opcode.
And the thing it's going to do is it's going to update the PC with PC plus offset value, which is in the immediate field, and then also update the RD with PC plus 4.
Và việc nó làm là cập nhật PC bằng PC cộng giá trị độ lệch nằm trong trường tức thời, và đồng thời cập nhật RD bằng PC cộng 4.
So that's going to... Let's also walk through what happens. First, we always start from the PC to read the current instruction. This time we need the immediate value, right?
Vậy nó sẽ... Hãy cùng đi qua những gì xảy ra. Đầu tiên, ta luôn bắt đầu từ PC để đọc lệnh hiện tại. Lần này chúng ta cần giá trị tức thời, đúng không?
So we're going to take the immediate field and also we're going to need the RD. So that's going to go to the address D.
Vậy chúng ta sẽ lấy trường tức thời và cũng cần RD. Cái đó sẽ đi tới địa chỉ D.
The immediate value will actually get extended to the full 4 bytes because the thing we have here is only a subset of those 4 bytes.
Giá trị tức thời sẽ được mở rộng thành đủ 4 byte vì thứ chúng ta có ở đây chỉ là một phần của 4 byte đó.
This immediate generation block will do things like sign extensions, adding more zeros at the end to get the full 4 bytes.
Khối sinh giá trị tức thời này sẽ thực hiện những việc như mở rộng dấu, thêm các số 0 ở cuối để có đủ 4 byte.
And that's going to go into ALU because we're going to do an addition. And that addition is going to be also done with the PC.
Và giá trị đó sẽ đi vào ALU vì chúng ta sẽ thực hiện một phép cộng. Và phép cộng đó cũng được thực hiện với PC.
So the PC now this time goes into the ALU right here. So at this point we have PC plus immediate and that's going to be the new PC value, right?
Vậy lần này PC đi vào ALU ngay ở đây. Tới thời điểm này ta có PC cộng immediate và đó sẽ là giá trị PC mới, đúng không?
So that's actually going to go like here to be the next value of PC. So that's how we do the actual job.
Vậy nên giá trị đó sẽ đi như thế này, tới đây để trở thành giá trị tiếp theo của PC. Đó là cách ta thực hiện công việc chính.
And then there's one thing we missed here, right? Which is updating the RD with PC plus 4. The PC plus 4 is actually conveniently right here. That addition is always done here.
Và còn một thứ chúng ta đã bỏ sót ở đây, đúng không? Đó là cập nhật RD bằng PC cộng 4. PC cộng 4 thực ra có sẵn ngay ở đây. Phép cộng đó luôn được thực hiện ở đây.
So we're going to just take that value, feed it to this MUX, and that's going to be written back to register.
Vậy ta chỉ cần lấy giá trị đó, đưa vào MUX này, và nó sẽ được ghi ngược lại vào thanh ghi.
Obviously, we're going to have to input the right control signals to these ALUs, MUXs, and so on.
Tất nhiên, ta sẽ phải đưa các tín hiệu điều khiển phù hợp vào các ALU, các MUX, v.v.
All right. Now, JALR. JALR is pretty much the most mind-bending one here.
Được rồi. Bây giờ là JALR. JALR gần như là lệnh khó hình dung nhất ở đây.
JALR is an I-type instruction, meaning that it will now have all RD, immediate, and RS1. Okay.
JALR là một lệnh kiểu I, nghĩa là lúc này nó sẽ có đủ RD, immediate, và RS1. Được rồi.
So the operation for that is going to be update PC with this time's RS1 value, or the register file's RS1 value, plus immediate, and then update RD with PC plus 4.
Phép toán của nó là cập nhật PC bằng giá trị RS1 lần này, hay giá trị RS1 của tệp thanh ghi, cộng immediate, rồi cập nhật RD bằng PC cộng 4.
So the idea is pretty similar. Let's start with the PC again. We now take RS1 and RD and immediate, right? It's going to be generated to the full 4 bytes.
Ý tưởng khá giống trước. Ta lại bắt đầu từ PC. Bây giờ ta lấy RS1, RD và immediate, đúng không? Nó sẽ được sinh ra thành đủ 4 byte.
It's going to the ALU, and now this time we're going to do the addition with RS1, not the PC, so that's going to come from here.
Nó đi vào ALU, và lần này ta sẽ thực hiện phép cộng với RS1, không phải PC, nên giá trị đó sẽ đến từ đây.
And at that point, it's the RS1 plus immediate that's going to go to the PC, right?
Và lúc đó, RS1 cộng immediate sẽ đi vào PC, đúng không?
And then, again, we have to update the RD with PC plus 4.
Rồi một lần nữa, ta phải cập nhật RD bằng PC cộng 4.
So we're going to do the same thing, which is just take the PC plus 4 from here and write it back to RD.
Vậy ta làm điều tương tự, tức là lấy PC cộng 4 từ đây và ghi ngược lại vào RD.
I'm just going to omit the control signals at this point. Any questions so far?
Tới đây tôi sẽ bỏ qua các tín hiệu điều khiển. Đến giờ có câu hỏi nào không?
All right. So here we have a branch instruction. So branch is a B type, meaning it's going to have RS1, RS2, and immediate.
Được rồi. Ở đây ta có một lệnh rẽ nhánh. Lệnh rẽ nhánh là kiểu B, nghĩa là nó sẽ có RS1, RS2 và immediate.
And what we're going to do here is a little more tricky. Now, the PC is going to be updated with either PC plus immediate or PC plus 4, right?
Và việc ta làm ở đây phức tạp hơn một chút. Bây giờ PC sẽ được cập nhật bằng PC cộng immediate hoặc PC cộng 4, đúng không?
Depending on the conditional signal, which is this branch taken or not. And that taken or not will be taken from the comparison between RS1 and RS2.
Tùy vào tín hiệu điều kiện, tức là rẽ nhánh có được thực hiện hay không. Và việc có thực hiện hay không được lấy từ phép so sánh giữa RS1 và RS2.
We do the compare, and that's going to produce the taken value.
Ta so sánh, và nó sẽ tạo ra giá trị taken.
So there are going to be two things happening here, and this part has to happen first in order to update the PC with the right one.
Vậy ở đây sẽ có hai việc diễn ra, và phần này phải xảy ra trước để cập nhật PC bằng giá trị đúng.
Let's walk through again. Start with PC, get the instructions. We're going to use RS1 and RS2 this time, and also the immediate.
Ta đi qua lại một lần nữa. Bắt đầu với PC, lấy lệnh. Lần này ta sẽ dùng RS1 và RS2, và cả immediate.
The immediate flows through the immediate generation block, which now goes to... Well, the immediate is actually used for PC.
Immediate đi qua khối sinh immediate, giờ sẽ đi tới... À, thực ra immediate được dùng cho PC.
So it's going to go to the ALU, where we're also going to get PC to do the PC plus immediate addition here, right?
Vì vậy nó sẽ đi tới ALU, nơi chúng ta cũng lấy PC để thực hiện phép cộng PC cộng immediate ở đây, đúng không?
But let's stop there and think about how the comparison is done. So we're going to have to read the values of register RS1 and RS2, and that's going to happen inside this register file.
Nhưng hãy dừng ở đây và nghĩ xem phép so sánh được thực hiện như thế nào. Chúng ta sẽ phải đọc giá trị của thanh ghi RS1 và RS2, và việc đó sẽ diễn ra bên trong register file này.
And now we use the branch comparison block to do the actual comparison.
Và bây giờ ta dùng khối so sánh nhánh để thực hiện phép so sánh thực sự.
Now, the result of that actually goes inside the control logic, because control logic is going to decide how to reroute the signals to update the PC with the right one.
Kết quả của nó sẽ đi vào bên trong control logic, vì control logic sẽ quyết định cách định tuyến lại các tín hiệu để cập nhật PC với giá trị đúng.
So that's going to come from here, and now we're going to have to provide that MUX with both ALU and PC plus 4. So ALU, we already have it here.
Tín hiệu đó sẽ đến từ đây, và giờ ta phải cấp cho MUX đó cả ALU lẫn PC cộng 4. ALU thì ta đã có ở đây.
And then PC plus 4, we also already have it here. So it's only a matter of selecting the right MUX signal. That's going to come off from the control logic.
Còn PC cộng 4 thì ta cũng đã có ở đây. Vậy chỉ còn việc chọn đúng tín hiệu cho MUX. Tín hiệu đó sẽ đến từ control logic.
You can see now the delay path is going to get longer, right?
Bạn có thể thấy đường trễ giờ sẽ dài hơn, đúng không?
Because you're going to have to do the read here, and then do the comparison, and travel all the way through the control logic, and then the PC cell, and then we're going to do the selection.
Vì ta phải thực hiện việc đọc ở đây, rồi so sánh, rồi đi suốt qua control logic, rồi tới PC, và sau đó mới thực hiện việc chọn.
And that's going to be pretty much the critical path that we're going to have.
Và đó gần như sẽ là đường tới hạn của chúng ta.
So you can imagine it's a little more challenging operation for the hardware, although we're only going to figure that out if we actually do the physical design.
Vậy bạn có thể hình dung đây là một thao tác khó hơn một chút đối với phần cứng, mặc dù ta chỉ biết được điều đó nếu thực sự làm thiết kế vật lý.
And that's why we have some limitations in really bumping up the clock frequency.
Và đó là lý do ta bị một số giới hạn khi muốn tăng mạnh tần số xung nhịp.
Load word. So load word is actually an I type again. So I type is pretty much used in many different places.
Load word. Load word thực ra lại là kiểu I. Kiểu I được dùng ở khá nhiều nơi khác nhau.
Now we have the RD, because we have to store that value we read from the memory. And RS1 and R immediate.
Giờ ta có RD, vì ta phải lưu giá trị đọc được từ bộ nhớ. Và RS1 cùng immediate.
What happens is we're going to store RD or update RD with the memory value, which is read from RS1 plus immediate, And PC is updated with PC plus 4, because we just want to move on to the next one.
Điều xảy ra là ta sẽ lưu vào RD, hay cập nhật RD, bằng giá trị bộ nhớ được đọc từ địa chỉ RS1 cộng immediate, và PC được cập nhật bằng PC cộng 4, vì ta chỉ muốn chuyển sang lệnh kế tiếp.
So again, let's walk through from the PC, get the instruction. Now this time we're going to need RS1 and immediate and RD.
Vậy ta lại đi từ PC, lấy lệnh. Lần này ta sẽ cần RS1, immediate và RD.
The immediate will flow through here and be ready for addition at the ALU.
Immediate sẽ chạy qua đây và sẵn sàng để cộng tại ALU.
The RS1, the register file will actually read the content of it, and then go through here to do the addition with the immediate.
Còn RS1, register file sẽ đọc nội dung của nó, rồi đi qua đây để cộng với immediate.
So here we have this, which is the actual address we're going to read in from. So now we're going to actually use it in this memory block.
Vậy ở đây ta có kết quả này, chính là địa chỉ thực sự mà ta sẽ đọc dữ liệu từ đó. Giờ ta sẽ dùng nó trong khối bộ nhớ này.
We're going to feed that to the address. Again, this is the address, not the data that we're going to have.
Ta đưa nó vào đầu vào địa chỉ. Một lần nữa, đây là địa chỉ, không phải dữ liệu.
And the memory will do the reading, and then it's going to go through this load extension block, which is, like I said, we're going to either load a byte or a half word or word from the memory.
Bộ nhớ sẽ thực hiện việc đọc, rồi dữ liệu đi qua khối load extension này, như tôi đã nói, ta sẽ nạp một byte, một nửa từ hoặc một từ từ bộ nhớ.
So depending on that, we still have to restore the full four bytes, so we can store that to the register.
Tùy vào đó, ta vẫn phải khôi phục đủ bốn byte, để có thể lưu vào thanh ghi.
So this load extension block is going to do that, the extension, and then it's going to be written back to the RD.
Khối load extension này sẽ làm việc đó, tức là mở rộng, rồi kết quả được ghi ngược lại vào RD.
And then, of course, we're always going to have PC plus 4 working in the back. All right. So it's not really challenging.
Và tất nhiên, lúc nào chúng ta cũng có PC cộng 4 hoạt động ở phía sau. Được rồi. Vậy nên nó thực ra không khó.
It's just about being very finicky about things and trying to think of all the cases, all the signals that are going to be used.
Vấn đề chỉ là phải thật tỉ mỉ và cố nghĩ đến mọi trường hợp, mọi tín hiệu sẽ được sử dụng.
And drawing this on here is not very hard, but if you actually don't get to writing the code, if you just miss one wire from here, nothing's going to work, and it's going to take some time to figure out which one you really missed.
Vẽ cái này ra đây thì không khó lắm, nhưng nếu bạn không thực sự bắt tay viết mã, chỉ cần thiếu một dây ở đây thôi là không có gì chạy được, và sẽ mất một lúc để tìm ra bạn đã thiếu dây nào.
So yeah, it's more about doing than... So again, let's revisit the datapath stages.
Nên đúng vậy, vấn đề là làm nhiều hơn là... Giờ hãy xem lại các giai đoạn của datapath.
Like we said, the datapath has different stages, but now what does that mean in terms of timing and clock frequency?
Như đã nói, datapath có nhiều giai đoạn khác nhau, nhưng điều đó có ý nghĩa gì về thời gian và tần số xung nhịp?
So the most straightforward design is to do everything in a single cycle. So we just give a really big, really long clock period and go through all the five stages.
Thiết kế đơn giản nhất là làm mọi thứ trong một chu kỳ. Tức là ta chỉ cần đặt một chu kỳ xung nhịp thật lớn, thật dài và đi qua cả năm giai đoạn.
And so here, this is going to be the clock period.
Và ở đây, đây sẽ là chu kỳ xung nhịp.
It's pretty long because now that's going to be determined by the critical path that flows all the way through this. Now, all of those stages are combinational circuit right now, right?
Nó khá dài vì giờ nó được quyết định bởi đường tới hạn chạy xuyên suốt qua toàn bộ phần này. Bây giờ, tất cả các giai đoạn đó đều là mạch tổ hợp, đúng không?
Because that's going to happen inside one clock cycle, and that critical path is not very long. So we cannot shrink the clock period past the critical path.
Vì mọi thứ sẽ diễn ra bên trong một chu kỳ xung nhịp, và đường tới hạn đó không hề ngắn. Nên ta không thể rút ngắn chu kỳ xung nhịp hơn đường tới hạn.
We still need to have some things like clock-to-Q delay, setup time violation, hold time violation, and everything. So this design works.
Ta vẫn cần tính đến những thứ như độ trễ clock-to-Q, vi phạm thời gian setup, vi phạm thời gian hold, và các thứ khác. Vậy thiết kế này chạy được.
It's very straightforward, and it's easy to make, but we cannot push the clock frequency very high. Okay.
Nó rất đơn giản và dễ thực hiện, nhưng ta không thể đẩy tần số xung nhịp lên cao. Được rồi.
So the different way of doing this is to break this down into different clock periods.
Vậy cách khác để làm là chia nó thành nhiều chu kỳ xung nhịp.
So we're now going to just do one stage at a time at each clock period, either the instruction fetch or decode. Those things are going to happen.
Giờ mỗi chu kỳ xung nhịp ta chỉ làm một giai đoạn, hoặc là nạp lệnh hoặc là giải mã. Những việc đó sẽ diễn ra.
And now the clock period is going to be determined by the longest critical path among these stages.
Và lúc này chu kỳ xung nhịp sẽ được quyết định bởi đường tới hạn dài nhất trong các giai đoạn này.
So right here we have the instruction fetch, which has the longest critical path, so that's going to determine the overall clock frequency. Critical path.
Ở ngay đây ta có giai đoạn nạp lệnh, giai đoạn có đường tới hạn dài nhất, nên nó sẽ quyết định tần số xung nhịp chung. Đường tới hạn.
And so really the idea is we're going to just do less things in one clock cycle to really bump up the clock frequency.
Và ý tưởng thực sự là ta làm ít việc hơn trong một chu kỳ xung nhịp để nâng tần số xung nhịp lên cao.
And what we get is, in the same period of time, this total time, we've actually worked on four instructions with this design, as opposed to just two instructions in a single cycle.
Và kết quả là, trong cùng một khoảng thời gian, tức tổng thời gian này, với thiết kế này ta đã xử lý được bốn lệnh, so với chỉ hai lệnh khi dùng một chu kỳ.
So it seems like we just achieved, like, twice of a performance increase. Okay. So again, pipeline is just a simple way of cutting down the critical path to really increase the clock frequency.
Có vẻ như ta vừa đạt được hiệu năng tăng gấp đôi. Được rồi. Vậy pipeline chỉ là một cách đơn giản để cắt ngắn đường tới hạn nhằm tăng mạnh tần số xung nhịp.
Okay. Yeah, let me also point out the other facts. So one effect that comes from pipelining is the clock frequency increase.
Okay. Vâng, để tôi nói thêm về những điểm khác. Một hiệu quả của việc dùng đường ống là tăng tần số xung nhịp.
But the other thing is we also increase the hardware utilization.
Nhưng một điều nữa là chúng ta cũng tăng mức sử dụng phần cứng.
Because now that we have pipelined things in one clock period, we're actually using all of the stages in the datapath, right?
Bởi vì giờ đây khi đã chia đường ống, trong một chu kỳ xung nhịp, chúng ta thực sự dùng tất cả các tầng trong datapath, đúng không?
Whereas in the single cycle, at any given point of time, we're only running things in a single stage. So we're now actually making use of more transistors that we put into the silicon area.
Trong khi ở thiết kế đơn chu kỳ, tại bất kỳ thời điểm nào, chúng ta chỉ chạy công việc ở một tầng duy nhất. Vậy là giờ chúng ta thực sự tận dụng nhiều transistor hơn mà chúng ta đã đặt vào diện tích silicon.
So it's a natural thing. You know, we're only getting performance increase because we're doing more things in different areas in the silicon.
Đó là điều tự nhiên thôi. Bạn biết đấy, chúng ta chỉ đạt được hiệu năng tăng thêm vì chúng ta làm nhiều việc hơn ở các vùng khác nhau trên silicon.
But those are the two effects we get from the pipeline. All right. So how do we actually implement the pipeline thing?
Nhưng đó là hai hiệu quả mà chúng ta có được từ đường ống. Được rồi. Vậy thực tế chúng ta hiện thực hóa đường ống như thế nào?
The idea is, again, to cut down those critical paths to small, manageable pieces, right? And that we're going to do by putting in these stage registers. Okay.
Ý tưởng, một lần nữa, là cắt các đường tới hạn thành những phần nhỏ, dễ quản lý, đúng không? Và chúng ta sẽ làm điều đó bằng cách đặt vào các thanh ghi tầng này. Okay.
So whatever comes from the previous stage here, we're going to stage that into this register and just going to hold it for the next clock cycle.
Vậy bất cứ thứ gì đến từ tầng trước ở đây, chúng ta sẽ đưa nó vào thanh ghi này và chỉ giữ nó cho chu kỳ xung nhịp tiếp theo.
And that register is going to have the same value over the next clock cycle. And we're going to use that in the next stage and so on, right?
Và thanh ghi đó sẽ giữ nguyên giá trị trong chu kỳ xung nhịp kế tiếp. Rồi chúng ta dùng nó ở tầng tiếp theo, cứ như vậy, đúng không?
So now what happens is one instruction comes into the stage and then it just flows through it over different clock cycles. Okay.
Vậy giờ điều xảy ra là một lệnh đi vào tầng rồi chạy xuyên qua các tầng qua nhiều chu kỳ xung nhịp khác nhau. Okay.
So now it's actually going to take like five clock cycles to complete one instruction, as opposed to just one clock cycle for the single cycle, right?
Vậy giờ thực sự sẽ mất khoảng năm chu kỳ xung nhịp để hoàn thành một lệnh, thay vì chỉ một chu kỳ xung nhịp như ở đơn chu kỳ, đúng không?
But then again, each of the clock periods is shorter. So maybe we can complete it in a shorter time. Any questions?
Nhưng mỗi chu kỳ xung nhịp lại ngắn hơn. Nên có lẽ chúng ta có thể hoàn thành trong thời gian ngắn hơn. Có câu hỏi nào không?
All right. So let's talk about some of the downsides of doing pipeline design.
Được rồi. Giờ ta nói về một số nhược điểm của thiết kế đường ống.
So one implication of doing pipeline is now each of the instructions, like I said, is going to take more than one cycle, right? All of these are going to take five cycles now.
Một hệ quả của việc dùng đường ống là mỗi lệnh, như tôi đã nói, sẽ mất hơn một chu kỳ, đúng không? Tất cả những lệnh này giờ sẽ mất năm chu kỳ.
So what happens is that when the next instruction enters the pipeline, it may be the case that the previous instruction hasn't completed its execution. Okay.
Vậy điều xảy ra là khi lệnh tiếp theo đi vào đường ống, có thể lệnh trước đó vẫn chưa hoàn thành việc thực thi. Okay.
And that can be a problem when the next instruction is actually reading the value that is being produced from the previous one, because at that point, that instruction may have not completed its execution and written everything back to the register.
Và điều đó có thể là vấn đề khi lệnh tiếp theo đang đọc giá trị được tạo ra từ lệnh trước, vì tại thời điểm đó, lệnh ấy có thể chưa hoàn thành việc thực thi và chưa ghi mọi thứ trở lại thanh ghi.
So let me just remind you of the syntax here, which is, this is going to the destination.
Để tôi nhắc lại cú pháp ở đây, đó là, cái này đi vào đích.
So everything is going to be assigned here and the operation is going to be done with these. You might notice all of these are R-type instructions.
Vậy mọi thứ sẽ được gán ở đây và phép toán sẽ được thực hiện với những toán hạng này. Bạn có thể nhận thấy tất cả đều là lệnh kiểu R.
And here, what we're going to want to look at is those cases where the next instructions are using the value that is being produced by the previous one.
Và ở đây, điều chúng ta muốn xem xét là những trường hợp mà các lệnh tiếp theo đang dùng giá trị đang được lệnh trước đó tạo ra.
Right. Another example is here.
Đúng không. Đây là một ví dụ khác.
So this type of hazards, we're going to call read after write hazards, because literally we're reading a value, same value after write.
Vậy loại hazard này, chúng ta sẽ gọi là hazard đọc sau ghi (read after write), vì theo đúng nghĩa đen là ta đọc một giá trị, chính giá trị đó, sau khi nó được ghi.
So let's just see what actually happens inside the pipeline by just writing things down in this table. Okay. So on the columns, we have different stages. On the rows, we have clock cycles.
Giờ hãy xem thực sự điều gì xảy ra bên trong đường ống bằng cách ghi mọi thứ vào bảng này. Được rồi. Các cột là những giai đoạn khác nhau. Các hàng là các chu kỳ xung nhịp.
And we're going to write things like, okay, at the first cycle, the add instruction hasn't entered the pipeline. Now, the add instruction doesn't have any problems because there's nothing ahead of it.
Và ta sẽ ghi như sau: ở chu kỳ đầu tiên, lệnh add chưa đi vào đường ống. Lệnh add không gặp vấn đề gì vì phía trước nó không có gì cả.
So it's just going to flow through the pipeline without any hiccups.
Nên nó cứ chạy qua đường ống mà không bị trục trặc.
What about subtraction? What's going to happen for the subtraction?
Còn lệnh trừ thì sao? Chuyện gì sẽ xảy ra với lệnh trừ?
There's no hazards for the subtraction, right? Because the sub instruction is reading from the x1 and x2 value, which is not really being modified by the previous one.
Lệnh trừ không có hazard nào, đúng không? Vì lệnh sub đọc giá trị x1 và x2, mà các giá trị này không bị lệnh trước đó thay đổi.
Okay. So it's just going to flow through the pipeline smoothly.
Được rồi. Nên nó cứ chạy trơn tru qua đường ống.
Okay, now the problem is XOR.
Bây giờ vấn đề là lệnh XOR.
Can XOR go to the decode stage at the fourth cycle? No.
XOR có thể vào giai đoạn giải mã ở chu kỳ thứ tư không? Không.
Why not?
Tại sao không?
That's true. But that doesn't mean that the XOR cannot fetch this instruction, right? Because still XOR knows where to fetch its instruction from. It's going to be PC plus four.
Đúng vậy. Nhưng điều đó không có nghĩa là XOR không thể nạp lệnh này, đúng không? Vì XOR vẫn biết cần nạp lệnh của nó từ đâu. Đó là PC cộng bốn.
So actually, you can complete the fetch stage. It's a little tricky, right?
Vậy thực ra bạn có thể hoàn thành giai đoạn nạp lệnh. Hơi khó nhận ra, đúng không?
But when it comes to the decode stage, now the problem happens, like you said before, because the stage that we actually read the register value is at the decode stage.
Nhưng đến giai đoạn giải mã, thì vấn đề xảy ra, như bạn đã nói trước đó, vì giai đoạn mà ta thực sự đọc giá trị thanh ghi là giai đoạn giải mã.
This is where we read register. And that register file is not holding the up-to-date value for x3.
Đây là nơi ta đọc thanh ghi. Và tệp thanh ghi đó chưa giữ giá trị mới nhất của x3.
And that's only going to be updated at the write-back stage of add, because that's where you write things back to the register. So XOR will have to wait until add reaches that stage.
Giá trị đó chỉ được cập nhật ở giai đoạn ghi lại (write-back) của lệnh add, vì đó là lúc bạn ghi mọi thứ trở lại thanh ghi. Vậy XOR sẽ phải đợi cho đến khi add tới giai đoạn đó.
So what happens in this stage?
Vậy ở giai đoạn này chuyện gì xảy ra?
We just insert a bubble, meaning we're going to just insert meaningless control signals that don't write anything to the register file, don't write anything to the memory, so that we don't see any modifications in the state.
Ta chỉ chèn một bubble, nghĩa là ta sẽ chèn vào các tín hiệu điều khiển vô nghĩa, không ghi gì vào tệp thanh ghi, không ghi gì vào bộ nhớ, để ta không thấy bất kỳ thay đổi nào trong trạng thái.
Now, things are still going to happen in those ALUs, because there's a circuit, right? And they're always running. But they're not doing anything useful to the program state.
Dĩ nhiên, mọi thứ vẫn xảy ra trong các ALU đó, vì đó là mạch điện, đúng không? Và chúng luôn hoạt động. Nhưng chúng không làm gì hữu ích cho trạng thái chương trình.
We're going to call that bubbles, or nops. And we're going to just do it with bubbles. And what happens is the pipeline is being stalled at the decode stage, right?
Ta gọi đó là bubble, hay nop. Và ta sẽ chỉ xử lý bằng bubble. Và kết quả là đường ống bị dừng (stall) ở giai đoạn giải mã, đúng không?
The XOR cannot move on to the next one. Now, at the fifth cycle, the add actually updates the x3 value to the newest one.
XOR không thể tiến sang giai đoạn tiếp theo. Đến chu kỳ thứ năm, add thực sự cập nhật giá trị x3 thành giá trị mới nhất.
So XOR can actually read the value in the same cycle and then move on to work with the up-to-date values.
Nên XOR thực sự có thể đọc giá trị ngay trong cùng chu kỳ rồi tiếp tục làm việc với các giá trị đã được cập nhật.
After that, there's no problem. What about OR?
Sau đó thì không còn vấn đề gì. Còn lệnh OR thì sao?
So OR cannot move on to the decode stage simply because the decode stage is not occupied, right?
Lệnh OR đơn giản là không thể chuyển sang tầng giải mã vì tầng giải mã vẫn đang bị chiếm, đúng không?
So OR is actually seeing that kind of latency, although it doesn't have any problems at the fetch stage. But then we cannot move on to the decode stage.
Vậy là OR thực sự chịu độ trễ đó, mặc dù nó không gặp vấn đề gì ở tầng nạp lệnh. Nhưng sau đó ta không thể chuyển nó sang tầng giải mã.
Oh, no, we can move it, right? Because it can complete the instruction fetch without a problem once the decode stage is empty. But it cannot move on to the execution stage, right?
À không, ta chuyển được chứ, đúng không? Vì nó có thể hoàn tất việc nạp lệnh mà không gặp vấn đề khi tầng giải mã đã trống. Nhưng nó không thể chuyển sang tầng thực thi, đúng không?
The reason is it's using the x5 value that is going to be written back at the XOR. And that XOR is going to read things only at the write-back stage.
Lý do là nó dùng giá trị x5 sẽ được ghi lại bởi lệnh XOR. Và lệnh XOR đó chỉ ghi giá trị ở tầng ghi ngược.
So it's going to have to wait two more cycles. And so there's going to be two bubbles being inserted into the pipeline.
Vì vậy nó sẽ phải chờ thêm hai chu kỳ nữa. Và như vậy sẽ có hai bong bóng được chèn vào đường ống.
And all those bubbles are going to just follow through the pipeline because they don't have any hazards. They're just meaningless signals. And after that, now all hazards are cleared.
Và tất cả các bong bóng đó sẽ cứ chạy xuyên qua đường ống vì chúng không có hazard nào. Chúng chỉ là các tín hiệu vô nghĩa. Và sau đó, mọi hazard đã được giải quyết.
So OR will follow through as well. So actually, now if you look at the total number of cycles that took this program to run, it's 11 cycles, right?
Nên lệnh OR cũng sẽ chạy tiếp qua. Vậy nếu giờ ta nhìn vào tổng số chu kỳ mà chương trình này cần để chạy, thì là 11 chu kỳ, đúng không?
So although the pipelining gives us a nice benefit of clock frequency increase, that also gives us a problem with clock efficiency.
Vậy nên dù pipelining mang lại lợi ích tốt là tăng tần số xung nhịp, nó cũng gây ra vấn đề về hiệu quả xung nhịp.
So we're going to use a metric for this, which is called clock per instruction.
Vì thế ta sẽ dùng một thước đo cho việc này, gọi là clock per instruction.
We're cycles per instruction. What we want is one CPI, right?
Tức là số chu kỳ trên mỗi lệnh (cycles per instruction). Điều ta muốn là CPI bằng một, đúng không?
Because we want to have each instruction go through the pipelines without any cycle bubbles. But we cannot really reach one CPI because there's going to be bubbles inserted in the pipeline.
Vì ta muốn mỗi lệnh đi qua đường ống mà không có bong bóng chu kỳ nào. Nhưng ta thực sự không thể đạt CPI bằng một vì sẽ có các bong bóng được chèn vào đường ống.
So that's going to go down, go less than one. So the goal is, it's not less than one, right? More than one.
Nên giá trị đó sẽ giảm xuống, thấp hơn một. Mục tiêu là, không phải nhỏ hơn một, đúng không? Mà lớn hơn một.
The goal is we want to bring that CPI value as down as possible by doing tricks on the pipeline, which you're going to learn in the later lectures.
Mục tiêu là ta muốn đưa giá trị CPI đó xuống càng thấp càng tốt bằng cách dùng các mẹo trên đường ống, mà bạn sẽ được học trong các bài giảng sau.
So this is just the solution for the table. And the hazard we looked at is called data hazard, and it's only one type of the hazards that can occur.
Đây chỉ là lời giải cho bảng. Và loại hazard ta vừa xem được gọi là data hazard, và nó chỉ là một trong các loại hazard có thể xảy ra.
Data hazard is when one or more source registries stop up to date because it's being produced by the previous instruction. Solution for that is going to be forwarding.
Data hazard xảy ra khi một hoặc nhiều thanh ghi nguồn không còn được cập nhật vì nó đang được tạo ra bởi lệnh trước đó. Giải pháp cho việc đó là forwarding.
So actually, all of these problems can be solved nicely by adding just a bunch of more wires in the datapath, which you will learn in the later lectures.
Thực ra, tất cả những vấn đề này có thể được giải quyết gọn gàng chỉ bằng cách thêm một số đường dây vào datapath, mà bạn sẽ học trong các bài giảng sau.
Another type of hazard is structural hazard. It literally means there's not enough hardware to do the work. And that's going to be a problem for things like parallel hardware.
Một loại hazard khác là structural hazard. Nghĩa đen là không đủ phần cứng để thực hiện công việc. Và đó sẽ là vấn đề với những thứ như phần cứng song song.
So say we have, like, parallel threads, and threads that are running at the same time in the software, but in the hardware, say you only have small n ALUs, which is smaller than that.
Giả sử ta có các luồng song song, tức các luồng chạy cùng lúc trong phần mềm, nhưng trong phần cứng, giả sử bạn chỉ có n ALU nhỏ hơn số đó.
So we can only process small n instructions per time, but we have, like, large n threads. That means some of those threads will have to wait some cycles to become its own turn, right?
Vì vậy mỗi lần ta chỉ xử lý được n lệnh, nhưng lại có N luồng, với N lớn hơn. Điều đó có nghĩa là một số luồng sẽ phải chờ vài chu kỳ để đến lượt của mình, đúng không?
So that's going to be the structural hazard. The solution is obvious: to add more hardware, and that's going to add more cores and also add to the cost.
Đó chính là xung đột cấu trúc. Giải pháp thì rõ ràng: thêm phần cứng, và điều đó sẽ thêm nhiều lõi hơn, đồng thời làm tăng chi phí.
That's why those beefy hardwares are more costly. Now, the more kind of tricky hazard is the control hazard. So this comes from branches.
Đó là lý do những phần cứng mạnh như vậy đắt hơn. Còn loại xung đột khó hơn là xung đột điều khiển. Nó xuất phát từ các lệnh rẽ nhánh.
And the problem with branches is we don't really know early enough whether it is taken or not. So what happens is, again, we have stages like fetch, decode, execute, memory, and write back.
Vấn đề với rẽ nhánh là ta không thực sự biết đủ sớm liệu nhánh có được thực hiện hay không. Cụ thể, một lần nữa ta có các giai đoạn như fetch, decode, execute, memory và write back.
But the thing about branches is the branch comparison is only done at execute stage, right?
Nhưng với rẽ nhánh, phép so sánh của nhánh chỉ được thực hiện ở giai đoạn execute, đúng không?
But depending on that, we're going to decide if the next instruction is going to come from PC plus 4 or PC plus immediate.
Tuy nhiên, dựa vào kết quả đó, ta sẽ quyết định lệnh tiếp theo đến từ PC cộng 4 hay PC cộng immediate.
So if we have the same table here, only when the BEQ instruction reaches the execute stage, then we are going to be able to fetch the right next instruction.
Vậy nếu ta có cùng bảng này ở đây, chỉ khi lệnh BEQ đến giai đoạn execute, ta mới có thể fetch đúng lệnh tiếp theo.
Then we're going to know the address that that instruction lives.
Lúc đó ta mới biết địa chỉ nơi lệnh ấy nằm.
And again, there's going to be bubbles inserted between those stages. So what's going to be the solution for this?
Và một lần nữa, sẽ có các bong bóng được chèn vào giữa các giai đoạn. Vậy giải pháp cho việc này là gì?
There's no real solution because it comes from the fundamental fact that fetch and comparison is happening at a different timing. So the only way to do it is to take a best guess.
Thật ra không có giải pháp trọn vẹn, vì nó xuất phát từ thực tế cơ bản là việc fetch và việc so sánh xảy ra ở những thời điểm khác nhau. Nên cách duy nhất là đoán tốt nhất có thể.
So we're going to actually just predict if this branch is going to be taken or not by looking at the program, looking at the history of the program's behavior.
Tức là ta sẽ dự đoán xem nhánh này có được thực hiện hay không bằng cách nhìn vào chương trình, xem lịch sử hành vi của chương trình.
And that's going to be where pretty much dark magic is involved to predict the branch's will. And also that's going to be covered in the later lecture slides.
Và đó là chỗ mà gần như có cả “ma thuật đen” tham gia để đoán ý của nhánh. Phần đó cũng sẽ được đề cập trong các slide bài giảng sau.
And you may also get to the point in your course project where you can build a branch predictor and put it in and get some scores for that.
Và có thể bạn cũng sẽ đến giai đoạn trong đồ án môn học mà bạn xây dựng một bộ dự đoán rẽ nhánh rồi đưa vào và nhận điểm cho phần đó.
So, yeah, that's it for today's discussion. Are there any other questions?
Vâng, buổi thảo luận hôm nay đến đây là hết. Còn câu hỏi nào khác không?
In the general design of a pipeline process, or implementation of Cloud ISA, would it always be better to construct a single cycle structure and then change that to a pipeline structure?
Trong thiết kế tổng quát của một quy trình đường ống, hay khi hiện thực ISA của Cloud, liệu có phải lúc nào cũng tốt hơn nếu xây dựng cấu trúc một chu kỳ trước rồi sau đó chuyển nó thành cấu trúc đường ống không?
Is that always a good idea? That's a good question, yeah. Taking everything from RISC-V to the general thought cycle. Yeah.
Đó có luôn là ý hay không? Câu hỏi hay đấy. Lấy mọi thứ từ RISC-V sang tư duy chu kỳ đơn tổng quát. Vâng.
So you're talking about pretty much what's the easier way to do that in the course project, right? So that's a very tricky question.
Vậy bạn đang hỏi về cách dễ hơn để làm việc đó trong đồ án môn học, đúng không? Đó là một câu hỏi rất khó.
So if you start with a single cycle, you're going to get the datapath right from the beginning. You're going to get all the wires right.
Nếu bạn bắt đầu với thiết kế một chu kỳ, thì ngay từ đầu bạn sẽ có được datapath đúng. Bạn sẽ nối đúng tất cả các dây.
But then it gets tricky to put the registers there. Because if you just put registers partially, then you're not going to get the signal that you like timing.
Nhưng sau đó việc đặt các thanh ghi vào sẽ trở nên khó khăn. Bởi vì nếu bạn chỉ đặt thanh ghi một phần, thì bạn sẽ không có được tín hiệu đúng về mặt định thời như mình muốn.
Some of the signals are going to be this instruction, whereas some of the others are for the pass instruction. So those signals are going to be mixed, coming from different instructions.
Một số tín hiệu sẽ thuộc về lệnh này, trong khi những tín hiệu khác thuộc về lệnh trước đó. Vì vậy các tín hiệu đó sẽ bị trộn lẫn, đến từ những lệnh khác nhau.
And that's going to be very tricky for debugging. And the thing I did when I took the course was I just started with the pipeline design, and I just built the instruction fetch first.
Và điều đó sẽ rất khó cho việc gỡ lỗi. Còn điều mình đã làm khi học môn này là mình bắt đầu ngay với thiết kế đường ống, và mình xây dựng phần instruction fetch trước.
Because instruction fetch, what it does is just fetches the instruction, and you can test it by itself. And then do the decoding, which you can also test by itself.
Vì instruction fetch chỉ làm việc lấy lệnh, và bạn có thể kiểm tra riêng nó. Sau đó làm phần giải mã, phần này cũng có thể kiểm tra riêng.
So I wouldn't say that's necessarily a better design, because still you have to, you're pushing the work of getting the wires to the end, if you're starting with the pipeline design, if you're building one stage pipeline at one set.
Nên mình sẽ không nói đó nhất thiết là thiết kế tốt hơn, vì bạn vẫn phải, bạn chỉ đẩy việc nối dây xuống cuối cùng, nếu bạn bắt đầu với thiết kế đường ống, nếu bạn xây từng tầng của đường ống một lần.
But yeah, I think in my mind, starting with pipeline would be easier.
Nhưng theo mình, bắt đầu với đường ống sẽ dễ hơn.
Any other questions? Yeah. So, hello. Go ahead.
Còn câu hỏi nào khác không? Vâng, xin chào. Bạn cứ hỏi.
So while implementing this hazard solution, so how do we get to know, like we have to stall for like three cycles, four cycles, that can be like dependent on how we are going to instruction.
Khi triển khai giải pháp xử lý hazard này, làm sao biết được là phải stall ba chu kỳ, hay bốn chu kỳ, vì điều đó có thể phụ thuộc vào các lệnh mình đưa vào.
So let's say we give add first in this example, and after that we give XOR, which is kind of dependent on that. Then we have to stall for more cycles.
Ví dụ trong ví dụ này ta đưa lệnh add trước, rồi sau đó đưa lệnh XOR phụ thuộc vào lệnh add đó. Thì ta phải stall thêm nhiều chu kỳ hơn.
So like, depending on the program complexity, we have to provide those stalls, and the number can be varied, but hardware is kind of fixed.
Như vậy, tùy theo độ phức tạp của chương trình, ta phải chèn các stall đó, và số lượng có thể thay đổi, nhưng phần cứng thì cố định.
So how do we deal with this situation? That's a good question. So you're talking about how hardware actually know how many bubbles to insert, right?
Vậy ta xử lý tình huống này thế nào? Câu hỏi hay. Bạn đang hỏi làm sao phần cứng thực sự biết cần chèn bao nhiêu bubble, đúng không?
Yeah. So that is actually going to be done all by hardware inside the control logic. So this giant block here, control logic, is actually going to read the instructions.
Vâng. Việc đó hoàn toàn do phần cứng thực hiện bên trong control logic. Khối lớn này, control logic, sẽ đọc các lệnh.
But now if you pipeline things, still we have this control. Oh wait, I'm changing the screen on the laptop.
Nhưng giờ nếu ta chia đường ống, ta vẫn có khối điều khiển này. À khoan, mình đang đổi màn hình trên laptop.
So here we still have the control logic, right? Yeah. And that control logic is actually seeing all the instructions for these five stages, right?
Vậy ở đây ta vẫn có control logic, đúng không? Vâng. Và control logic đó nhìn thấy tất cả các lệnh trong năm tầng này, đúng không?
You can actually see through all the five instructions, and you can decode all those five instructions to see if there's any interdependency between them. Okay.
Nó có thể nhìn xuyên suốt cả năm lệnh, và giải mã cả năm lệnh đó để xem giữa chúng có sự phụ thuộc lẫn nhau nào không. Được chứ.
Depending on that, it's going to decide things like, okay, you're going to stall here, or how many cycles and all that. So, yeah. Okay, thank you. Good question. Any other questions?
Dựa vào đó, nó sẽ quyết định những việc như, được, bạn sẽ stall ở đây, hoặc stall bao nhiêu chu kỳ, v.v. Vâng. Cảm ơn bạn. Câu hỏi hay. Còn câu hỏi nào khác không?
Okay, so that's it for this week. Have a nice weekend and see you all in the next week.
Được rồi, vậy là hết nội dung của tuần này. Chúc các bạn cuối tuần vui vẻ và hẹn gặp lại các bạn vào tuần sau.
Đăng nhập để đánh giá học liệu này.
Đăng nhập để bình luận — chưa ai bình luận về học liệu này.
Không có khóa học liên quan.