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ả.
Okay, well, good morning, everyone. Great to see you again. Welcome to EE151/251A, Introduction to Digital Logic and Integrated Circuits.
Chào buổi sáng cả lớp. Rất vui được gặp lại các bạn. Chào mừng các bạn đến với EE151/251A, Nhập môn Logic số và Mạch tích hợp.
After enough of Verilog and finite state machines, we are going to actually transition a little bit, really talking about how we actually specify a complex system.
Sau khi đã học khá đủ về Verilog và máy trạng thái hữu hạn, chúng ta sẽ chuyển hướng một chút, để nói về cách chúng ta đặc tả một hệ thống phức tạp.
In particular, we're actually going to talk about how we actually describe different functionalities and specifically different instructions in RISC-V.
Cụ thể, chúng ta sẽ nói về cách mô tả các chức năng khác nhau, và đặc biệt là các lệnh khác nhau trong RISC-V.
We do the RISC-V review early because this will basically be the spec or be the hardware platform that you will be designing during your final project, right?
Chúng ta ôn lại RISC-V sớm vì đây sẽ là bản đặc tả hay nói cách khác là nền tảng phần cứng mà các bạn sẽ thiết kế trong đồ án cuối kỳ, đúng không?
So we want to get the discussion early so that you are prepared.
Vì vậy chúng ta muốn thảo luận sớm để các bạn có sự chuẩn bị.
We'll also have a couple of homeworks to get you a little bit more familiar with the different aspects of the ISA so that you are ready for the final project.
Chúng ta cũng sẽ có vài bài tập về nhà để các bạn quen hơn với các khía cạnh khác nhau của ISA, để sẵn sàng cho đồ án cuối kỳ.
For exchange students, graduate students, if you haven't seen RISC-V before, it's okay.
Với các bạn sinh viên trao đổi, sinh viên cao học, nếu chưa từng học RISC-V thì cũng không sao.
We'll actually use this this week to actually go through different components of the RISC-V ISA and datapath.
Chúng ta sẽ dùng tuần này để đi qua các thành phần khác nhau của ISA RISC-V và datapath.
It is a little bit crammed in some sense because we basically pack everything in these two lectures.
Theo một nghĩa nào đó thì hơi dồn dập vì chúng ta nén toàn bộ nội dung vào hai bài giảng này.
If you want to know more or you're interested in knowing more details, always go to the RISC-V spec, right? The ISA spec that basically has the most detailed knowledge.
Nếu các bạn muốn biết thêm hoặc quan tâm đến chi tiết hơn, hãy luôn xem bản đặc tả RISC-V, nhé. Bản đặc tả ISA là nơi có kiến thức chi tiết nhất.
And also 61C has a good set of resources, so feel free to check it out. For students who have taken 61C before, this will be more like a review course.
Ngoài ra 61C cũng có một bộ tài liệu tốt, các bạn cứ tham khảo. Với các bạn đã học 61C, phần này sẽ giống một buổi ôn tập hơn.
But even for whenever I interact with students who have 61C experience, whenever they go through this week, it's of course an opportunity to remind themselves of different topics that we have covered, but also another opportunity to see actually why this is designed this way and different aspects of the ISA.
Nhưng ngay cả khi tôi trao đổi với các bạn đã có kinh nghiệm 61C, mỗi khi các bạn học qua tuần này, tất nhiên đây là cơ hội để tự nhắc lại các chủ đề mà chúng ta đã học, nhưng cũng là cơ hội khác để thấy vì sao nó được thiết kế như vậy và các khía cạnh khác nhau của ISA.
So this is still a fun journey. So before we start talking about all the different specific instructions, some exciting news about RISC-V.
Vì vậy đây vẫn là một hành trình thú vị. Trước khi bắt đầu nói về từng lệnh cụ thể, có một tin thú vị về RISC-V.
Recently, NASA actually collaborated with SiFive, basically a RISC-V company that most of the founders actually started here at Berkeley, in actually building a high-performance vector processor for the future NASA missions.
Gần đây, NASA đã hợp tác với SiFive, một công ty về RISC-V mà hầu hết những người sáng lập đã bắt đầu tại Berkeley này, để xây dựng một bộ xử lý vectơ hiệu năng cao cho các sứ mệnh tương lai của NASA.
So in the future, the RISC-V machines, the ISA is actually a little bit different from the one we're designing, but they'll share a lot of instructions.
Vì vậy trong tương lai, các máy RISC-V, ISA này hơi khác với ISA mà chúng ta đang thiết kế, nhưng chúng sẽ có chung rất nhiều lệnh.
It also has an extended vector engine, which is actually very good for signal processing and also machine learning.
Nó cũng có một bộ máy vectơ mở rộng, rất phù hợp cho xử lý tín hiệu và cả học máy.
Those are actually growing importance, very important algorithms that also will be used in NASA's space missions.
Đây là những thuật toán ngày càng quan trọng, rất quan trọng và cũng sẽ được dùng trong các sứ mệnh không gian của NASA.
So this is pretty significant because this is basically the major update in NASA's computing processor, computing platform in almost two or three decades.
Điều này khá có ý nghĩa vì về cơ bản đây là bản cập nhật lớn của bộ xử lý tính toán của NASA, nền tảng tính toán, sau gần hai hoặc ba thập kỷ.
The processors actually in most of the NASA's missions actually haven't changed a lot in the past three decades. Any guesses which ISA has been used in NASA's computing platform?
Các bộ xử lý trong hầu hết các thực ra đã không thay đổi nhiều trong ba thập kỷ qua. Các em đoán xem NASA đã dùng ISA nào trong nền tảng tính toán của họ?
Which ISA? Well, the new one, they are replacing the old one with RISC-V, right? So presumably it was not RISC-V, and it was also started using 20, 30 years ago, right?
ISA nào? À, cái mới thì họ đang thay cái cũ bằng RISC-V, đúng không? Vậy chắc chắn trước đây nó không phải RISC-V, và nó cũng đã bắt đầu được dùng từ 20, 30 năm trước, đúng không?
So RISC-V is pretty recent. Omer, is that x86?
RISC-V thì khá mới. Omer, có phải x86 không?
Well, as you say, x86 is a good guess, but they were actually not using x86. Good for them. Yeah, what others?
Như em nói, x86 là một dự đoán hợp lý, nhưng thực ra họ không dùng x86. May cho họ. Vâng, còn ai đoán gì nữa không?
Mips, getting closer, something more commercial.
Mips, gần đúng hơn rồi, một thứ mang tính thương mại hơn.
Also getting closer in the sense it's RISC-based, but actually started from a U.S. company, a more than 100-year-old U.S. company. PowerPC, yes.
Cũng gần đúng ở chỗ nó dựa trên RISC, nhưng thực ra bắt nguồn từ một công ty của Mỹ, một công ty Mỹ hơn 100 năm tuổi. PowerPC, đúng rồi.
So they are actually using IBM's PowerPC. So that basically has been the ISA they have been using in the past two or three decades, right? So this is actually interesting, interesting updates.
Vậy là họ thực sự đang dùng PowerPC của IBM. Đó về cơ bản là ISA mà họ đã sử dụng trong hai ba thập kỷ qua, đúng không? Vậy đây là một cập nhật khá thú vị.
They are interested in using not only the SiFive processor, but also the entire RISC-V ecosystem, right?
Họ quan tâm đến việc dùng không chỉ bộ xử lý SiFive, mà còn cả toàn bộ hệ sinh thái RISC-V, đúng không?
So we'll be seeing interesting trends moving forward and to see what kind of processors running not actually on Earth, but also in space.
Vì vậy chúng ta sẽ thấy những xu hướng thú vị trong thời gian tới và xem những loại bộ xử lý nào sẽ chạy không chỉ trên Trái Đất, mà còn trong không gian.
So some interesting developments on the RISC-V side, but PowerPC is also a very powerful ISA, very interesting platform.
Vậy là có một số diễn biến thú vị về phía RISC-V, nhưng PowerPC cũng là một ISA rất mạnh, một nền tảng rất thú vị.
IBM also has done a lot of very important processors, a lot of major architectural innovations, especially out-of-order execution were actually first invented by IBM very early in the 60s and 70s, right?
IBM cũng đã làm ra rất nhiều bộ xử lý quan trọng, nhiều đổi mới lớn về kiến trúc, đặc biệt là thực thi không theo thứ tự (out-of-order execution) lần đầu được phát minh bởi IBM từ rất sớm, vào những năm 60 và 70, đúng không?
So a lot of excitement. If you have already taken or interested in taking 152A, next semester we'll talk a lot about the out-of-order core design execution.
Vậy là có rất nhiều điều thú vị. Nếu các em đã học hoặc muốn học 152A, học kỳ sau chúng ta sẽ nói nhiều về thiết kế lõi thực thi không theo thứ tự.
A lot of innovation was actually from IBM, which is also a very major semiconductor company. Oh, a couple of folks, Jake and Mohamed, yes, IBM PowerPC, yes.
Rất nhiều đổi mới thực ra đến từ IBM, cũng là một công ty bán dẫn rất lớn. Ồ, có vài bạn, Jake và Mohamed, vâng, IBM PowerPC, đúng rồi.
Okay, so in today's lecture, just a quick review. Topics we covered: we review the state machine, right?
Được rồi, trong bài giảng hôm nay, trước hết ôn lại nhanh. Các chủ đề đã học: chúng ta ôn lại máy trạng thái, đúng không?
We specify the functionality, draw the state transition diagram, specify our encoding and express the functionalities for both output logic and next state using the Boolean expression, right?
Chúng ta đặc tả chức năng, vẽ sơ đồ chuyển trạng thái, xác định cách mã hóa và biểu diễn chức năng cho cả logic đầu ra lẫn trạng thái kế tiếp bằng biểu thức Boolean, đúng không?
And then we can actually write in Verilog to describe the behavior, right? Eventually we want to implement the design. We started a little bit of discussion on RISC-V.
Rồi chúng ta có thể viết bằng Verilog để mô tả hành vi, đúng không? Cuối cùng chúng ta muốn hiện thực thiết kế đó. Chúng ta đã bắt đầu thảo luận đôi chút về RISC-V.
We can basically view RISC-V as the big state machine, right? We are doing some updates to modify either the PC counter or the register states or the memory state.
Về cơ bản có thể xem RISC-V như một máy trạng thái lớn, đúng không? Chúng ta thực hiện một số cập nhật để thay đổi bộ đếm chương trình PC hoặc trạng thái thanh ghi hoặc trạng thái bộ nhớ.
If we think about RISC-V or any microprocessor execution at a very high level, right, to give us like a vocabulary or a set of terminology to use to describe different operations, we categorize the instruction execution into those five phases, right?
Nếu nghĩ về RISC-V hay bất kỳ quá trình thực thi của vi xử lý nào ở mức rất cao, đúng không, để có một vốn từ hay một bộ thuật ngữ dùng mô tả các thao tác khác nhau, chúng ta phân loại việc thực thi lệnh thành năm giai đoạn này, đúng không?
Five stages: instruction fetch, fetching the instructions, decoding the instructions, execute the instruction, doing the memory accesses, and then finally doing the register write-back.
Năm giai đoạn: nạp lệnh (instruction fetch), tức là lấy các lệnh về, giải mã lệnh, thực thi lệnh, truy cập bộ nhớ, và cuối cùng là ghi ngược vào thanh ghi.
We talked a lot about different components in the processor pipeline like muxes, ALUs, and registers in last lecture. One thing we didn't get to is memory.
Trong bài giảng trước, chúng ta đã nói nhiều về các thành phần của đường ống bộ xử lý như mux, ALU và các thanh ghi. Một thứ chúng ta chưa đề cập là bộ nhớ.
Memory is also a very important state element in our datapaths, right?
Bộ nhớ cũng là một phần tử trạng thái rất quan trọng trong datapath của chúng ta, đúng không?
When we think about memory design, we basically want to both be able to read data from memory so that we can get data out of memory, and also write data to memory, right?
Khi nghĩ về thiết kế bộ nhớ, về cơ bản chúng ta muốn vừa có thể đọc dữ liệu từ bộ nhớ để lấy dữ liệu ra khỏi bộ nhớ, vừa có thể ghi dữ liệu vào bộ nhớ, đúng không?
So that we can update memory. Similar to register, right? We introduced the concept of write-enable, right?
Để chúng ta có thể cập nhật bộ nhớ. Tương tự như thanh ghi, đúng không? Chúng ta đã giới thiệu khái niệm write-enable, đúng không?
We only do the write once the clock ticks, and if the write-enable is set or is high, we actually perform the write operation, right?
Chúng ta chỉ ghi khi xung clock kích, và nếu write-enable được đặt hoặc ở mức cao, thì chúng ta mới thực hiện thao tác ghi, đúng không?
So similar to read to register, we have addresses and data. We'll say that in, and then getting data out.
Vậy tương tự như đọc thanh ghi, chúng ta có địa chỉ và dữ liệu. Ta sẽ đưa dữ liệu vào, rồi lấy dữ liệu ra.
Instead of a fixed 32 number of registers, especially in RISC-V, 5, I say here the address can actually be much larger, right?
Thay vì số thanh ghi cố định là 32, đặc biệt trong RISC-V là 5 bit địa chỉ, ở đây địa chỉ thực ra có thể lớn hơn nhiều, đúng không?
But depends on the memory capacity, we can send address in to read at different parts of the address.
Nhưng tùy vào dung lượng bộ nhớ, chúng ta có thể đưa địa chỉ vào để đọc ở các vị trí khác nhau.
One thing in particular in this class discussion, we want to highlight: there's the relationship with read and write, the relationship between clock and the read-write operation.
Có một điều cụ thể trong phần thảo luận của lớp này mà chúng ta muốn nhấn mạnh: đó là mối quan hệ giữa đọc và ghi, mối quan hệ giữa xung clock và thao tác đọc-ghi.
Generally in this class, unless actually explicitly specified, clock only affects write operation. Basically during read, we assume a fully combinational path, right?
Nói chung trong lớp này, trừ khi được nêu rõ ràng, clock chỉ ảnh hưởng đến thao tác ghi. Về cơ bản khi đọc, chúng ta giả sử đường đi hoàn toàn tổ hợp, đúng không?
We have address and then we get data out directly. Sometimes you also, people here, here people say actually read operation is asynchronous, right? Because it's not synchronous with clocks, fully combinational, right?
Có địa chỉ thì chúng ta lấy dữ liệu ra trực tiếp. Đôi khi bạn cũng sẽ nghe, người ta nói thao tác đọc là bất đồng bộ, đúng không? Vì nó không đồng bộ với clock, hoàn toàn tổ hợp, đúng không?
When we say something is asynchronous, it's not synchronous with clocks, which is true for most of the discussion in this class, where read operation, we get the address, then combinationally we get the data out.
Khi nói điều gì đó là bất đồng bộ, nghĩa là nó không đồng bộ với clock, điều này đúng với hầu hết nội dung trong lớp này, ở đó với thao tác đọc, chúng ta nhận địa chỉ, rồi lấy dữ liệu ra một cách tổ hợp.
But data, but for write, it is actually synchronous. So write is actually associated with clock, right?
Nhưng còn với thao tác ghi, nó thực sự là đồng bộ. Tức là thao tác ghi gắn với clock, đúng không?
We only perform write when clock ticks, and then we check the write enable, and then we'll perform write operation. This makes the discussion, especially with our processor pipeline, a little bit easier.
Chúng ta chỉ ghi khi xung clock kích, rồi kiểm tra write enable, sau đó mới thực hiện thao tác ghi. Điều này khiến việc thảo luận, đặc biệt với đường ống bộ xử lý của chúng ta, dễ hơn một chút.
But again, different designs are different, we always need to specify our context, right?
Nhưng một lần nữa, các thiết kế khác nhau thì khác nhau, nên chúng ta luôn cần nêu rõ ngữ cảnh, đúng không?
So here, asynchronous read, Synchronous write is basically the majority of the designs that we use in this class, but that's not always true, right? Especially with more complex designs.
Vậy ở đây, đọc bất đồng bộ, ghi đồng bộ về cơ bản là phần lớn các thiết kế mà chúng ta dùng trong lớp này, nhưng không phải lúc nào cũng vậy, đúng không? Đặc biệt với các thiết kế phức tạp hơn.
In some cases, both read and write are actually synchronous because the critical paths could be too long if everything, if the read is actually asynchronous, right?
Trong một số trường hợp, cả đọc và ghi đều đồng bộ vì các đường tới hạn có thể quá dài nếu mọi thứ, nếu việc đọc thực sự là bất đồng bộ, đúng không?
But for this discussion, for this class, most of the time we'll assume asynchronous read and synchronous write.
Nhưng với phần thảo luận này, với môn học này, phần lớn thời gian ta sẽ giả định đọc bất đồng bộ và ghi đồng bộ.
We'll talk about how we actually build real memory, how SRAM is actually designed using a combination of different transistors later this semester.
Ta sẽ nói về cách xây dựng bộ nhớ thực tế, cách SRAM thực sự được thiết kế bằng sự kết hợp của nhiều loại transistor khác nhau, vào cuối học kỳ này.
We'll actually see, go into the SRAM to see how it is actually designed.
Ta sẽ đi sâu vào SRAM để xem nó thực sự được thiết kế như thế nào.
But at the very high level, we're basically address in, data out for read operation, address in, data in, and the clock and write enable for synchronous write operation for memory write.
Nhưng ở mức rất tổng quát, về cơ bản ta có địa chỉ vào, dữ liệu ra cho thao tác đọc, và địa chỉ vào, dữ liệu vào, cùng với xung clock và tín hiệu write enable cho thao tác ghi đồng bộ, tức là ghi bộ nhớ.
So that's the last element of the datapaths. We talk about muxes, we'll see muxes a lot when we go through the datapaths, ALUs, registers, and the memory.
Đó là thành phần cuối cùng của các datapath. Ta đã nói về các mux, và sẽ gặp mux rất nhiều khi xem xét các datapath, ALU, thanh ghi và bộ nhớ.
So after seeing all the different elements, next we're actually going to see how we actually assemble those different elements to execute all the instructions.
Vậy sau khi đã xem tất cả các thành phần khác nhau, tiếp theo ta sẽ xem cách ghép các thành phần đó lại để thực thi tất cả các lệnh.
So we have a list of all the instructions here. We, I think we'll probably just finish half of the instructions this class and we'll do the other half next class.
Ở đây có danh sách tất cả các lệnh. Tôi nghĩ buổi này ta có lẽ chỉ làm xong một nửa số lệnh và nửa còn lại sẽ làm ở buổi sau.
Again, we will actually review this pretty quickly, just more like a refresher, but always refer to the ISA manual, the ISA specs that has all the information.
Một lần nữa, ta sẽ xem lại khá nhanh, chỉ như ôn lại, nhưng hãy luôn tham khảo sách hướng dẫn ISA, tức đặc tả ISA có đầy đủ thông tin.
So when we talk about instructions, we want to basically think about instruction format. You will see this format being used a lot consistently in this class.
Khi nói về các lệnh, về cơ bản ta cần nghĩ đến định dạng lệnh. Bạn sẽ thấy định dạng này được dùng rất nhất quán trong môn học.
We're basically describing the layout of the 32-bit instructions. RISC-V is a 32-bit instruction ISA.
Nó mô tả cách bố trí của các lệnh 32 bit. RISC-V là một ISA có lệnh 32 bit.
The data can be different, 16-bit data, like 32-bit data, and like even byte. Every byte, we'll talk about bytes, accessing each individual byte later, or even 64-bit data.
Dữ liệu có thể khác nhau: dữ liệu 16 bit, 32 bit, thậm chí là byte. Mỗi byte, ta sẽ nói về việc truy cập từng byte riêng lẻ sau, hoặc thậm chí dữ liệu 64 bit.
But instruction is always a 32-bit instruction. So we'll use this format, The top of the row basically describing each individual bit position.
Nhưng lệnh thì luôn là lệnh 32 bit. Vì vậy ta sẽ dùng định dạng này, Hàng trên cùng mô tả vị trí của từng bit.
The bottom of the format will basically be talking about the number of bits in each field, and in each of the cell, in each of the entry, we'll talk about what is the functionality, what it's actually trying to indicate for each of the fields.
Hàng dưới cùng của định dạng cho biết số bit của mỗi trường, và trong mỗi ô, mỗi mục, ta nói về chức năng, tức là mỗi trường đang muốn chỉ ra điều gì.
So basically, generally divide a 32-bit instruction word into different subfields for different functionalities.
Về cơ bản, một từ lệnh 32 bit thường được chia thành các trường con khác nhau cho các chức năng khác nhau.
One of the most common ones, and also a very consistent one, is the last seven bits will always be used to describe the opcode, which specifies the functionality.
Một trong những trường phổ biến nhất, và cũng rất nhất quán, là bảy bit cuối luôn dùng để mô tả opcode, quy định chức năng của lệnh.
And we also have, we'll see those a lot, a register, source register, two source registers, the RS1 and RS2, and whenever we see an R, it's a register, and destination register, RD, to describe registers.
Ta cũng có, và sẽ gặp chúng nhiều, các thanh ghi, thanh ghi nguồn, hai thanh ghi nguồn RS1 và RS2, và mỗi khi thấy chữ R thì đó là thanh ghi, và thanh ghi đích RD, để mô tả các thanh ghi.
So with this format, we'll first start from R-type instruction. This is basically the most basic, the most standard instructions in RISC-V. The format is very standard, very clear.
Với định dạng này, đầu tiên ta sẽ bắt đầu từ lệnh kiểu R. Đây về cơ bản là các lệnh cơ bản nhất, chuẩn nhất trong RISC-V. Định dạng này rất chuẩn, rất rõ ràng.
It basically has all the different subfields. We have opcode to describe the functionality, what this instruction is trying to do. We'll see a couple examples later.
Về cơ bản nó có đầy đủ các trường con khác nhau. Chúng ta có opcode để mô tả chức năng, tức là lệnh này muốn làm gì. Lát nữa chúng ta sẽ xem một vài ví dụ.
For R-type instruction, all the operations are basically operating on registers, which means that we have two full source registers, RS1 and RS2, and one destination register, RD.
Với lệnh kiểu R, tất cả các phép toán về cơ bản đều thực hiện trên các thanh ghi, nghĩa là chúng ta có hai thanh ghi nguồn, RS1 và RS2, và một thanh ghi đích, RD.
So we see for all those registers, we have 5-bit to represent those registers. Why do we only use 5-bit here? Omer? Yes, we always have 32 registers.
Như vậy, với tất cả các thanh ghi này, chúng ta dùng 5 bit để biểu diễn chúng. Tại sao ở đây chúng ta chỉ dùng 5 bit? Omer? Đúng, vì chúng ta luôn có 32 thanh ghi.
Remember the discussion we had last time? No matter what is the RISC-V that we're operating on, always 32-bit registers. Sorry, always 32 registers for computing. Always 32 registers.
Còn nhớ cuộc thảo luận lần trước không? Dù chúng ta đang làm việc với RISC-V loại nào, thì cũng luôn là các thanh ghi 32 bit. Xin lỗi, luôn có 32 thanh ghi để tính toán. Luôn là 32 thanh ghi.
To represent 32 registers, we need 5-bit to represent 32 registers. So those are always consistent, 5-bit for each source registers and also the destination registers. We also see func7 and func3.
Để biểu diễn 32 thanh ghi, chúng ta cần 5 bit. Vì vậy những điều này luôn nhất quán, 5 bit cho mỗi thanh ghi nguồn và cả thanh ghi đích. Chúng ta cũng thấy func7 và func3.
We'll see later, examples later. Basically, you can think about them as sub-opcodes. So they're still describing the functionalities within this category and differentiate different functions.
Chúng ta sẽ xem các ví dụ sau. Về cơ bản, bạn có thể coi chúng là các opcode phụ. Chúng vẫn mô tả các chức năng trong nhóm lệnh này và phân biệt các chức năng khác nhau.
Let's take a look at all the different fields again. We already mentioned two source registers, one destination register, and we use 5-bit unsigned integers because we always have 32 registers.
Hãy xem lại tất cả các trường khác nhau. Chúng ta đã nhắc đến hai thanh ghi nguồn, một thanh ghi đích, và dùng số nguyên không dấu 5 bit vì chúng ta luôn có 32 thanh ghi.
So we have the full set of both source registers, two source registers, and one destination register. Let's take a look at an example.
Vậy là chúng ta có đủ cả hai thanh ghi nguồn, và một thanh ghi đích. Hãy xem một ví dụ.
So one of the basic examples we like to use is addition. So here, we add two numbers. We add two registers here and write to a destination register.
Một trong những ví dụ cơ bản mà chúng ta hay dùng là phép cộng. Ở đây, chúng ta cộng hai số. Chúng ta cộng hai thanh ghi và ghi vào một thanh ghi đích.
We'll have two source registers, x10 and x9, and then we add the result to a destination register, rd.
Chúng ta có hai thanh ghi nguồn, x10 và x9, rồi cộng và ghi kết quả vào thanh ghi đích, rd.
So we actually translate this instruction to the 32-bit format that we have been using. So we have the opcode here. They specify this is a register, r-type instruction.
Bây giờ chúng ta dịch lệnh này sang định dạng 32 bit mà chúng ta vẫn dùng. Ở đây chúng ta có opcode. Nó cho biết đây là lệnh kiểu R, lệnh thanh ghi.
We have the encoding of two source registers, x10 and x9 here, and then we have the destination register x8 here to specify the register ID.
Chúng ta có mã hóa của hai thanh ghi nguồn, x10 và x9, rồi thanh ghi đích x8 ở đây để chỉ định ID của thanh ghi.
We use a combination of func3 and func7 to indicate this is an add operation. How do we actually use that?
Chúng ta dùng kết hợp func3 và func7 để chỉ ra đây là phép cộng. Thực tế chúng ta dùng nó như thế nào?
How do we actually use a different combination to represent different instructions?
Thực tế chúng ta dùng các tổ hợp khác nhau như thế nào để biểu diễn các lệnh khác nhau?
We'll see an example later how we actually change some of the subfields of func3 and func7 to represent different arithmetic, different r-type instructions.
Lát nữa chúng ta sẽ xem ví dụ về cách thay đổi một số trường con của func3 và func7 để biểu diễn các phép toán số học khác nhau, các lệnh kiểu R khác nhau.
So generally, when we think about r-type instructions, we can modify the destination registers by reading and performing operations on the source registers.
Nói chung, khi nghĩ về các lệnh kiểu R, chúng ta có thể thay đổi thanh ghi đích bằng cách đọc và thực hiện các phép toán trên các thanh ghi nguồn.
One important thing here is the PC content. So we talk about how we can basically view the processor pipeline as a giant state machine.
Một điều quan trọng ở đây là nội dung của PC. Chúng ta đã nói về cách có thể xem đường ống của bộ xử lý như một máy trạng thái khổng lồ.
All we're doing is basically modifying the states through the computation. The arithmetic, the ALU operation here is very straightforward. So we always need to actually perform the arithmetic operation.
Tất cả những gì chúng ta làm về cơ bản là thay đổi các trạng thái trong quá trình tính toán. Phép tính số học, tức thao tác ALU ở đây, rất đơn giản. Vì vậy lúc nào chúng ta cũng cần thực hiện phép tính số học.
But also another state, another important state element in our processor is the program counter, the PC register.
Nhưng còn một trạng thái khác, một phần tử trạng thái quan trọng khác trong bộ xử lý của chúng ta là bộ đếm chương trình, tức thanh ghi PC.
So whenever we execute an instruction, we also need to keep track of how we like to actually update the PC content.
Vì vậy mỗi khi thực thi một lệnh, chúng ta cũng cần theo dõi xem muốn cập nhật nội dung PC như thế nào.
So for most of the instructions that are actually not changing the program execution, it's always PC plus four as well, which actually gets to the next instruction.
Với hầu hết các lệnh không làm thay đổi luồng thực thi chương trình, thì luôn là PC cộng bốn, để chuyển đến lệnh tiếp theo.
We'll talk about the branch and the jump instructions, which can actually potentially update the PC content.
Chúng ta sẽ nói về các lệnh rẽ nhánh và lệnh nhảy, những lệnh có thể làm thay đổi nội dung PC.
So we think about changes to the machine states, not only just the registers and the memory, but also PC content.
Vì vậy khi nghĩ về những thay đổi đối với trạng thái của máy, không chỉ có các thanh ghi và bộ nhớ, mà còn cả nội dung PC.
So when we actually implement, so those are basically the states that actually change during the execution.
Vậy khi chúng ta triển khai, đó về cơ bản là những trạng thái thay đổi trong quá trình thực thi.
So when we implement this instruction in our processor pipeline, in our datapath, we haven't actually pipelined the datapath yet. Single cycle operation, we just want to execute this operation.
Khi triển khai lệnh này trong đường ống của bộ xử lý, trong datapath của chúng ta, thì chúng ta vẫn chưa chia datapath thành đường ống. Hoạt động một chu kỳ, chúng ta chỉ muốn thực thi thao tác này.
So first we actually execute it, we need to read data from the PC counter.
Đầu tiên, để thực thi, chúng ta cần đọc dữ liệu từ bộ đếm PC.
So instruction fetch, want to perform the fetch, we need to read the program counter so that we know which instruction we want to fetch.
Với việc nạp lệnh, khi muốn thực hiện nạp, chúng ta cần đọc bộ đếm chương trình để biết cần nạp lệnh nào.
Remember what we discussed, always there's another state element we need to change, the program counter, so we can advance to the next instruction.
Hãy nhớ những gì đã bàn, luôn có một phần tử trạng thái khác cần thay đổi, là bộ đếm chương trình, để có thể tiến đến lệnh tiếp theo.
So after we get the PC counter, in addition to getting instructions, we also do the PC increment so that we can actually move to the next instruction.
Vậy sau khi lấy được PC, ngoài việc lấy lệnh, chúng ta còn tăng PC để có thể chuyển sang lệnh tiếp theo.
This is another state that's actually being changed during the execution. So after that, we decode the instruction.
Đây là một trạng thái khác bị thay đổi trong quá trình thực thi. Sau đó, chúng ta giải mã lệnh.
We have the instruction, the full 32-bit, and then we basically do what we just did, like looking at the different subfields and figure out what operation it does.
Chúng ta có lệnh đủ 32 bit, rồi làm như vừa làm, là xem các trường con khác nhau và xác định nó thực hiện thao tác nào.
By looking at the instruction, we know it's an R-type instruction, meaning that we actually need to read two source registers and also write to a destination register.
Nhìn vào lệnh, chúng ta biết đây là lệnh kiểu R, nghĩa là cần đọc hai thanh ghi nguồn và ghi vào một thanh ghi đích.
So all the three register IDs can be fully decoded after we see the instruction.
Vì vậy cả ba ID thanh ghi đều có thể giải mã đầy đủ sau khi thấy lệnh.
This is an addition operation, so we pass the values that we read from the register file, perform the ALU operation, and then we also need to write to the destination register.
Đây là phép cộng, nên chúng ta chuyển các giá trị đọc từ tệp thanh ghi vào thực hiện thao tác ALU, rồi còn cần ghi vào thanh ghi đích.
So the ALU result also is being written back to the register.
Vậy kết quả ALU cũng được ghi ngược lại vào thanh ghi.
We also need to, well, this is basically how we actually perform a register operation, specifically for addition. We also need some control signals here, right?
Chúng ta cũng cần, à, về cơ bản đây là cách chúng ta thực hiện một thao tác thanh ghi, cụ thể là với phép cộng. Ở đây chúng ta cũng cần một số tín hiệu điều khiển, đúng không?
We are setting the ALU to perform an addition. We are also doing a register write, right? So remember, when we talk about write, we need a clock signal so we can do synchronous write.
Chúng ta đặt ALU để thực hiện phép cộng. Chúng ta cũng thực hiện ghi thanh ghi, đúng không? Vậy hãy nhớ, khi nói đến thao tác ghi, chúng ta cần một tín hiệu xung nhịp để có thể ghi đồng bộ.
We also need the write enable signal so that we can actually write to the register, right? And those need to be set by the control logic.
Chúng ta cũng cần tín hiệu cho phép ghi (write enable) để thực sự có thể ghi vào thanh ghi, đúng không? Và những tín hiệu đó phải được đặt bởi logic điều khiển.
And to set the write enable signal so we know we want to actually perform the write, we also need to tell the ALU.
Và để đặt tín hiệu cho phép ghi để biết rằng chúng ta thực sự muốn thực hiện việc ghi, chúng ta cũng cần báo cho ALU.
We'll talk about the ALU can do other things, right? Not only just addition. We'll tell the ALU we are actually performing an addition operation.
Ta sẽ nói về việc ALU có thể làm những việc khác, không chỉ phép cộng. Ta sẽ báo cho ALU rằng chúng ta đang thực hiện phép cộng.
So that's basically a basic datapath that is needed to execute the first instruction. We talked about the R-type instruction because we are purely doing register operations.
Vậy đó về cơ bản là một đường dữ liệu (datapath) cơ bản cần thiết để thực thi lệnh đầu tiên. Chúng ta đã nói về lệnh kiểu R vì chúng ta chỉ thực hiện các thao tác trên thanh ghi.
But on top of that, another state machine is changed. Another state that is changed is the program counter. So this is execution of the datapath of addition, right?
Nhưng ngoài ra, còn một máy trạng thái khác bị thay đổi. Một trạng thái khác bị thay đổi là bộ đếm chương trình. Vậy đây là quá trình thực thi phép cộng trên datapath, đúng không?
We talked about earlier, this is not pipelined yet. We were talking about single cycle execution, right? So what's the timing behavior, right? When we actually execute this instruction in a single cycle.
Như đã nói trước đó, nó chưa được chia theo đường ống. Chúng ta đang nói về thực thi đơn chu kỳ, đúng không? Vậy hành vi về thời gian là gì? Khi chúng ta thực thi lệnh này trong một chu kỳ.
So here, this is the execution timeline. It's over time and we have our clock signal, right? So the basic transition at every rising edge of the clock, right?
Đây là dòng thời gian thực thi. Nó diễn ra theo thời gian và chúng ta có tín hiệu xung nhịp, đúng không? Vậy sự chuyển trạng thái cơ bản xảy ra ở mỗi sườn lên của xung nhịp, đúng không?
And we want to basically implement the datapath that we just introduced earlier to perform the addition operation, right? So we mentioned the first operation we do is to actually read the program counter, right?
Và về cơ bản chúng ta muốn hiện thực datapath mà vừa giới thiệu để thực hiện phép cộng, đúng không? Như đã nói, thao tác đầu tiên là đọc bộ đếm chương trình, đúng không?
Read the PC state so that we know which instruction we want to access. After we read the PC state, we can perform two operations actually in parallel, right?
Đọc trạng thái PC để biết ta muốn truy cập lệnh nào. Sau khi đọc trạng thái PC, ta có thể thực hiện hai thao tác song song, đúng không?
One is increment the PC. The other is to access, To do the decoding so that we can actually access the instruction memory so that we can do the decoding, right?
Một là tăng PC. Hai là truy cập, để giải mã nhằm có thể truy cập bộ nhớ lệnh để chúng ta có thể giải mã, đúng không?
So that's basically the two operations we will do. The first part is basically increment the PC.
Vậy đó là hai thao tác chúng ta sẽ thực hiện. Phần đầu tiên là tăng PC.
This part, this part of our datapath so that we can actually get PC ready for the next instruction. We also read the instruction out from the instruction memory, right?
Phần này, phần này của datapath để PC sẵn sàng cho lệnh tiếp theo. Chúng ta cũng đọc lệnh ra từ bộ nhớ lệnh, đúng không?
So then we can actually perform the decoding. So there is some latency here, because either latency, again, we're doing asynchronous read. Remember we talked about memory, everything is asynchronous, combinational, right?
Rồi sau đó có thể thực hiện giải mã. Vậy ở đây có một độ trễ nhất định, vì độ trễ này, một lần nữa, chúng ta đang đọc bất đồng bộ. Nhớ rằng khi nói về bộ nhớ, mọi thứ đều bất đồng bộ, tổ hợp, đúng không?
So after certain combinational delay, the instruction is actually coming out from memory. And now we see it's an addition operation.
Vậy sau một độ trễ tổ hợp nhất định, lệnh thực sự được đưa ra từ bộ nhớ. Và bây giờ ta thấy đó là phép cộng.
We want to do the, we want to basically do the register file access, right?
Chúng ta muốn truy cập tập thanh ghi (register file), đúng không?
We have all the instruction, all the register ID ready so that we can actually perform read from our register file. Similarly for register, we also do asynchronous read, right?
Chúng ta đã có toàn bộ lệnh, tất cả ID thanh ghi đã sẵn sàng để chúng ta có thể thực hiện việc đọc từ register file. Tương tự, với thanh ghi, chúng ta cũng đọc không đồng bộ, đúng không?
So whenever the register IDs are ready, after a certain combinational delay, right? We can get the data from register, right? So here we're doing two source registers, R-type, right? Two source registers.
Vì vậy, ngay khi các ID thanh ghi đã sẵn sàng, sau một độ trễ tổ hợp nhất định, đúng không? Chúng ta có thể lấy dữ liệu từ thanh ghi, đúng không? Ở đây ta có hai thanh ghi nguồn, kiểu R, đúng không? Hai thanh ghi nguồn.
We get the content ready for basically those two wires, right? Reg RS1 and Reg RS2, right? So this is an arithmetic operation, we're doing addition, right?
Ta có nội dung sẵn sàng trên hai dây đó, đúng không? Reg RS1 và Reg RS2, đúng không? Đây là một phép toán số học, ta đang thực hiện phép cộng, đúng không?
So after a certain combinational delay, goes in through ALU, our results, our added result is ready, is ready from the ALU.
Sau một độ trễ tổ hợp nhất định, dữ liệu đi qua ALU, kết quả của chúng ta, kết quả phép cộng đã sẵn sàng từ ALU.
And the last step is basically perform the write operation to our register file, right?
Và bước cuối cùng là thực hiện thao tác ghi vào register file, đúng không?
Remember for write, we always do synchronous write, which means that when we do the write, we need to wait first with a clock trigger.
Hãy nhớ rằng với việc ghi, ta luôn ghi đồng bộ, nghĩa là khi ghi, trước tiên ta phải chờ xung clock kích hoạt.
We need to have the clock wait for the next writing edge of the clock.
Ta cần chờ đến cạnh ghi tiếp theo của xung clock.
And we also need to set the write enable signal from our control module to actually specify we want to do a write operation, right?
Và ta cũng cần đặt tín hiệu cho phép ghi từ khối điều khiển để chỉ rõ rằng ta muốn thực hiện thao tác ghi, đúng không?
So with that, register R1, which is basically the destination register, is updated after the writing edge of the next clock, right?
Như vậy, thanh ghi R1, tức là thanh ghi đích, được cập nhật sau cạnh ghi của xung clock tiếp theo, đúng không?
So all the operation that we discussed happened in this clock cycle. And we started by reading the PC counter, and we end this cycle by actually updating our register, our destination register.
Vậy tất cả các thao tác chúng ta đã thảo luận đều diễn ra trong chu kỳ clock này. Chúng ta bắt đầu bằng việc đọc bộ đếm chương trình PC, và kết thúc chu kỳ này bằng việc cập nhật thanh ghi, tức thanh ghi đích.
And everything else, we do instruction read. We also do register read. Both reads happened combinationally, so asynchronous read, which doesn't need to wait for the clock cycle.
Còn mọi thứ khác, ta đọc lệnh. Ta cũng đọc thanh ghi. Cả hai lần đọc đều diễn ra theo kiểu tổ hợp, tức là đọc không đồng bộ, không cần chờ chu kỳ clock.
Makes sense, the datapath? Questions, doubts?
Datapath thì hiểu chưa? Có câu hỏi hay thắc mắc nào không?
Lucy?
Lucy?
Right, right.
Vâng, đúng vậy.
So Lucy's question is that do we always specifically implement this instruction this way, or depends on the different design scenarios, do we actually have different designs, like for embedded system and desktop or even servers?
Câu hỏi của Lucy là liệu chúng ta có luôn triển khai lệnh này theo đúng cách này không, hay tùy theo các kịch bản thiết kế khác nhau, thì ta có những thiết kế khác nhau không, chẳng hạn cho hệ thống nhúng, máy tính để bàn hoặc thậm chí máy chủ?
The answer is no, we don't always implement this way. So remember, we talk about layers of abstractions, and we talk about spec and implementation, right?
Câu trả lời là không, không phải lúc nào cũng triển khai theo cách này. Hãy nhớ rằng chúng ta đã nói về các lớp trừu tượng, và nói về đặc tả và triển khai, đúng không?
So the R type instruction, basically all the format, it's too many slides, animation. Anyway, the R type format, always the same. The different register fields and different func3, func7, they stay the same.
Với lệnh kiểu R, toàn bộ định dạng, có quá nhiều slide, hiệu ứng. Dù sao thì định dạng kiểu R luôn luôn giống nhau. Các trường thanh ghi khác nhau và func3 khác nhau, func7, chúng vẫn giữ nguyên.
Those are the spec. The implementation is up to the designers and up to a different group of designers, different companies.
Đó là đặc tả. Còn việc triển khai là do các nhà thiết kế quyết định, và tùy từng nhóm thiết kế, từng công ty khác nhau.
You can implement your RISC-V execution in a particular fashion, which can be actually very different from, let's say, Western Digital's implementation or SiFive's implementation. Even we talk about this datapath, right?
Bạn có thể triển khai việc thực thi RISC-V theo một cách riêng, có thể rất khác với, chẳng hạn, cách triển khai của Western Digital hay của SiFive. Ngay cả khi chúng ta nói về datapath này, đúng không?
When you actually approach your final project, you will also implement it different, right? So that's basically the differences between spec. RISC-V is really just a standard, right?
Khi các em thực hiện đồ án cuối kỳ, các em cũng sẽ cài đặt nó theo cách khác nhau, đúng không? Đó chính là sự khác biệt giữa đặc tả và cài đặt. RISC-V thực chất chỉ là một chuẩn, đúng không?
So it's specified on instruction format, and how you plan to execute, what's the microarchitecture that you're designing, can be very different.
Chuẩn này quy định định dạng lệnh, còn cách các em dự định thực thi lệnh, tức vi kiến trúc mà các em thiết kế, có thể rất khác nhau.
So when people are actually designing their own RISC-V processor, they only need the particular spec that we're talking about, but the implementation can be very different.
Vì vậy khi mọi người thiết kế bộ xử lý RISC-V của riêng mình, họ chỉ cần phần đặc tả mà chúng ta đang nói tới, nhưng cách cài đặt thì có thể rất khác nhau.
Oh, you have a follow-up question? Okay, go ahead.
Ồ, em có câu hỏi tiếp theo à? Được, em hỏi đi.
Right, So that's a good question. So you mentioned several different concepts in architecture. They all ended with memory, but they're talking about very different things, right?
Vâng, đó là một câu hỏi hay. Em vừa nhắc đến nhiều khái niệm khác nhau trong kiến trúc. Chúng đều kết thúc bằng từ memory (bộ nhớ), nhưng thực ra chúng nói về những thứ rất khác nhau, đúng không?
So here, when we talk about memory, you can basically think of the slow math as actually SRAM, the physical SRAM, which takes addresses and then outputs data.
Ở đây, khi nói về bộ nhớ, các em có thể hiểu phần bộ nhớ chậm chính là SRAM, tức SRAM vật lý, nhận vào địa chỉ rồi xuất ra dữ liệu.
That's basically the physical memory interface, the SRAM interface. So that's our discussion. Virtual memory is something different.
Đó chính là giao diện bộ nhớ vật lý, giao diện SRAM. Đó là nội dung chúng ta đang bàn. Bộ nhớ ảo thì khác.
Virtual memory is really thinking about how we virtualize the system, virtualize the memory, so that the different processes, different threads can actually see the same memory space, but then can be physically partitioned differently.
Bộ nhớ ảo là cách ta ảo hóa hệ thống, ảo hóa bộ nhớ, để các tiến trình khác nhau, các luồng khác nhau có thể cùng thấy một không gian bộ nhớ, nhưng về mặt vật lý lại được phân chia khác nhau.
So that's actually another layer on top of the physical SRAM that we're talking about; it's higher level. Flash memory is actually a different way of actually implementing the memory.
Vậy nên đó là một lớp khác nằm trên SRAM vật lý mà ta đang nói tới; nó ở mức cao hơn. Bộ nhớ flash là một cách khác để cài đặt bộ nhớ.
We'll actually cover flash later this semester. So when we talk about memory interface, data, addressing, memory out, there are different physical ways of implementing memory, right?
Chúng ta sẽ học về flash ở phần sau của học kỳ này. Vậy khi nói về giao diện bộ nhớ gồm dữ liệu, địa chỉ, đầu ra bộ nhớ, có nhiều cách vật lý khác nhau để cài đặt bộ nhớ, đúng không?
SRAM, you can actually build it with six transistors. You can actually build it with eight transistors. Again, that's another layer of implementation. You can actually implement it differently.
SRAM có thể xây dựng bằng sáu transistor. Cũng có thể xây dựng bằng tám transistor. Một lần nữa, đó là một lớp cài đặt khác. Các em có thể cài đặt theo cách khác.
Flash is actually a different way of implementing memory. So we are literally talking about this memory, physical memory interface with address and data. That's a memory word. Question?
Flash là một cách khác để cài đặt bộ nhớ. Vậy ở đây chúng ta đang nói đúng về bộ nhớ này, giao diện bộ nhớ vật lý với địa chỉ và dữ liệu. Đó là một từ nhớ. Có câu hỏi không?
Yeah, that's a very good question.
Vâng, đó là một câu hỏi rất hay.
Also very important one. Just want to reiterate so everyone online can see. So the question, and your name is? Ben. Ben.
Cũng là câu hỏi rất quan trọng. Tôi nhắc lại để mọi người học trực tuyến đều thấy. Câu hỏi, và tên em là gì? Ben. Ben.
So the question Ben asked is that the data path that we're building up throughout the lecture, is this part of the spec or is this part of implementation?
Câu hỏi của Ben là đường dữ liệu mà chúng ta xây dựng dần trong suốt bài giảng, là một phần của đặc tả hay một phần của cài đặt?
The answer is this is part of a specific implementation. This is not part of the spec. The spec is really just the instruction.
Câu trả lời là nó thuộc về một cách cài đặt cụ thể. Nó không phải là một phần của đặc tả. Đặc tả thực chất chỉ là tập lệnh.
So we talk about the R type instruction, S type instruction, I type instruction. Those instruction formats are part of the spec. If you read the RISC-V instruction spec, they are talking about instruction format.
Tức là chúng ta nói về lệnh kiểu R, lệnh kiểu S, lệnh kiểu I. Các định dạng lệnh đó là một phần của đặc tả. Nếu đọc đặc tả tập lệnh RISC-V, họ nói về định dạng lệnh.
What we are talking about here is a particular implementation of this particular RISC-V 32-bit integer. This is just one example implementation.
Còn điều chúng ta đang nói ở đây là một bản triển khai cụ thể của RISC-V số nguyên 32 bit này. Đây chỉ là một ví dụ triển khai.
It's a good implementation that cover different stages. The one that you will be actually implementing in your project will also be slightly different from this one.
Đó là một bản triển khai tốt, bao quát các giai đoạn khác nhau. Bản mà các bạn thực sự sẽ triển khai trong dự án cũng sẽ hơi khác so với bản này.
So this is just the A implementation. It's not part of the spec. It's just the one that we're using to cover different contents. And there are actually different semesters.
Vậy đây chỉ là một bản triển khai. Nó không thuộc đặc tả. Nó chỉ là bản chúng ta dùng để trình bày các nội dung khác nhau. Và thực tế có nhiều học kỳ khác nhau.
I also see different designs in some of the 61C examples and our examples in different semesters. We also adjust the example slightly differently.
Tôi cũng thấy các thiết kế khác nhau trong một số ví dụ của 61C và trong các ví dụ của chúng ta ở những học kỳ khác nhau. Chúng ta cũng điều chỉnh ví dụ hơi khác nhau.
So this is not part of the spec. This is just an A implementation. Very important. Any other questions?
Vậy đây không thuộc đặc tả. Đây chỉ là một bản triển khai. Rất quan trọng. Còn câu hỏi nào khác không?
Okay, so we'll see more how we actually cover different components of the design throughout the lecture. Again, the instruction itself is part of the standard. It's part of the spec.
Được rồi, chúng ta sẽ thấy rõ hơn cách chúng ta trình bày các thành phần khác nhau của thiết kế trong suốt bài giảng. Một lần nữa, bản thân lệnh là một phần của chuẩn. Nó là một phần của đặc tả.
Then we are using this datapath as a particular example to implement the instruction. So, so far we only talked about add instruction, which is one of the most basic R-type instructions.
Sau đó chúng ta dùng datapath này như một ví dụ cụ thể để triển khai lệnh. Cho đến giờ chúng ta mới nói về lệnh add, một trong những lệnh kiểu R cơ bản nhất.
But there are other, we mentioned earlier, other arithmetic operations also specified in RISC-V ISA. So another one is basically subtract, subtraction.
Nhưng còn những lệnh khác, như đã nhắc trước đó, các phép toán số học khác cũng được quy định trong ISA RISC-V. Một lệnh khác là subtract, tức phép trừ.
So here you see how we actually use, this is the FUNC7 field that we discussed earlier. How we actually modify the FUNC7 field. Everything else stays the same.
Ở đây các bạn thấy chúng ta dùng như thế nào, đây là trường FUNC7 mà chúng ta đã thảo luận trước đó. Chúng ta sửa trường FUNC7 như thế nào. Mọi thứ khác giữ nguyên.
We still have two source registers, one destination register. The only difference is that we modify this bit to indicate this is actually a subtraction instead of addition.
Vẫn có hai thanh ghi nguồn, một thanh ghi đích. Khác biệt duy nhất là ta sửa bit này để chỉ ra đây thực ra là phép trừ chứ không phải phép cộng.
So this, again, this is RISC-V. This is part of the spec. This is the standard, right? Now we transition to implement. We want to implement, add this instruction also to our implementation.
Vậy, một lần nữa, đây là RISC-V. Đây là một phần của đặc tả. Đây là chuẩn, đúng không? Giờ ta chuyển sang phần triển khai. Chúng ta muốn triển khai, thêm lệnh này vào bản triển khai của mình.
Then we look at our datapaths. They largely stay the same, right? Because everything is still performing register read and then do some update arithmetic operations and do the register write, right?
Rồi ta nhìn vào các datapath. Chúng gần như giữ nguyên, đúng không? Vì mọi thứ vẫn là đọc thanh ghi rồi thực hiện một phép toán số học nào đó và ghi thanh ghi, đúng không?
One thing we added here is basically this control signal that I actually get to select which operation that we want to do, right? Whether we're doing addition or whether we're actually doing subtraction, right?
Một thứ chúng ta thêm vào ở đây là tín hiệu điều khiển này để chọn phép toán mà chúng ta muốn thực hiện, đúng không? Là đang làm phép cộng hay đang làm phép trừ, đúng không?
So this is a data path for the addition and subtraction, I say. Both are R-type instructions. So we look at all the different R-type instructions.
Vậy đây là datapath cho phép cộng và phép trừ. Cả hai đều là lệnh kiểu R. Giờ ta xem tất cả các lệnh kiểu R khác nhau.
We not only have the, I just talked about addition and subtraction, but there are other basically register-to-register operations, right? We see they basically have the same opcode.
Chúng ta không chỉ có phép cộng và phép trừ như tôi vừa nói, mà còn có các phép toán thanh ghi với thanh ghi khác, đúng không? Ta thấy chúng có cùng opcode.
They either differ, like look at, for example, the addition and subtraction have different FUNC7, FUNC7 field, or they have different FUNC3 field to specify different operations, right?
Chúng khác nhau ở, chẳng hạn hãy xem, ví dụ phép cộng và phép trừ có FUNC7 khác nhau, trường FUNC7, hoặc có FUNC3 khác nhau để chỉ định các phép toán khác nhau, đúng không?
But the rest of the register, where the source registers are and the destination registers are, are consistent, right?
Nhưng phần còn lại của các thanh ghi, tức là vị trí của các thanh ghi nguồn và thanh ghi đích, thì nhất quán, đúng không?
We see a bunch of different operations: shift, shifting operation, set, set less than, set less than unsigned, xor, shift right.
Chúng ta thấy một loạt phép toán khác nhau: phép dịch bit, set, set less than, set less than unsigned, xor, dịch phải.
Oh, so now we have two shift right operations, right? One is srl and one is sra. What's the difference between srl and sra? George?
Ồ, vậy bây giờ ta có hai phép dịch phải, đúng không? Một là srl và một là sra. Sự khác nhau giữa srl và sra là gì? George?
Exactly, right? So here we need to differentiate logical shift and arithmetic shift, right? So for arithmetic shift, as George mentioned, we need to actually do sign extension to actually keep the sign bit.
Chính xác, đúng không? Ở đây ta cần phân biệt dịch logic và dịch số học, đúng không? Với dịch số học, như George đã nói, ta thực sự cần mở rộng dấu để giữ nguyên bit dấu.
When we shift right, we're doing just logical shift. We just do the zero extension. We don't need to extend the sign bits, right?
Khi dịch phải logic, ta chỉ làm dịch logic thôi. Ta chỉ mở rộng bằng số 0. Không cần mở rộng bit dấu, đúng không?
So very important when we actually approach different subfields and different detail operations, especially when you actually need to implement the design. Okay, so those are the R-type instructions.
Vì vậy điều này rất quan trọng khi ta làm việc với các trường con khác nhau và các phép toán chi tiết khác nhau, đặc biệt là khi bạn cần hiện thực thiết kế. Được rồi, đó là các lệnh kiểu R.
Before we move on, any other questions, comments about R-type instruction or data path? Okay, so we see a little bit, a taste of the instructions. Ben?
Trước khi tiếp tục, có câu hỏi nào khác không, hay nhận xét nào về lệnh kiểu R hoặc đường dữ liệu không? Được rồi, vậy là ta đã thấy sơ qua về các lệnh. Ben?
Yeah, that's a good question. So the spec that we're talking about is RISC-V 32-bit integer spec, right?
Vâng, đó là một câu hỏi hay. Đặc tả mà ta đang nói đến là đặc tả số nguyên RISC-V 32 bit, đúng không?
So in this spec, multiply is not part of the instruction set. If you actually read it, these are all the R-type instructions. There is a multiply extension.
Trong đặc tả này, phép nhân không thuộc tập lệnh. Nếu bạn đọc kỹ, đây là tất cả các lệnh kiểu R. Có một phần mở rộng cho phép nhân.
So RISC-V also has different extensions, right? I mentioned during the NASA one, they actually support the vector extension so that it can actually perform vector operation.
RISC-V cũng có nhiều phần mở rộng khác nhau, đúng không? Tôi đã nhắc đến trường hợp của NASA, họ hỗ trợ phần mở rộng vectơ để có thể thực hiện các phép toán vectơ.
So there is a multiply extension that can actually support multiply instruction. So it's not part of the base ISA.
Vậy có một phần mở rộng nhân để hỗ trợ lệnh nhân. Nó không thuộc ISA cơ sở.
Base ISA will only do addition and subtraction, but there are extensions to support more operations. Good question. Remember?
ISA cơ sở chỉ làm phép cộng và phép trừ, nhưng có các phần mở rộng để hỗ trợ thêm nhiều phép toán. Câu hỏi hay. Bạn nhé?
It seems like they are mostly trying to use RISC-V 32-bit to distinguish the different operations. But there are Steiner bits of RISC-V 32-bit, they all use RISC-V 32-bit.
Có vẻ như họ chủ yếu cố dùng RISC-V 32 bit để phân biệt các phép toán khác nhau. Nhưng có những bit của RISC-V 32 bit mà họ đều dùng cho RISC-V 32 bit.
My question is why don't they just use RISC-V 32-bit so much bits to distinguish everything?
Câu hỏi của em là tại sao họ không dùng RISC-V 32 bit nhiều bit như vậy để phân biệt mọi thứ?
Yeah, so a lot of the implementation in determining the instruction format is also thinking about the decoding efficiency, how we can actually quickly decode the instruction.
Vâng, việc xác định định dạng lệnh phần lớn cũng cân nhắc đến hiệu quả giải mã, tức là làm sao để giải mã lệnh thật nhanh. Chỉ cần nhìn vào 3 bit để biết phép toán là gì thì nhanh hơn nhiều.
It's a lot faster, just look at the 3-bit to figure out what's the operation. So we actually see basically, you can think of that the first level in coding is actually Func3.
Vậy ta thấy về cơ bản, bạn có thể xem mức mã hóa đầu tiên chính là Func3.
By looking at Func3, you'll know whether they're doing additional subtraction or they're doing a different set operations or bitwise operations.
Nhìn vào Func3, bạn sẽ biết họ đang làm phép cộng hay phép trừ hay không. hoặc họ đang thực hiện các phép toán đặt giá trị khác, hoặc các phép toán theo từng bit.
And then if needed, we look at the Func7 to see actually what sub-operations are actually needed. So this is basically decoding efficiency.
Và sau đó, nếu cần, chúng ta xem Func7 để biết thực sự cần những phép toán con nào. Vậy đây chính là hiệu quả giải mã.
We want to actually decode instruction as quickly as possible so we can actually do later operations faster.
Chúng ta muốn giải mã lệnh càng nhanh càng tốt để có thể thực hiện các thao tác sau đó nhanh hơn.
So this is basically, you can think about the hierarchy of decoding and it's a lot faster to have smaller bits so that we can actually move quickly.
Vậy bạn có thể coi đây là một phân cấp giải mã, và dùng ít bit hơn thì nhanh hơn nhiều, nhờ đó chúng ta có thể xử lý nhanh chóng.
So it's much faster to decode the 3-bit.
Vì vậy giải mã 3 bit nhanh hơn nhiều.
And also, like, add and sub, they have the same Func3, because maybe they're doing some similar operations, because subtraction is func, and the same number, and sub, right?
Ngoài ra, add và sub có cùng Func3, vì có lẽ chúng thực hiện các phép toán tương tự nhau, vì phép trừ cũng là một hàm, cùng một số, và sub, đúng không?
Exactly, exactly.
Chính xác, chính xác.
So we group the similar things actually together using the same Func3, and then we'll see other examples, then they're like find differences, And then finding the differences in Func7 to actually specify different functions.
Vậy chúng ta gom những thứ tương tự lại với nhau bằng cách dùng cùng một Func3, và sau đó chúng ta sẽ thấy các ví dụ khác, khi đó ta tìm ra sự khác biệt, và tìm ra sự khác biệt trong Func7 để xác định các hàm khác nhau.
So decoding efficiency is very important when designing an instruction format, right? Good question. So we talked about R-type instruction, we'll see a little bit about other types of instructions.
Vì vậy hiệu quả giải mã rất quan trọng khi thiết kế một định dạng lệnh, đúng không? Câu hỏi hay. Chúng ta đã nói về lệnh kiểu R, giờ chúng ta sẽ xem qua một chút về các kiểu lệnh khác.
So far, we're mostly talking about register-to-register operation, right? But another very commonly used pattern is actually a constant that we actually want to use directly in our computation, right?
Cho đến giờ, chúng ta chủ yếu nói về phép toán giữa thanh ghi với thanh ghi, đúng không? Nhưng một mẫu rất hay dùng khác là một hằng số mà chúng ta muốn dùng trực tiếp trong tính toán, đúng không?
So that's basically what I-type instruction is trying to do, or immediate instruction, right?
Đó chính là điều mà lệnh kiểu I muốn làm, hay còn gọi là lệnh immediate, đúng không?
So as the name suggests, the data is immediately available instead of actually needing, instead of reading from the register file, right?
Như tên gọi cho thấy, dữ liệu có sẵn ngay lập tức thay vì cần phải đọc từ tệp thanh ghi, đúng không?
So R-type instruction is actually largely very similar to, sorry, I-type, I-type immediate instruction is largely similar to R-type, the register-to-register operation.
Vậy lệnh kiểu R về cơ bản rất giống với, xin lỗi, lệnh immediate kiểu I về cơ bản tương tự lệnh kiểu R, phép toán giữa thanh ghi với thanh ghi.
The only difference here, because one of the sources will be an immediate, right? So we don't need actually two source registers.
Điểm khác duy nhất ở đây là một trong các toán hạng nguồn sẽ là một immediate, đúng không? Vì vậy chúng ta không cần đến hai thanh ghi nguồn.
So what it does, basically, combines RS2 and Func7 into our immediate bits, right? So now you'll see we actually still, the format is largely the same.
Do đó, về cơ bản nó kết hợp RS2 và Func7 thành các bit immediate, đúng không? Vậy bây giờ bạn sẽ thấy định dạng vẫn gần như giống nhau.
On the right-hand side, we still have source and destination registers, but then to actually encode, because first, we don't need a source register, right?
Ở phía bên phải, chúng ta vẫn có các thanh ghi nguồn và đích, nhưng để mã hóa, vì thứ nhất, chúng ta không cần thanh ghi nguồn, đúng không?
And second, we actually want to encode, I guess, a constant or immediate as large as possible, with more bits. So we basically dedicate the upper 12 bits to encode the immediate, right?
Và thứ hai, chúng ta muốn mã hóa một hằng số hay immediate lớn nhất có thể, với nhiều bit hơn. Vì vậy chúng ta dành 12 bit cao để mã hóa immediate, đúng không?
So largely the same, but then we basically combine RS2 and the Func7 so that we can represent a 12-bit immediate. The rest of the things is the same, right?
Nên về cơ bản là giống nhau, nhưng chúng ta kết hợp RS2 và Func7 để có thể biểu diễn một immediate 12 bit. Phần còn lại thì giống nhau, đúng không?
And then we can actually represent values. It's a signed value, right? So positive and negative 2048, positive 2047.
Và khi đó chúng ta có thể biểu diễn các giá trị. Đó là giá trị có dấu, đúng không? Tức là từ âm 2048 đến dương 2047.
So we have this immediate that we can actually use in our instruction. So everything else is the same.
Vậy là chúng ta có giá trị immediate này để dùng trong lệnh. Còn mọi thứ khác thì giữ nguyên.
So one thing you will see generally in instruction ISA design, in particular, you'll see also in RISC-V, is that they try to keep the format as constant as possible, related to what the member discussed earlier, decoding efficiency, Right?
Một điều các bạn thường thấy trong thiết kế ISA, và đặc biệt là trong RISC-V, là người ta cố giữ định dạng lệnh càng cố định càng tốt, liên quan đến điều bạn đã nhắc lúc nãy, đó là hiệu quả giải mã, đúng không?
So as long as they're consistent, it's easier to decode. So we always try to actually maintain the format as consistent as possible.
Miễn là các định dạng nhất quán thì việc giải mã sẽ dễ hơn. Vì vậy chúng ta luôn cố giữ định dạng nhất quán nhất có thể.
We actually will see some weird patterns later, but we always try to keep this format as much as possible, right? So you will, again, look pretty similar.
Sau này chúng ta sẽ thấy một vài kiểu khác thường, nhưng chúng ta luôn cố giữ định dạng này hết mức có thể, đúng không? Nên các lệnh trông sẽ khá giống nhau.
You will actually look at all the different I-type instructions, right? It's basically like an extension of R-type, register-type instruction, but then we actually add an immediate here, right?
Các bạn hãy xem tất cả các lệnh kiểu I khác nhau, nhé. Về cơ bản nó giống như một phần mở rộng của lệnh kiểu R, lệnh kiểu thanh ghi, nhưng ở đây chúng ta thêm một giá trị immediate, đúng không?
So one thing you will see, we don't have Func7 and the source register two anymore. So we basically combine those as a, as a big immediate field, right?
Một điều các bạn sẽ thấy là không còn Func7 và thanh ghi nguồn hai nữa. Chúng ta gộp chúng lại thành một trường immediate lớn, đúng không?
So we look at the operations. Let's see. Oh, so, well, some of you may be wondering, right? So Sophia will talk about the Boolean algebra, the logical operation, right?
Giờ hãy xem các phép toán. Để xem nào. À, có thể một số bạn đang thắc mắc, đúng không? Sophia sẽ nói về đại số Boolean, các phép toán logic, đúng không?
You told us the basic functionality, the basic operations are basically NOT, single input, NOT inversion, and the two input, AND and OR, right? So now you will look at the RISC-V.
Cô ấy đã cho các bạn biết các chức năng cơ bản, các phép toán cơ bản là NOT, một đầu vào, tức phép đảo, và hai đầu vào là AND và OR, đúng không? Bây giờ hãy nhìn vào RISC-V.
I say, we only have OR and AND, but we actually don't have the NOT, which is basically one of the most basic building blocks in our digital logic, right?
Ta chỉ có OR và AND, nhưng lại không có NOT, vốn là một trong những khối cơ bản nhất của logic số, đúng không?
So why RISC-V didn't include a NOT operation here?
Vậy tại sao RISC-V không có phép NOT ở đây?
Is this a bug, Brendan? You can flip a bit with XOR, right? So how do we flip a bit with XOR?
Đây có phải là lỗi không, Brendan? Có thể đảo một bit bằng XOR, đúng không? Vậy làm sao đảo một bit bằng XOR?
I think if you XOR with one, then it's a bit, zero XOR one, one, one, one, one, one, one.
Em nghĩ nếu XOR với một, thì bit, không XOR một ra một, một, một, một, một, một.
So we'll do a one, basically? So we XOR one, would that give us a NOT operation? I'm sorry, you would XOR with every bit one.
Vậy ta XOR với một, đúng không? Vậy XOR với một thì có cho ta phép NOT không? Xin lỗi, bạn phải XOR với một ở mọi bit.
With every bit is one, right? So with, what's that? Negative. Negative one, exactly. So every bit is one, into its complement, basically negative one, right? So yes, exactly.
Mọi bit đều là một, đúng không? Vậy đó là gì? Số âm. Âm một, chính xác. Mọi bit đều là một, thành số bù của nó, về cơ bản là âm một, đúng không? Vậy nên, đúng thế.
So with, you will want to actually perform a NOT operation, very basic operation. We can actually basically use XOR to perform this operation, right?
Khi muốn thực hiện phép NOT, một phép toán rất cơ bản, chúng ta có thể dùng XOR để thực hiện, đúng không?
So instead of adding another ISA, so again, another philosophy with ISA design: reduce instructions, that ISA, right? Architecture, right? We want to design as simple, as clean as possible.
Thay vì thêm một lệnh nữa, đó lại là một triết lý khác của thiết kế ISA: giảm số lệnh, đúng không? Kiến trúc, đúng không? Ta muốn thiết kế đơn giản và gọn gàng nhất có thể.
So instead of having another ISA just perform the not, we can always use XOR to perform the not operation here, right?
Vì vậy thay vì có thêm một lệnh chỉ để thực hiện NOT, ta luôn có thể dùng XOR để thực hiện phép NOT, đúng không?
So one of the differences here with the immediate instruction design is the shift operation, right?
Một điểm khác biệt ở đây trong thiết kế lệnh immediate là phép dịch, đúng không?
We already talked about shift left, it is what it is, but for shift right, we have arithmetic shift and the logical shift, and that's also consistent in the I type instruction.
Dịch trái thì chúng ta đã nói rồi, nó là như vậy, nhưng với dịch phải, ta có dịch số học và dịch logic, và điều đó cũng nhất quán trong lệnh kiểu I.
So with the shift instruction, right? We actually don't need the full 12 bit to specify the shift amount, right? We actually only need five bit to specify the shift amount. Why is that?
Vậy với lệnh dịch bit nhé? Thực ra chúng ta không cần đủ 12 bit để xác định số lượng bit cần dịch, đúng không? Thực ra chỉ cần 5 bit để xác định số bit cần dịch. Tại sao vậy?
Why do we only need five bit? Ben? Because all of the registers that would be getting five are going to take long.
Tại sao chỉ cần 5 bit? Ben? Vì tất cả các thanh ghi được lấy ra ở đây đều có độ dài giới hạn.
And so the large count that's finding that is 32 or 31, and yeah.
Và giá trị đếm lớn nhất là 32 hay 31, vâng.
And if we shift a register by more than 31 spaces, then we are losing all of the data to that register. Exactly. So it doesn't make sense to actually shift more, right?
Và nếu ta dịch một thanh ghi hơn 31 vị trí, thì ta sẽ mất toàn bộ dữ liệu trong thanh ghi đó. Chính xác. Vậy nên dịch nhiều hơn là không có ý nghĩa, đúng không?
So we actually see the shift amount we only use those five bit.
Vì thế với số bit cần dịch, ta chỉ dùng 5 bit đó.
While we are talking about 32 bit, we also mentioned last time, a lot of, especially today is like more like for desktop, like Lucy mentioned, right? We actually build more complex processors.
Khi nói về 32 bit, lần trước chúng ta cũng đã nhắc đến, rất nhiều, đặc biệt là ngày nay, thiên về máy tính để bàn, như Lucy đã nói, đúng không? Chúng ta xây dựng các bộ xử lý phức tạp hơn.
So it's actually possible, like a lot of processors are actually using 64 bit instead of 32 bit, right?
Nên hoàn toàn có thể, nhiều bộ xử lý thực ra dùng 64 bit thay vì 32 bit, đúng không?
So we actually like to extend it instead of the RV 32 bit integer, you will want to do the RV 64 bit integer.
Vì vậy ta muốn mở rộng, thay vì RV 32 bit số nguyên, bạn sẽ muốn dùng RV 64 bit số nguyên.
So with 64 bit, right? Every register is in 32 bit is 64 bit, right? So how do we actually change the ISA to support 64 bit values?
Với 64 bit, mỗi thanh ghi vốn 32 bit giờ là 64 bit, đúng không? Vậy ta thay đổi ISA như thế nào để hỗ trợ các giá trị 64 bit?
Omar? We shift the amount to 64 bit. Exactly. We do have some extra space here, right? So we still have the MSP, the seven bits here.
Omar? Ta mở rộng số bit dịch lên 64 bit. Chính xác. Ở đây chúng ta còn dư một ít chỗ, đúng không? Ta vẫn còn MSP, tức 7 bit ở đây.
So now instead of only shifting five bits, with 64 bit data, we can actually shift, we need to actually use six bits to specify the shift amount, right?
Vậy giờ thay vì chỉ dịch 5 bit, với dữ liệu 64 bit, ta có thể dịch, ta cần dùng 6 bit để xác định số bit cần dịch, đúng không?
So when we actually extend it to 64 bit data, we actually, we can grab one more bit to specify the shift amount, right?
Vậy khi mở rộng sang dữ liệu 64 bit, ta có thể lấy thêm một bit để xác định số bit cần dịch, đúng không?
So when you're talking about a base ISA design, but there are all the different extensions and different thought process actually going into the ISA design. So this is important. Omar?
Vậy khi nói về thiết kế ISA cơ sở, thì còn có rất nhiều phần mở rộng khác nhau và những cách suy nghĩ khác nhau được đưa vào thiết kế ISA. Điều này quan trọng. Omar?
So for 64 bit system, the address is not 64 bit, but are the instructions also 64 bit or is it?
Với hệ thống 64 bit, địa chỉ không phải 64 bit, nhưng các lệnh cũng là 64 bit hay là sao ạ?
That's a good question. For 64 bit ISA, how many bits do we use for instructions?
Câu hỏi hay. Với ISA 64 bit, lệnh dùng bao nhiêu bit?
The data is 64 bit, right? We talked about. Yeah. How about instructions? Aya? Should be 32. Why is that? We use 32 bit.
Dữ liệu là 64 bit, đúng không? Chúng ta đã nói rồi. Vâng. Còn lệnh thì sao? Aya? Chắc là 32. Tại sao vậy? Ta dùng 32 bit.
Right, so in majority of the time, we basically want to have a consistent ISA. So no matter whether the data is 32 bit or 64 bit, the instruction is always 32 bit.
Đúng, phần lớn thời gian ta muốn có một ISA nhất quán. Nên dù dữ liệu là 32 bit hay 64 bit, lệnh luôn là 32 bit.
So it's always 32 bit. There is only one exception, is that for RISC-V embedded extension.
Nó luôn là 32 bit. Chỉ có một ngoại lệ, là phần mở rộng nhúng của RISC-V.
So as Lucy also mentioned earlier, embedded is a very important market and code efficiency, minimizing the code size is very important. So for embedded extension, RISC-V does support 16 bit instruction.
Như Lucy cũng đã nói trước đó, nhúng là một thị trường rất quan trọng và hiệu quả mã, tức giảm thiểu kích thước mã, là rất quan trọng. Vì vậy với phần mở rộng nhúng, RISC-V có hỗ trợ lệnh 16 bit.
That's the only exception. The majority of the time, it's always 32 bit. Even when we get to 64 bit data, instruction is always 32 bit. Question?
Đó là ngoại lệ duy nhất. Phần lớn thời gian, nó luôn là 32 bit. Ngay cả khi dữ liệu 64 bit, lệnh vẫn luôn là 32 bit. Có câu hỏi không?
So if you're working with 64 bit data, how do you manage that and how do you know that it's 64 bit data and it's based on the data?
Vậy nếu làm việc với dữ liệu 64 bit, thì làm sao quản lý được điều đó, và làm sao biết đó là dữ liệu 64 bit, và nó dựa trên dữ liệu à?
Right, that's a good question, right? So again, register size in term of the number of registers, They also stay constant.
Đúng rồi, câu hỏi hay đấy. Về kích thước thanh ghi xét theo số lượng thanh ghi, chúng cũng giữ nguyên không đổi.
There are only 32 registers, but we do need to specify whether we're loading the upper 32 bit or the lower 32 bit explicitly when we get to the 64 bit ISA.
Chỉ có 32 thanh ghi, nhưng chúng ta cần chỉ rõ là đang nạp 32 bit trên hay 32 bit dưới khi làm việc với ISA 64 bit.
So there are additional instructions in the 64 bit extension to specify the upper and the lower operation. Yeah.
Vì vậy có thêm các lệnh trong phần mở rộng 64 bit để chỉ định thao tác trên phần trên và phần dưới. Vâng.
So if there were 64 bit operation, that would be the reason if there was 64 bit?
Vậy nếu có thao tác 64 bit thì đó sẽ là lý do, đúng không?
They will be stored in the same register, but when you access it, we'll specify that.
Chúng sẽ được lưu trong cùng một thanh ghi, nhưng khi truy cập thì ta sẽ chỉ định điều đó.
When you perform an operation, you need to specify whether you are looking at the lower half of the register values or upper half of the register values.
Khi thực hiện một phép toán, bạn cần chỉ rõ là đang xét nửa dưới của giá trị thanh ghi hay nửa trên của giá trị thanh ghi.
The register is 64, the data is still 64 bit. Yeah, Lucy.
Thanh ghi là 64, dữ liệu vẫn là 64 bit. Vâng, Lucy.
Yeah, that's a good, it's already a question for, a problem for, so the question is the immediate only 12 bits, right?
Vâng, câu hỏi hay đấy, đó đã là một vấn đề đối với câu hỏi là giá trị immediate chỉ có 12 bit, đúng không?
It's already a problem for 32 bit ISA, right? There are only so limited. We will actually talk about the U type instruction very likely, will be the upper immediate.
Đó đã là vấn đề với ISA 32 bit rồi, vì nó khá hạn chế. Rất có thể chúng ta sẽ nói về lệnh kiểu U, tức là immediate phần trên.
Exactly, right? On the 61C model, we will talk about the upper immediate. Memory is coming back. The upper immediate, that actually give us how we actually extend to actually get bigger range.
Đúng vậy. Trong môn 61C, chúng ta sẽ nói về immediate phần trên. Bộ nhớ sẽ quay lại. Immediate phần trên cho ta cách mở rộng để có dải giá trị lớn hơn.
So we need to consider all the different aspects here.
Vì vậy chúng ta cần cân nhắc tất cả các khía cạnh khác nhau ở đây.
Okay, so we start with the instruction. I like to add some discussion so that we can think about other things. One thing very important: register always 32. The number of registers always 32.
Được rồi, vậy ta bắt đầu với lệnh. Tôi muốn thêm một chút thảo luận để chúng ta nghĩ đến những vấn đề khác. Một điều rất quan trọng: thanh ghi luôn là 32. Số lượng thanh ghi luôn là 32.
The instructions, the instruction bit width is always 32. The only exception is actually 16 bit, but the majority of times always 32, right?
Với lệnh, độ rộng bit của lệnh luôn là 32. Ngoại lệ duy nhất là 16 bit, còn phần lớn thời gian luôn là 32, đúng không?
So keep that consistent, no matter what kind of extension that we're talking about. So again, get back to the basics. When we talk about the I type instruction, right?
Vậy hãy giữ điều đó nhất quán, bất kể ta đang nói đến loại phần mở rộng nào. Vậy ta quay lại những điều cơ bản. Khi nói về lệnh kiểu I, đúng không?
The basic one is basically still three addresses, right? We only need one source register. We don't need two source registers anymore. Only one source register. Another source operand is actually immediate, basically a constant.
Lệnh cơ bản về căn bản vẫn có ba địa chỉ, đúng không? Ta chỉ cần một thanh ghi nguồn. Ta không cần hai thanh ghi nguồn nữa. Chỉ một thanh ghi nguồn. Toán hạng nguồn còn lại là immediate, về cơ bản là một hằng số.
And then we perform the arithmetic operation, and then we get back to our destination register, right? So RD is still the same place.
Sau đó ta thực hiện phép toán số học, rồi ghi kết quả vào thanh ghi đích, đúng không? Vậy RD vẫn ở cùng một vị trí.
So we can actually use the same decoding logic to decode it. But then the immediate is stored using the upper 12 bits. Now we get to, again, so far it's still spec, right?
Nên ta có thể dùng cùng một logic giải mã để giải mã nó. Nhưng immediate được lưu bằng 12 bit trên. Bây giờ, cho đến đây vẫn mới là đặc tả, đúng không?
Now we get to an example implementation in this class. So this is our 151A datapath, right? So majority of the components stay the same.
Giờ ta chuyển sang một ví dụ triển khai trong lớp này. Đây là datapath 151A của chúng ta. Vậy là phần lớn các thành phần vẫn giữ nguyên.
We still need to implement the PC. We still need to read the instruction, decode the instruction and perform operation.
Chúng ta vẫn cần hiện thực PC. Vẫn cần đọc lệnh, giải mã lệnh và thực hiện phép toán.
What has changed is that one of the source, one of the inputs, one of the source operands to ALU is not register anymore, right? There's actually a constant coming in, right?
Điều thay đổi là một trong các nguồn, một trong các đầu vào, một trong các toán hạng nguồn của ALU không còn là thanh ghi nữa, đúng không? Thực ra có một hằng số đi vào, đúng không?
We discussed a very important datapath building block is multiplexer, right? Whenever we have multiple options, we add a multiplexer, we add a MUX there so that we can actually do selection.
Chúng ta đã thảo luận một khối xây dựng rất quan trọng của datapath là bộ dồn kênh, đúng không? Bất cứ khi nào có nhiều lựa chọn, chúng ta thêm một bộ dồn kênh, thêm một MUX ở đó để có thể thực hiện việc chọn.
We'll see this pattern multiple times while we're going through the datapath, right?
Chúng ta sẽ thấy mẫu này nhiều lần khi đi qua datapath, đúng không?
So here we basically need to have an option so that we can select, depends on the instruction type, we either select the register or select the immediate, right?
Ở đây về cơ bản cần có một lựa chọn để có thể chọn, tùy vào loại lệnh, hoặc chọn thanh ghi hoặc chọn giá trị tức thời, đúng không?
So in this scenario, we add a multiplexer here. We add a multiplexer here so that we can actually do B select. So basically this is source A, source B, right? B operands.
Vì vậy trong trường hợp này, ta thêm một bộ dồn kênh ở đây. Ta thêm một bộ dồn kênh ở đây để có thể thực hiện B select. Đây là nguồn A, nguồn B, đúng không? Các toán hạng B.
We do the B select to determine whether it is actually from register or from the immediate logic, right? So here we just have a wire labeled it as 32-bit immediate, right?
Ta dùng B select để xác định nó đến từ thanh ghi hay từ logic tạo giá trị tức thời, đúng không? Ở đây ta chỉ có một dây được gán nhãn là giá trị tức thời 32 bit, đúng không?
But we mentioned that this immediate is actually from the instruction, right? It's part of the instruction.
Nhưng chúng ta đã nói rằng giá trị tức thời này thực ra đến từ lệnh, đúng không? Nó là một phần của lệnh.
Then we extend it to be originally a 12-bit value, extend it to be a 32-bit value so that we can actually perform operation, right?
Sau đó ta mở rộng nó, ban đầu là giá trị 12 bit, thành giá trị 32 bit để có thể thực hiện phép toán, đúng không?
So one of the, also the most important logics in the design is the immediate generation. The input is basically part of the instruction, Right? We read the instruction in, and then we select.
Vì vậy, một trong những logic quan trọng nhất trong thiết kế cũng là phần tạo giá trị tức thời. Đầu vào về cơ bản là một phần của lệnh, đúng không? Ta đọc lệnh vào, rồi sau đó chọn.
We'll also talk about later, there are actually different ways of organizing the immediate based on different instruction formats. So far it's really just one for I type instruction, but there will be others, right?
Sau này chúng ta cũng sẽ nói về việc có nhiều cách khác nhau để tổ chức giá trị tức thời tùy theo các định dạng lệnh khác nhau. Cho đến giờ thực sự chỉ có một cách cho lệnh kiểu I, nhưng sẽ còn những cách khác, đúng không?
So we do the immediate select, how we like to actually extend to generate the immediate, and then we feed it to this B select MUX, right?
Vì vậy ta thực hiện chọn giá trị tức thời, tức là chọn cách mở rộng để tạo ra giá trị tức thời, rồi đưa nó vào MUX B select này, đúng không?
So that's basically how we actually will implement I type instruction to our datapaths. Again, this is a specific implementation.
Đó về cơ bản là cách chúng ta sẽ hiện thực lệnh kiểu I vào datapath. Một lần nữa, đây là một cách hiện thực cụ thể.
We add a MUX here to do the selection, and then we add this immediate generation logic to actually generate the immediate. Edison?
Ta thêm một MUX ở đây để thực hiện việc chọn, rồi thêm logic tạo giá trị tức thời này để sinh ra giá trị tức thời. Edison?
Yeah, I was just wondering if it would be a hazard because we need a narrow cycle to write the data type.
Vâng, em chỉ thắc mắc liệu đó có phải là một hazard không vì chúng ta cần một chu kỳ hẹp để ghi kiểu dữ liệu.
Let's say we have a pad A0, 1, or 2, and another pad A5, A4, A0. So in the implementation logic, it's pretty long.
Giả sử ta có một lệnh pad A0, 1, hoặc 2, và một lệnh pad khác A5, A4, A0. Vậy trong logic hiện thực thì nó khá dài.
It only changes like right before the next slot. We have to put the A5 in. Right, so you're talking about two, let's say two instructions.
Nó chỉ thay đổi ngay trước ô tiếp theo. Chúng ta phải đưa A5 vào. Vâng, vậy là ta đang nói về hai lệnh, giả sử là hai lệnh.
I guess it can be either R type or I type. It doesn't matter, right?
Tôi nghĩ có thể là lệnh kiểu R hoặc kiểu I, không quan trọng, đúng không?
So basically the destination of the first instruction, let's say, is R5, and then R5 is also one of the source registers in the second instruction. So first we're talking about single cycle datapaths.
Về cơ bản, đích của lệnh đầu tiên, giả sử, là R5, và R5 cũng là một trong các thanh ghi nguồn của lệnh thứ hai. Đầu tiên ta nói về datapath đơn chu kỳ.
At this point, we're talking about pipelined datapaths.
Ở điểm này, ta nói về datapath có đường ống.
Right, so for a single cycle datapath, we will actually update the value of R5 at the end of the clock cycle, at the next rising edge of the clock cycle, right?
Vâng, với datapath đơn chu kỳ, ta sẽ cập nhật giá trị của R5 vào cuối chu kỳ xung nhịp, tại sườn lên tiếp theo của xung nhịp, đúng không?
So you will actually, let's do this. Write the clock. So this is a clock.
Nào, ta làm thế này. Vẽ xung nhịp. Đây là một xung nhịp.
Right, so this is our clock signal. And then at the next rising edge of clock, you will look at the register R5 state. So before it is X, not initialized.
Vâng, đây là tín hiệu xung nhịp của ta. Và tại sườn lên tiếp theo của xung nhịp, bạn sẽ xem trạng thái của thanh ghi R5. Trước đó nó là X, chưa được khởi tạo.
R5 is actually, let's say it's set to 15, Actually, after the first clock, right?
R5 thì giả sử nó được đặt bằng 15, thực ra là sau xung nhịp đầu tiên, đúng không?
So then when we actually need to read, we start reading the PC out of the instruction memory after this clock. So we start with PC for the next instruction.
Vậy khi ta thực sự cần đọc, ta bắt đầu đọc PC ra khỏi bộ nhớ lệnh sau xung nhịp này. Vậy ta bắt đầu với PC cho lệnh tiếp theo.
It takes latencies to actually go through, read the instruction memory, go through the decoding, and then to start actually reading the source register.
Cần có độ trễ để đi qua, đọc bộ nhớ lệnh, đi qua giải mã, rồi mới bắt đầu đọc thanh ghi nguồn.
So with this combinational latency that generally will happen, we actually only read the values of RS1, some latency, with some combinational latency, after the R5 is actually written.
Với độ trễ tổ hợp thường xảy ra này, ta thực ra chỉ đọc giá trị của RS1 sau một độ trễ, một độ trễ tổ hợp, kể từ khi R5 được ghi.
So it's not pipelined, and we perform write basically at the rising edge of the clock, which gives us enough time to actually get the read ready, because we still need to go through instruction fetch, decoding, which has fixed time.
Vậy nó không có đường ống, và ta thực hiện ghi tại sườn lên của xung nhịp, điều này cho ta đủ thời gian để việc đọc sẵn sàng, vì ta vẫn phải đi qua nạp lệnh và giải mã, vốn có thời gian cố định.
This will be a bigger problem when we actually talk about pipeline execution, but here, just because of all the different latency, the way things are organized, it's not a problem.
Đây sẽ là vấn đề lớn hơn khi ta nói về thực thi theo đường ống, nhưng ở đây, chỉ nhờ các độ trễ khác nhau đó, cách mọi thứ được tổ chức khiến nó không thành vấn đề.
Oh, the question is: how do we actually decide the BSEC?
À, câu hỏi là: làm sao ta quyết định BSEC?
Yeah, how do we decide the BSEC signal? Omer.
Vâng, làm sao ta quyết định tín hiệu BSEC? Omer.
Basically, when we decode the instruction from INEM, INEM also generates the control logic, and the INEM is going to tell the BSEC to be selected 0 or 1.
Về cơ bản, khi ta giải mã lệnh từ INEM, INEM cũng sinh ra logic điều khiển, và INEM sẽ báo cho BSEC được chọn là 0 hay 1.
Right, so as Omer said, the control logic sees the instruction, right? So the instruction has all the information. Which particular field the instruction is looking at to determine the BSEC? Omer.
Vâng, như Omer nói, logic điều khiển nhìn thấy lệnh, đúng không? Lệnh chứa toàn bộ thông tin. Logic nhìn vào trường nào của lệnh để xác định BSEC? Omer.
Here is the opcode. Remember the opcode we saw earlier?
Đây là opcode. Nhớ opcode ta thấy trước đó chứ?
Let's see. Well, I guess we don't have a... Take a look at the opcode.
Xem nào. À, tôi đoán là ta không có... Hãy xem opcode.
The opcode of all the R-type instructions, the opcode of all the I-type instructions, they are consistent, but they are different.
Opcode của tất cả các lệnh kiểu R, opcode của tất cả các lệnh kiểu I, chúng nhất quán với nhau, nhưng chúng khác nhau.
So for the BSEC, we basically compare the opcode field then to see how the decision... The decision we need to make is basically whether it's an R-type or I-type instruction.
Vậy với BSEC, về cơ bản ta so sánh trường opcode rồi xem quyết định thế nào... Quyết định chúng ta cần đưa ra về cơ bản là đây có phải lệnh kiểu R hay lệnh kiểu I.
That determines the BSEC signal. Make sense? Ben? Ben, for BSEC where we only have five bits, we also need to look at the opcode of all three, right?
Điều đó xác định tín hiệu BSEC. Hiểu chưa? Ben? Ben, với BSEC, nơi chúng ta chỉ có năm bit, chúng ta cũng cần xem opcode của cả ba, đúng không?
We only have the five bits of the immediate. What do you mean, the five bits? Like the shift amount? Yeah, for shift left, five bits, and shift right, five bits.
Chúng ta chỉ có năm bit của giá trị tức thời. Ý bạn là năm bit nào? Như lượng dịch bit à? Vâng, với dịch trái là năm bit, và dịch phải cũng năm bit.
We only have the five bits of the immediate, and we would want to look at something like that extra one in shift right.
Chúng ta chỉ có năm bit của giá trị tức thời, và chúng ta sẽ muốn xem một bit bổ sung như thế ở lệnh dịch phải.
Oh, I see, I see. That's a... We don't need to look at all three. That's a good question, right? So we talk about we're changing two fields here, right? One is the BSEC.
À, tôi hiểu rồi. Đó là... Chúng ta không cần xem cả ba. Đó là một câu hỏi hay, đúng không? Vậy chúng ta đang thay đổi hai trường ở đây, đúng không? Một là BSEC.
The other is immediate generation, right? BSEC will be determined... Both are determined by the control logic, right?
Còn lại là tạo giá trị tức thời, đúng không? BSEC sẽ được xác định... Cả hai đều được xác định bởi logic điều khiển, đúng không?
A BSEC is purely based on the opcode because that's basically whether the operands from register or immediate. But how the immediate is generated, right?
BSEC hoàn toàn dựa trên opcode vì về cơ bản đó là việc toán hạng đến từ thanh ghi hay từ giá trị tức thời. Nhưng giá trị tức thời được tạo ra như thế nào, đúng không?
So this is how we actually control things, right? Whether the immediate is actually... Well, we'll see actually different immediate formats. They will actually always be consistent.
Đây chính là cách chúng ta thực sự điều khiển mọi thứ, đúng không? Việc giá trị tức thời thực sự là... Chúng ta sẽ thấy các định dạng giá trị tức thời khác nhau. Chúng sẽ luôn nhất quán.
But how the immediate is actually generated will basically change for the I-type instruction. So we go back to the I-type instruction.
Nhưng cách giá trị tức thời được tạo ra sẽ thay đổi đối với lệnh kiểu I. Vậy ta quay lại lệnh kiểu I.
Immediate generation for those scenarios, they basically will just grab the 12 bits and then sign extend. For the shift, you will see the funct3 field, and then they basically cut the five bits here.
Việc tạo giá trị tức thời trong những trường hợp đó, về cơ bản chỉ lấy 12 bit rồi mở rộng dấu. Với lệnh dịch, bạn sẽ thấy trường funct3, và sau đó họ cắt lấy năm bit ở đây.
So that actually happened... That design decision happened in the immediate generation instead of BSEC. So there are two blocks that we're changing. Some happening in the BSEC, some happening in the immediate generation.
Vậy điều đó thực sự xảy ra... Quyết định thiết kế đó nằm ở khối tạo giá trị tức thời chứ không phải BSEC. Vậy có hai khối mà chúng ta thay đổi. Một phần xảy ra ở BSEC, một phần ở khối tạo giá trị tức thời.
Good question. Okay, a lot of interesting things when we actually come to the ISA. Let's see. Okay, the animation, basically the path, right? Again, PC also needs to be updated.
Câu hỏi hay. Được rồi, có rất nhiều điều thú vị khi chúng ta đến với ISA. Xem nào. Được rồi, phần hoạt hình, về cơ bản là đường đi, đúng không? Một lần nữa, PC cũng cần được cập nhật.
One thing that's very easy to forget, to remember, is to update the PC. Okay, so that's basically our datapath that includes the immediate instruction.
Một điều rất dễ quên, cần nhớ, là cập nhật PC. Được rồi, đó là datapath của chúng ta, bao gồm cả lệnh có giá trị tức thời.
We actually already touched on some of the discussion earlier, right? So for the I immediate format instructions, Right?
Thực ra chúng ta đã đề cập một phần thảo luận này trước đó, đúng không? Vậy với các lệnh định dạng giá trị tức thời kiểu I, đúng không?
We basically grab the 12 bits and then we do sign extensions so that we can still get the 32-bit signal. This is just the one type of the immediate.
Chúng ta lấy 12 bit rồi thực hiện mở rộng dấu để vẫn có được tín hiệu 32 bit. Đây chỉ là một loại giá trị tức thời.
We'll actually see later, there are actually other types of immediate. We actually... Immediate generation is actually one of the most complex logic in this pipeline because there are so many different formats.
Sau này chúng ta sẽ thấy còn có các loại giá trị tức thời khác. Thực ra chúng ta... Tạo giá trị tức thời thực ra là một trong những logic phức tạp nhất trong đường ống này vì có rất nhiều định dạng khác nhau.
We actually need to do a lot of bit manipulation to combine different things together, right? So the immediate generation, we'll see all the different options that determine immediate select.
Chúng ta thực sự cần thực hiện nhiều thao tác bit để kết hợp các phần khác nhau lại với nhau, đúng không? Vậy là phần tạo giá trị tức thời (immediate generation), chúng ta sẽ thấy tất cả các lựa chọn khác nhau quyết định tín hiệu chọn immediate.
Also an important signal. Okay, so this is basically the datapath that we have for all the R type and also I type instructions.
Đây cũng là một tín hiệu quan trọng. Được rồi, về cơ bản đây là datapath mà chúng ta có cho tất cả các lệnh kiểu R và cả các lệnh kiểu I.
So far, our discussions are mostly centered around arithmetic or logical operations. There's actually another type of I type instruction that's actually related to memory operation.
Cho đến giờ, những gì chúng ta thảo luận chủ yếu xoay quanh các phép toán số học hoặc logic. Thực ra còn một loại lệnh kiểu I khác liên quan đến thao tác bộ nhớ.
That's basically our load instruction. So load instruction, we actually, there's no dedicated L type instruction, right? So load instruction is the same as I type instruction. It follows the exact same format, right?
Đó chính là lệnh load. Với lệnh load, thực ra không có một kiểu lệnh L riêng, đúng không? Lệnh load cũng chính là lệnh kiểu I. Nó theo đúng định dạng y hệt, đúng không?
So we think about load operation, right? So basically, read data from memory. In order to read data, we need to generate an address, right?
Vậy hãy nghĩ về thao tác load, đúng không? Về cơ bản là đọc dữ liệu từ bộ nhớ. Để đọc dữ liệu, chúng ta cần tạo ra một địa chỉ, đúng không?
To generate the address, we use a combination of source register, which sets the base of the address, and then we use immediate or constant to set the offset of the address.
Để tạo địa chỉ, chúng ta kết hợp một thanh ghi nguồn, thanh ghi này đặt cơ sở của địa chỉ, rồi dùng giá trị immediate hay hằng số để đặt độ lệch của địa chỉ.
And then performing a load operation, right? Once we get the address, we read memory and then we write data to the register file. So we still have a destination register.
Sau đó thực hiện thao tác load, đúng không? Khi đã có địa chỉ, chúng ta đọc bộ nhớ rồi ghi dữ liệu vào tệp thanh ghi. Vậy là vẫn có một thanh ghi đích.
So this, you look at this pattern, it's very similar. It's basically identical to the I type instruction. We have a destination register.
Bạn nhìn mẫu này, nó rất giống. Về cơ bản nó giống hệt lệnh kiểu I. Chúng ta có một thanh ghi đích.
We only need one source register and then we use the rest of your basically RS2 and func7 as our offset immediate, right?
Chúng ta chỉ cần một thanh ghi nguồn và dùng phần còn lại, tức là RS2 và func7, làm immediate độ lệch, đúng không?
So this is, the format is the same as the immediate, but now we are actually not calculating the result to update the, Or not calculating the result and directly updating the register.
Vậy định dạng này giống với lệnh immediate, nhưng bây giờ chúng ta không tính kết quả để cập nhật, hay đúng hơn là không tính kết quả rồi cập nhật trực tiếp vào thanh ghi.
We are actually creating an address and performing a memory operation, a memory read operation, to update the register.
Chúng ta thực sự tạo ra một địa chỉ và thực hiện một thao tác bộ nhớ, một thao tác đọc bộ nhớ, để cập nhật thanh ghi.
So we look at an example of the load instruction here.
Hãy xem một ví dụ về lệnh load ở đây.
So it has the same destination register, and then we combine our base and offset here to create the address that we want to index. So again, this is a spec, right?
Nó có cùng thanh ghi đích, và chúng ta kết hợp cơ sở và độ lệch ở đây để tạo ra địa chỉ mà chúng ta muốn truy cập. Một lần nữa, đây là đặc tả, đúng không?
Let's take a look at a particular implementation. What happens? You will actually include this another flavor of I type instruction into our datapath, right?
Hãy xem một cách triển khai cụ thể. Điều gì xảy ra? Chúng ta sẽ đưa thêm một dạng khác của lệnh kiểu I vào datapath, đúng không?
So one key thing we discussed earlier is that we are adding this memory. Like, we didn't see the memory operation before, right?
Một điểm then chốt đã nói trước đó là chúng ta thêm bộ nhớ này. Trước đây chúng ta chưa thấy thao tác bộ nhớ, đúng không?
We're adding this data memory here because now we actually need to read memory, right?
Chúng ta thêm bộ nhớ dữ liệu ở đây vì bây giờ chúng ta thực sự cần đọc bộ nhớ, đúng không?
Remember the context we set up earlier in our discussion, in the majority of our discussion on a specified where we have asynchronous read, right?
Hãy nhớ bối cảnh mà chúng ta đã thiết lập trước đó trong buổi thảo luận, trong phần lớn nội dung thảo luận về đặc tả, là chúng ta có đọc bất đồng bộ, đúng không?
So read doesn't need actually additional clock synchronized with clock; it is basically fully combinational: addressing, data out, right? Whenever we talk about memory operation, we need another control signal, right?
Vậy thao tác đọc thực ra không cần thêm xung clock đồng bộ với clock; về cơ bản nó hoàn toàn là tổ hợp: địa chỉ, dữ liệu ra, đúng không? Mỗi khi nói về thao tác bộ nhớ, ta cần thêm một tín hiệu điều khiển, đúng không?
Telling the memory whether we are performing a read or write. If it's a write, it's basically the write enable signal so we can actually perform the write, right?
Báo cho bộ nhớ biết ta đang thực hiện đọc hay ghi. Nếu là ghi, thì về cơ bản đó là tín hiệu write enable để ta thực sự thực hiện được việc ghi, đúng không?
And then whenever we're adding another choice, remember the muxes that we're adding, right?
Và mỗi khi ta thêm một lựa chọn khác, hãy nhớ các mux mà ta thêm vào, đúng không?
So we need a mux to decide whether the data that we are writing back to our register is that from the ALU operation or is that from the memory, right?
Vậy ta cần một mux để quyết định dữ liệu mà ta ghi ngược về thanh ghi là từ phép toán của ALU hay là từ bộ nhớ, đúng không?
So two things changed. One is we're adding this asynchronous read from data memory. We're adding another mux to decide which data we actually want to write back to the register, right?
Vậy có hai thay đổi. Một là ta thêm thao tác đọc bất đồng bộ từ bộ nhớ dữ liệu. Hai là ta thêm một mux nữa để quyết định dữ liệu nào thực sự được ghi ngược về thanh ghi, đúng không?
We look at how things are actually executed. Very similar: we read the PC, we decode the instruction, right? Control logic, we look at the instruction to set different control logic.
Ta xem các lệnh thực sự được thực thi như thế nào. Rất giống trước: ta đọc PC, giải mã lệnh, đúng không? Với logic điều khiển, ta xem lệnh để thiết lập các tín hiệu điều khiển khác nhau.
We get different subfields so that we can actually access the register, then generate the immediate. And then again, we always need to increment the PC. And then now this is I-type instruction.
Ta lấy các trường con khác nhau để có thể truy cập thanh ghi, rồi tạo ra giá trị immediate. Và một lần nữa, lúc nào ta cũng cần tăng PC. Còn đây là lệnh kiểu I.
So we use the first source register and the immediate. We calculate the address, right? So now we still use the ALU. The ALU result is not the final value.
Nên ta dùng thanh ghi nguồn thứ nhất và giá trị immediate. Ta tính địa chỉ, đúng không? Vậy ở đây ta vẫn dùng ALU. Kết quả của ALU không phải là giá trị cuối cùng.
It is calculating the address. And then we do a combinational read. We get the result data. We go through our muxes because now it's from memory instead of register.
Nó đang tính địa chỉ. Rồi ta thực hiện đọc tổ hợp. Ta nhận được dữ liệu kết quả. Ta đi qua các mux vì lúc này dữ liệu đến từ bộ nhớ chứ không phải từ thanh ghi.
And then we update our register, right? So everything is pretty consistent. This is another I-type instruction, but now we are actually perform memory operation.
Rồi ta cập nhật thanh ghi, đúng không? Vậy mọi thứ khá nhất quán. Đây là một lệnh kiểu I khác, nhưng lúc này ta thực sự thực hiện thao tác bộ nhớ.
So let's take a look at some of the load instruction. Well, so far we only talk about load word, right? Basically loading 32-bit, right?
Ta hãy xem một số lệnh load. Cho đến giờ ta mới chỉ nói về load word, đúng không? Về cơ bản là nạp 32 bit, đúng không?
This is where we see basically how we actually use Func3 to actually specify different style, different types of load operation, right?
Ở đây ta thấy cách dùng Func3 để chỉ định các kiểu, các loại thao tác load khác nhau, đúng không?
We can load the entire word, which is 32-bit, and we can also load half word. H, L-H, half word is basically two bytes and loads two bytes from the system.
Ta có thể nạp cả word, tức 32 bit, và cũng có thể nạp half word. H, L-H, half word về cơ bản là hai byte và nạp hai byte từ hệ thống.
We can also load byte from the system, right? So we basically just specify the address that we want to read from, and only load the specific amount from system, from our memory system, right?
Ta cũng có thể nạp một byte từ hệ thống, đúng không? Vậy ta chỉ cần chỉ định địa chỉ muốn đọc, và chỉ nạp đúng lượng dữ liệu cụ thể từ hệ thống, từ hệ thống bộ nhớ của ta, đúng không?
So the other, so let's say we only need 16-bit for half word, right? And then we basically, again, we assign extent.
Còn nữa, giả sử ta chỉ cần 16 bit cho half word, đúng không? Và rồi, một lần nữa, ta thực hiện mở rộng dấu.
The rest of the results after memory is still 32-bit, but the only value we have to use from memory is a specific either 8-bit or 16-bit. So this is another type, another I-type instruction.
Phần kết quả còn lại sau bộ nhớ vẫn là 32 bit, nhưng giá trị duy nhất ta phải dùng từ bộ nhớ là một phần cụ thể, 8 bit hoặc 16 bit. Đây là một loại khác, một lệnh kiểu I khác.
The instruction formats are identical, organized identically. Similar, it's also a part of I-type instruction, but they are doing memory operation.
Các định dạng lệnh giống hệt nhau, được tổ chức giống hệt nhau. Tương tự, nó cũng là một phần của lệnh kiểu I, nhưng chúng thực hiện thao tác bộ nhớ.
Any questions? Okay, a lot of instructions already, right? Again, we're going through this pretty quickly. I always go back to the spec.
Có câu hỏi nào không? Được rồi, đã có khá nhiều lệnh rồi nhỉ? Một lần nữa, chúng ta đang đi qua khá nhanh. Tôi luôn quay lại xem tài liệu đặc tả.
I like to also take a look at spec to see the specific definition and for different things. That's always very useful, Especially when you get to the project part.
Tôi cũng thích xem đặc tả để biết định nghĩa cụ thể cho từng thứ khác nhau. Điều đó luôn rất hữu ích, đặc biệt là khi các bạn làm đến phần đồ án.
Some announcement. First, we extend the Lab 3 deadline by one more week. I understand Lab 3 is very challenging.
Một vài thông báo. Đầu tiên, chúng tôi gia hạn hạn nộp Lab 3 thêm một tuần. Tôi hiểu Lab 3 rất khó.
I know all of you, we just had our staff meeting, a very long staff meeting yesterday. I know all of you are making very good progress.
Tôi biết tất cả các bạn, chúng tôi vừa họp nhóm giảng viên, một buổi họp rất dài hôm qua. Tôi biết tất cả các bạn đang tiến bộ rất tốt.
After teaching this class a couple of times, I would say this class is challenging in different ways, but Lab 3, basically, we only have six labs, right?
Sau khi dạy môn này vài lần, tôi có thể nói môn này khó theo nhiều cách khác nhau, nhưng Lab 3, về cơ bản, chúng ta chỉ có sáu lab, đúng không?
So Lab 3 is basically half of the lab.
Vậy Lab 3 về cơ bản là một nửa số lab.
It's basically the steepest ramp up because we have to do a lot of things and all of a sudden, you actually need to, not necessarily master the language, but you basically need to understand the language, how to design, and also how to test to design a fairly complex logic, right?
Về cơ bản đây là đoạn dốc đứng nhất vì chúng ta phải làm rất nhiều thứ và đột nhiên các bạn thực sự cần phải, không nhất thiết thành thạo ngôn ngữ, nhưng về cơ bản phải hiểu ngôn ngữ đó, cách thiết kế, và cả cách kiểm thử để thiết kế một mạch logic khá phức tạp, đúng không?
So generally, Lab 3, it takes a lot of time to do Lab 3.
Nên nói chung, Lab 3 tốn rất nhiều thời gian.
I wouldn't say the later labs or the project is easier in some sense, but it's just more challenging in different dimensions. It's not in terms of, actually, you still need to learn the language.
Tôi không nói các lab sau hay đồ án dễ hơn theo nghĩa nào đó, mà chỉ là chúng khó ở những khía cạnh khác. Không phải về mặt ngôn ngữ, dù các bạn vẫn cần học ngôn ngữ.
It's more complex because you need to actually build in more complex architectures. So if Lab 3 is taking longer, it's fine. We want to give you enough time to catch up.
Nó phức tạp hơn vì các bạn thực sự cần xây dựng những kiến trúc phức tạp hơn. Vậy nếu Lab 3 mất nhiều thời gian hơn thì cũng không sao. Chúng tôi muốn cho các bạn đủ thời gian để theo kịp.
So we'll extend the deadline by one week. We also have, basically, 14 days of slip days, right? The reason we're doing that, it's pretty long.
Vì vậy chúng tôi sẽ gia hạn thêm một tuần. Chúng ta cũng có tổng cộng 14 ngày slip days, đúng không? Lý do chúng tôi làm vậy, nó khá dài.
The reason we're doing that is just it always makes sense to catch up. You'll fall behind a little bit. It's not a big deal.
Lý do là việc theo kịp luôn là điều hợp lý. Các bạn có thể chậm một chút. Không sao đâu.
Making sure you still go through the labs, work on your own, come to the office hours, come to the lab to catch up.
Hãy đảm bảo các bạn vẫn làm các lab, tự làm, đến giờ hỗ trợ, đến phòng lab để theo kịp.
That's very important because all those labs are very fundamental, especially when you get to the project. So don't fall behind.
Điều đó rất quan trọng vì tất cả các lab này đều rất nền tảng, đặc biệt khi các bạn làm đến đồ án. Vì vậy đừng để bị tụt lại.
We extend the deadline by one week so you have a little bit more time for Lab 3. Do finish Lab 3. If it's hard, it seems challenging. It is challenging for everyone.
Chúng tôi gia hạn thêm một tuần để các bạn có thêm chút thời gian cho Lab 3. Hãy hoàn thành Lab 3. Nếu nó khó, có vẻ thử thách. Nó khó với tất cả mọi người.
And for folks who finish Lab 3, we will also introduce a new lab this week. So Lab 4 will also be introduced this week.
Và với những bạn đã xong Lab 3, tuần này chúng tôi cũng sẽ giới thiệu một lab mới. Vậy Lab 4 cũng sẽ được giới thiệu trong tuần này.
And starting from Lab 4, Lab 4 to Lab 6, each of the labs will be a two-week lab. And we only introduce a new lab every other week, right?
Và từ Lab 4 đến Lab 6, mỗi lab sẽ kéo dài hai tuần. Và chúng tôi chỉ giới thiệu lab mới cách tuần một lần, đúng không?
So basically, you have a full two weeks to actually work on each of the labs, right? So we will slow down a little bit, but this is basically, again, don't fall behind, right?
Vậy về cơ bản, các bạn có đủ hai tuần để làm mỗi lab, đúng không? Vì vậy chúng ta sẽ chậm lại một chút, nhưng một lần nữa, đừng để bị tụt lại nhé.
This class is challenging in the sense that we need to cover a lot of things, learn a lot of things in a very short amount of time, but we structure this way so that everyone can make progress and then can actually understand the different components inside out, right?
Môn này khó ở chỗ chúng ta cần bao quát rất nhiều thứ, học rất nhiều thứ trong một khoảng thời gian rất ngắn, nhưng chúng tôi xây dựng như vậy để mọi người đều có thể tiến bộ và thực sự hiểu thấu đáo từng thành phần bên trong, đúng không?
So don't fall behind. Keep working on Lab 3 if you haven't. And for folks who have already finished Lab 3, start Lab 4, right?
Vì vậy đừng để bị tụt lại. Hãy tiếp tục làm Lab 3 nếu các em chưa xong. Còn những bạn đã xong Lab 3 rồi thì bắt đầu Lab 4 nhé.
We'll slow down things a little bit to make sure everyone is on track.
Chúng tôi sẽ chậm lại một chút để đảm bảo mọi người theo kịp.
So we'll do a two-week lab moving forward, but making sure that you're making progress, and reach out to staff, to other students for support if you need, right?
Vì vậy từ giờ mỗi lab sẽ kéo dài hai tuần, nhưng các em phải đảm bảo là mình đang tiến bộ, và hãy tìm đến đội ngũ giảng dạy, hoặc các bạn khác để được hỗ trợ nếu cần nhé.
We may want to make sure everyone is making progress. Thank you, ma'am. You're welcome. Your success is my success, right?
Chúng tôi muốn đảm bảo mọi người đều tiến bộ. Em cảm ơn cô. Không có gì. Thành công của các em cũng là thành công của cô, đúng không?
So all we are doing is, what we are doing, the entire teaching staff here, is we want to help you learn, help you making progress, right? So that's also related.
Tất cả những gì chúng tôi làm, toàn bộ đội ngũ giảng dạy ở đây, là muốn giúp các em học tốt và tiến bộ, đúng không? Nên điều đó cũng liên quan.
The second thing I want to talk about: this class is also different. We have a lot of interactions. I interact with all of you here in lectures, during lectures, either in person or virtually.
Điều thứ hai tôi muốn nói: lớp này cũng khác biệt. Chúng ta có rất nhiều tương tác. Tôi tương tác với tất cả các em ở đây trong các buổi giảng, trong giờ giảng, dù trực tiếp hay trực tuyến.
You also interact with your fellow students, the teaching staff in labs and office hour. We have a lot of interaction. That's what I really like about hardware, right?
Các em cũng tương tác với các bạn cùng lớp, với đội ngũ giảng dạy trong lab và giờ hỏi đáp. Chúng ta có rất nhiều tương tác. Đó là điều tôi thực sự thích ở phần cứng.
It's not only just about the concept per se. I really am working with lots of different people and making progress.
Nó không chỉ là bản thân các khái niệm. Tôi thực sự làm việc với rất nhiều người khác nhau và cùng tiến bộ.
So we want to create a safe and respectful learning experience for everyone, for all the teaching staff and for all the students, right?
Vì vậy chúng tôi muốn tạo ra một trải nghiệm học tập an toàn và tôn trọng cho mọi người, cho toàn bộ đội ngũ giảng dạy và tất cả sinh viên.
Making sure you feel safe and comfortable coming to lab, either virtually or in person. You feel comfortable talking to different teaching staff, talking to other fellow students, talking to the instructor, right?
Đảm bảo các em cảm thấy an toàn và thoải mái khi đến lab, dù trực tuyến hay trực tiếp. Các em thấy thoải mái khi trao đổi với các thành viên đội ngũ giảng dạy, với các bạn khác, với giảng viên, đúng không?
All of this is very important. If you don't feel that way, right?
Tất cả những điều này rất quan trọng. Nếu các em không cảm thấy như vậy thì sao?
If you feel there are other things that actually you feel hurtful or that actually make it harder to actually make progress in your learning experience, let me know, right?
Nếu các em thấy có điều gì khác khiến mình bị tổn thương hoặc khiến việc tiến bộ trong quá trình học trở nên khó khăn hơn, hãy cho tôi biết nhé.
We want to help you. We want to improve the class. We want to fix the issues, right? Generally, again, lab is very challenging. Keep working on that.
Chúng tôi muốn giúp các em. Chúng tôi muốn cải thiện lớp học. Chúng tôi muốn khắc phục các vấn đề đó. Nhìn chung, lab rất thử thách. Hãy tiếp tục làm.
Keep making progress. Things will getting better, right?
Hãy tiếp tục tiến bộ. Mọi thứ sẽ tốt hơn.
We'll also slow down a little bit, but let's make sure we have a safe and respectful learning experience so that everyone is comfortable coming to the lectures, coming to the labs, coming to the office hours, right?
Chúng ta cũng sẽ chậm lại một chút, nhưng hãy đảm bảo có một trải nghiệm học tập an toàn và tôn trọng để mọi người đều thoải mái đến các buổi giảng, đến các buổi lab, đến giờ hỏi đáp, đúng không?
If anything that you feel, you don't feel that way, let me know so that we can improve, mm-hmm. Okay, any questions on the logistic front?
Nếu có điều gì khiến các em không cảm thấy như vậy, hãy cho tôi biết để chúng ta cải thiện nhé, ừm. Được rồi, có câu hỏi nào về phần tổ chức lớp không?
Okay, so far, so good. We'll catch up again next week, see where we are. Okay, well, let us know how things are going.
Được rồi, đến giờ vẫn ổn. Tuần sau chúng ta sẽ xem lại tiến độ. Được rồi, hãy cho chúng tôi biết mọi việc đang diễn ra thế nào.
Okay, so we covered a range of different instructions. We get to memory, right? We say I type.
Vậy là chúng ta đã đi qua nhiều loại lệnh khác nhau. Giờ đến bộ nhớ. Chúng ta nói đến loại I.
We actually don't need a load L type instruction because load is actually the same as I type, same as immediate. We do need a new instruction format for store.
Thực ra chúng ta không cần một lệnh loại L cho load vì lệnh load thực ra giống với I type, giống với lệnh immediate. Chúng ta cần một định dạng lệnh mới cho store.
There's like another type of memory operation, right? So we do have the S format. That's for store operation, right?
Đây là một loại thao tác bộ nhớ khác, đúng không? Vì vậy chúng ta có định dạng S. Đó là cho thao tác store, đúng không?
Again, when we come to a store operation, we actually still need two source operands, right? We need a register to actually create the address for the memory access, right?
Một lần nữa, khi nói đến thao tác store, chúng ta vẫn cần hai toán hạng nguồn, đúng không? Chúng ta cần một thanh ghi để tạo ra địa chỉ truy cập bộ nhớ, đúng không?
This is consistent with the load instruction. We actually need another source operand to actually specify which value that we want to store to memory, right?
Điều này nhất quán với lệnh load. Chúng ta còn cần một toán hạng nguồn nữa để chỉ rõ giá trị nào mà chúng ta muốn lưu vào bộ nhớ, đúng không?
So we actually need two source registers, RS1 to create the base address, RS2 so that we can actually read the value from the register.
Vậy chúng ta cần hai thanh ghi nguồn, RS1 để tạo địa chỉ cơ sở, RS2 để chúng ta có thể đọc giá trị từ thanh ghi.
We actually don't need a destination register because the state we are changing is actually a memory, right? We are not changing the register. We talk about, again, finite state machine, right?
Chúng ta không cần thanh ghi đích vì trạng thái mà chúng ta thay đổi thực ra là bộ nhớ, đúng không? Chúng ta không thay đổi thanh ghi. Nhớ lại máy trạng thái hữu hạn, đúng không?
We're always changing the PC counter. Sometimes we are changing the register state so we need the destination register, but sometimes we're actually changing the memory state, which is the case for the S format.
Chúng ta luôn thay đổi bộ đếm chương trình PC. Đôi khi chúng ta thay đổi trạng thái thanh ghi nên cần thanh ghi đích, nhưng đôi khi chúng ta lại thay đổi trạng thái bộ nhớ, đó là trường hợp của định dạng S.
So we actually update the memory state. So in that case, we actually don't need a destination register, right? So that's something different.
Vậy chúng ta cập nhật trạng thái bộ nhớ. Trong trường hợp đó, chúng ta không cần thanh ghi đích, đúng không? Đây là điểm khác biệt.
So for the immediate I type instruction, we only need one source register and one destination register. We don't need the second source register.
Với lệnh I type dùng immediate, chúng ta chỉ cần một thanh ghi nguồn và một thanh ghi đích. Chúng ta không cần thanh ghi nguồn thứ hai.
For the store format, we still need both source registers, but we don't need the destination register, right? So that has interesting implications in the way we think about instruction format, right?
Với định dạng store, chúng ta vẫn cần cả hai thanh ghi nguồn, nhưng không cần thanh ghi đích, đúng không? Điều này có những hệ quả thú vị đối với cách chúng ta nghĩ về định dạng lệnh, đúng không?
So we still have our opcode. Func3 stays the same. Source1 stays the same. Now we need to keep source2 because we still need the source2 register.
Vậy chúng ta vẫn có opcode. Func3 giữ nguyên. Source1 giữ nguyên. Giờ chúng ta cần giữ source2 vì vẫn cần thanh ghi source2.
And the rest of the fields can actually be used to actually capture the immediate, the constant, right?
Và các trường còn lại có thể được dùng để chứa immediate, tức là hằng số, đúng không?
So what we do here is that the old func7 field stays the same to capture the upper seven bits of the offset.
Vậy ở đây, trường func7 cũ vẫn giữ nguyên để chứa bảy bit cao của offset.
Instead of using RS2, which was used in I type instruction to cover the lower five bits of the immediate, we actually use the destination because now we don't need the destination register anymore.
Thay vì dùng RS2, vốn được dùng trong lệnh I type để chứa năm bit thấp của immediate, chúng ta dùng trường đích vì giờ chúng ta không cần thanh ghi đích nữa.
All right, this is a little bit awkward, especially if you actually manually assemble instructions, right? Now this immediate is actually, different parts of the immediate are separated in different parts of the instruction.
Được rồi, điều này hơi khó chịu một chút, nhất là nếu bạn dịch lệnh sang mã máy bằng tay, đúng không? Bây giờ immediate này thực ra, các phần khác nhau của immediate bị tách ra nằm ở những phần khác nhau của lệnh.
But this is actually more consistent with our instruction format, right? It's like register read is very important. We want to make sure register read happens as fast as possible.
Nhưng cách này nhất quán hơn với định dạng lệnh của chúng ta, đúng không? Việc đọc thanh ghi rất quan trọng. Chúng ta muốn đảm bảo việc đọc thanh ghi diễn ra nhanh nhất có thể.
You want to keep the same consistent format for all the register accesses. And then immediate generation, that can also be automated in hardware, right?
Bạn muốn giữ cùng một định dạng nhất quán cho mọi truy cập thanh ghi. Và phần tạo giá trị tức thời (immediate) cũng có thể được tự động hóa trong phần cứng, đúng không?
We just need to have different immediate generation logic to generate the immediate.
Chúng ta chỉ cần có logic tạo immediate khác để sinh ra giá trị immediate.
So we keep the formats largely the same, but we separate different parts of the immediate so that they are stored in the combination of func seven and the destination register.
Vậy nên chúng ta giữ các định dạng gần như giống nhau, nhưng tách các phần khác nhau của immediate ra để chúng được lưu trong sự kết hợp của trường func7 và thanh ghi đích.
So we keep those register fields the same, right? Register names are pretty important because we want to do the register read access. All right, so that's basically our store format.
Tức là ta giữ nguyên các trường thanh ghi, đúng không? Tên thanh ghi khá quan trọng vì chúng ta muốn thực hiện việc đọc thanh ghi. Được rồi, đó về cơ bản là định dạng lệnh store của chúng ta.
Very fairly consistent, but because the destination register disappeared, we store the lower half, lower five bits of the immediate into the destination register. So we look at an instruction example, right?
Khá nhất quán, nhưng vì thanh ghi đích đã biến mất, nên ta lưu nửa thấp, năm bit thấp của immediate vào trường thanh ghi đích. Hãy xem một ví dụ lệnh nhé.
So when we do actually a store instruction, again, we need both two, RS1 and RS2. We need two source registers. One is to actually set up the base and eight is offset.
Khi thực hiện một lệnh store, một lần nữa, chúng ta cần cả hai, RS1 và RS2. Chúng ta cần hai thanh ghi nguồn. Một thanh ghi để thiết lập cơ sở (base) và immediate là độ lệch (offset).
And the other is to set up the value that we want to read from the registers and we can actually perform the right operation.
Thanh ghi còn lại để thiết lập giá trị mà chúng ta muốn đọc từ các thanh ghi để có thể thực hiện thao tác ghi.
The key difference here is that we are actually doing a combination, to generate the immediate, we are actually combining instead of neighboring fields, we are actually combining two separate fields when we actually produce this design, this immediate in hardware.
Điểm khác biệt chính ở đây là chúng ta đang thực hiện một sự kết hợp, để tạo immediate, chúng ta kết hợp chứ không phải các trường liền kề, mà là hai trường riêng biệt khi chúng ta tạo ra thiết kế này, immediate này trong phần cứng.
So far is a spec, right? How the store instruction is specced. Now let's take a look at how we actually change our data paths, this particular implementation, Right?
Đến đây là phần đặc tả, đúng không? Lệnh store được đặc tả như thế nào. Bây giờ hãy xem chúng ta thay đổi đường dữ liệu như thế nào, trong cách triển khai cụ thể này.
So this is what we have seen before, right? We've already introduced the load operation, which adds the memory component, but so far we're basically only doing the memory read, right?
Đây là những gì chúng ta đã thấy trước đây. Chúng ta đã giới thiệu thao tác load, vốn thêm thành phần bộ nhớ, nhưng cho đến giờ về cơ bản chúng ta mới chỉ đọc bộ nhớ, đúng không?
With store, we are basically doing the memory write. So you are doing the memory write. A couple of things changed.
Với store, về cơ bản chúng ta đang ghi bộ nhớ. Tức là bạn đang ghi vào bộ nhớ. Có một vài thứ thay đổi.
When we actually control this signal, we also need to make sure we can actually control, specify the write.
Khi chúng ta điều khiển tín hiệu này, chúng ta cũng cần đảm bảo có thể điều khiển, chỉ định việc ghi.
I know we mentioned earlier, this is basically the write enable signal we talked about earlier in our abstract memory, right? So we'll only perform the write when the write enable signal is set.
Tôi biết lúc trước chúng ta đã nhắc đến, đây chính là tín hiệu cho phép ghi (write enable) mà chúng ta đã nói trước đó trong bộ nhớ trừu tượng, đúng không? Vì vậy chúng ta chỉ ghi khi tín hiệu write enable được đặt.
We have the same address interface that will actually specify which address we need. So we have the same way of calculating the address through the ALU.
Chúng ta có cùng giao diện địa chỉ để chỉ định địa chỉ nào mà chúng ta cần. Vậy chúng ta tính địa chỉ theo cùng cách thông qua ALU.
What's different here is that we also need to have a data write, right?
Điểm khác ở đây là chúng ta cũng cần có dữ liệu ghi, đúng không?
We need to have an input data to our memory, which is a value that we want to write to this particular address, right?
Chúng ta cần có một dữ liệu đầu vào cho bộ nhớ, là giá trị mà chúng ta muốn ghi vào địa chỉ cụ thể này, đúng không?
And this value, this is actually coming from the register file, right? We have two source registers. One is to specify the address, which is going through the ALU.
Và giá trị này đến từ tệp thanh ghi (register file), đúng không? Chúng ta có hai thanh ghi nguồn. Một thanh ghi dùng để xác định địa chỉ, và địa chỉ này đi qua ALU.
The second one actually specifies the value that we want to write to memory. So we have a direct path from the register, the output of the register file, to the memory.
Thanh ghi thứ hai xác định giá trị mà ta muốn ghi vào bộ nhớ. Vì vậy ta có một đường đi trực tiếp từ thanh ghi, tức là từ đầu ra của tệp thanh ghi, tới bộ nhớ.
So that's basically how I need to specify. Well, that's the first part, in the memory part, how we actually support the store operation. We also mentioned, right?
Về cơ bản đó là cách tôi cần xác định. Đó là phần đầu tiên, ở phần bộ nhớ, về cách ta thực sự hỗ trợ thao tác store. Ta cũng đã đề cập rồi, đúng không?
Immediate generation is also different because now we have a different pattern. We need to cut two different areas, two different fields, into the immediate.
Việc tạo giá trị immediate cũng khác, vì bây giờ ta có một dạng khác. Ta cần cắt hai vùng, hai trường khác nhau, để tạo thành immediate.
So instead of just the I type immediate, we also have this S type immediate. Well, it's still operating on the instructions, but they are picking different subfields to create the immediate, right?
Vì vậy, ngoài immediate kiểu I, ta còn có immediate kiểu S này. Nó vẫn thao tác trên các lệnh, nhưng chọn các trường con khác nhau để tạo ra immediate, đúng không?
So you will look at the path, the highlighted. Always remember to update the PC. That's always going on. So far, it just keeps incrementing, but then we basically read the value.
Các bạn hãy nhìn vào đường đi được tô sáng. Luôn nhớ cập nhật PC. Việc đó lúc nào cũng diễn ra. Cho đến giờ nó chỉ tiếp tục tăng, nhưng sau đó ta đọc giá trị.
Both registers are read, right? We actually have two source registers, but we don't need the destination register. One source register is used to create the address.
Cả hai thanh ghi đều được đọc, đúng không? Ta có hai thanh ghi nguồn, nhưng không cần thanh ghi đích. Một thanh ghi nguồn được dùng để tạo địa chỉ.
The other source register is used to actually create the value. And we have the immediate set up. Carol?
Thanh ghi nguồn còn lại được dùng để tạo giá trị. Và ta đã thiết lập xong immediate. Carol, em hỏi đi?
The memory unit copying from one address to another. What do you mean, copying from one address to another?
Đơn vị bộ nhớ sao chép từ địa chỉ này sang địa chỉ khác. Ý em là sao, sao chép từ địa chỉ này sang địa chỉ khác?
The memory unit copying from one address to another. I don't really quite understand what you mean. Oh, I see. I see what you're asking.
Đơn vị bộ nhớ sao chép từ địa chỉ này sang địa chỉ khác. Tôi chưa hiểu lắm ý em. À, tôi hiểu rồi. Tôi hiểu em đang hỏi gì.
So again, let's justify the memory operation we were talking about, right? So we're performing a store, right? So we're assigning some value to memory, right? So there are two parts.
Vậy ta hãy làm rõ lại thao tác bộ nhớ mà ta đang nói đến, đúng không? Ta đang thực hiện một lệnh store, đúng không? Tức là ta gán một giá trị nào đó cho bộ nhớ, đúng không? Vậy có hai phần.
One is the address of the memory access, and the other is the value that we are writing to, right? So the value is actually from register file. This is actually from RS2.
Một là địa chỉ của truy cập bộ nhớ, và hai là giá trị mà ta ghi vào đó, đúng không? Giá trị này thực ra đến từ tệp thanh ghi. Nó thực ra đến từ RS2.
So we are writing, we are reading from, so the read actually happens in the register file. We read the value from register file, and then we write that value to memory.
Vậy ta đang ghi, ta đang đọc từ nên việc đọc thực sự xảy ra ở tệp thanh ghi. Ta đọc giá trị từ tệp thanh ghi, rồi ghi giá trị đó vào bộ nhớ.
So we read from register file and to memory, and the register file index is specified by RS2, which is a register read.
Vậy ta đọc từ tệp thanh ghi và đưa tới bộ nhớ, và chỉ số thanh ghi trong tệp thanh ghi được xác định bởi RS2, đó là một lần đọc thanh ghi.
And when we are doing a write, we actually also need to calculate the address. We actually read the value of RS1 plus offset to calculate the address.
Và khi ghi, ta cũng cần tính địa chỉ. Ta đọc giá trị của RS1 cộng với offset để tính địa chỉ.
So you're right, we're doing a read and write, but we're reading from register file, writing to memory. So that's the operation we're doing with store.
Vậy em nói đúng, ta vừa đọc vừa ghi, nhưng ta đọc từ tệp thanh ghi và ghi vào bộ nhớ. Đó là thao tác ta thực hiện với lệnh store.
So we see the register file read and memory write. Okay, any other questions for the store?
Vậy ta thấy có đọc tệp thanh ghi và ghi bộ nhớ. Được rồi, còn câu hỏi nào khác về store không?
Do you have functionality to check that you're asking, or you're storing the value that you want to, or is it just like you come by the workstation?
Có chức năng nào để kiểm tra điều em đang hỏi không, hay là việc lưu giá trị mà em muốn, hay chỉ là kiểu em ghé qua máy trạm?
What do you mean? I'm like checking the value.
Ý em là sao? Em đang kiểm tra giá trị.
Like, I don't know, there's like a ton of tools based on GPU, And let's say one of the things is a value that I'm not sure of.
Kiểu như, em không rõ, có rất nhiều công cụ dựa trên GPU, Và giả sử có một giá trị mà em không chắc chắn.
But is there a way to make sure that it's still true that I found the value? Yeah, yeah, that's a good question, right?
Nhưng có cách nào để đảm bảo rằng giá trị mà em tìm được vẫn đúng không? Vâng, đó là một câu hỏi hay.
So how do we actually guarantee we're reading or writing the expected operation? Right, there are two aspects of this. First, let's assume every bit is encoded, stored correctly, right?
Vậy làm sao ta thực sự đảm bảo rằng mình đang đọc hoặc ghi đúng thao tác mong đợi? Có hai khía cạnh ở đây. Thứ nhất, giả sử mọi bit đều được mã hóa và lưu trữ đúng.
So there is some safeguard you can do to see whether this particular address is actually within reach. Let's say our memory only has four kilobytes, right?
Khi đó có một số biện pháp bảo vệ ta có thể làm để kiểm tra xem địa chỉ này có thực sự nằm trong phạm vi hay không. Giả sử bộ nhớ của ta chỉ có bốn kilobyte.
But then if your address is indexing something beyond four kilobytes, that's a clear error because we don't have that capacity, right? So that's one style of error.
Nhưng nếu địa chỉ của bạn trỏ tới vị trí vượt quá bốn kilobyte, thì đó rõ ràng là lỗi vì ta không có dung lượng đó. Đó là một kiểu lỗi.
The scenario that you talked about earlier is a different scenario. You're talking about, let's say, instructions are stored correctly, but somehow, let's say because of radiation, one of the bits actually got flipped, right?
Tình huống em nói lúc nãy là một tình huống khác. Em đang nói tới việc, giả sử, các lệnh được lưu đúng, nhưng bằng cách nào đó, chẳng hạn do bức xạ, một trong các bit bị lật.
That is very hard to check based on the current implementation, right? Because just the bit is flipped. It is what it is, right? But there's no way to check.
Điều đó rất khó kiểm tra với cách hiện thực hiện tại. Vì bit đã bị lật rồi thì nó là như vậy. Nhưng không có cách nào để kiểm tra.
People have been doing, like, for example, more resilience architecture or resilient design where they use different, for example, duplication logic. They actually have, let's say, two sets of register file, store the same thing.
Người ta đã làm, ví dụ, kiến trúc có khả năng chịu lỗi cao hơn hoặc thiết kế chịu lỗi, trong đó họ dùng, chẳng hạn, logic nhân bản. Họ có, giả sử, hai tập register file lưu cùng một dữ liệu.
And then they actually compare, let's say when we actually read data from RS2, whether the data actually still match so that they can get an early indication of whether there is an error, right?
Rồi họ so sánh, chẳng hạn khi ta đọc dữ liệu từ RS2, xem dữ liệu có còn khớp nhau không, để có thể sớm phát hiện dấu hiệu có lỗi hay không.
But if we're just looking at the single, the current design, if something actually flipped during the way, it is an error.
Nhưng nếu chỉ xét thiết kế đơn, thiết kế hiện tại, nếu có gì đó bị lật trên đường đi thì đó là lỗi.
It will lead to an error in the end. But that's actually very hard to catch. The radiation is actually one of the hardest challenges.
Cuối cùng nó sẽ dẫn đến lỗi. Nhưng điều đó rất khó phát hiện. Bức xạ là một trong những thách thức khó nhất.
So that's why the NASA machines actually have been using basically the same processor for decades, because they don't want to deal with this kind of challenges.
Đó là lý do các máy của NASA về cơ bản đã dùng cùng một bộ xử lý suốt nhiều thập kỷ, vì họ không muốn đối mặt với những thách thức kiểu này.
Okay, so let's, we'll talk about the store instruction. And I guess we are different, similar to the load. There are different patterns. We only, we can also do the sub word, right?
Được rồi, bây giờ ta sẽ nói về lệnh store. Tương tự như load, có nhiều dạng khác nhau.
So that we only store either byte or half the byte. And we also talk about immediate generation, right? So we have two different immediate formats.
Ta cũng có thể làm với sub word, tức là chỉ lưu một byte hoặc nửa word. Và ta cũng nói về việc sinh immediate. Ta có hai định dạng immediate khác nhau.
The higher bits, some bits are the same, but the lower five bits can either be from the old RS2 field or the new RD field. That's the two different immediate generations.
Các bit cao, một số bit là giống nhau, nhưng năm bit thấp có thể lấy từ trường RS2 cũ hoặc trường RD mới. Đó là hai cách sinh immediate khác nhau.
We'll also talk about other immediate generation in the next lecture. So in today's lecture, we finished three instruction types: R type, I type and the store type.
Ta cũng sẽ nói về các cách sinh immediate khác trong bài giảng sau. Vậy trong bài giảng hôm nay, ta đã xong ba loại lệnh: loại R, loại I và loại store.
We'll continue our discussion on branch, jump and the upper immediate in the next lecture. So good seeing you all and I'll see you this Thursday.
Ta sẽ tiếp tục thảo luận về lệnh rẽ nhánh, lệnh nhảy và upper immediate trong bài giảng sau. Hẹn gặp lại các em vào thứ Năm này.
Đă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.