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. Welcome to EE 151/251A, Introduction to Digital Design and Integrated Circuits.
Chào buổi sáng mọi người. Chào mừng các bạn đến với EE 151/251A, Nhập môn Thiết kế số và Mạch tích hợp.
So we're going to have our nice lecture of this semester, and in this lecture we'll wrap up our discussion on RISC-V instruction set architecture, ISAs, and also a particular implementation of the single cycle datapath.
Vậy là chúng ta sẽ có bài giảng đầu tiên thật hay của học kỳ này, và trong bài giảng này chúng ta sẽ kết thúc phần thảo luận về kiến trúc tập lệnh RISC-V, tức các ISA, và cả một cách hiện thực cụ thể của datapath một chu kỳ.
We'll also talk about the control logic that needs to be implemented to support different functionalities. So after this, we'll start the pipelining discussion.
Chúng ta cũng sẽ nói về logic điều khiển cần được hiện thực để hỗ trợ các chức năng khác nhau. Sau đó, chúng ta sẽ bắt đầu phần thảo luận về đường ống.
Next week, we'll cover different aspects of how we can actually make our CPU run even faster.
Tuần sau, chúng ta sẽ đề cập các khía cạnh khác nhau về việc làm thế nào để CPU của chúng ta chạy nhanh hơn nữa.
Well, since we're talking about different ISAs and also CPU microarchitecture, right, so, and especially NVIDIA just did their announcement yesterday on their new RTX 4000 generation, right, so this is Ada architecture right after Turing, right, the third generation RTX architecture.
À, vì chúng ta đang nói về các ISA khác nhau và cả vi kiến trúc CPU, đúng không, nên nhất là khi NVIDIA vừa có thông báo hôm qua về thế hệ RTX 4000 mới của họ, đúng không, đây là kiến trúc Ada, ngay sau Turing, tức là kiến trúc RTX thế hệ thứ ba.
So NVIDIA has been making a lot of interesting designs in the past couple years, especially the transition from Ampere, like two years ago, their GPU architecture, to the current Ada or Hopper, Ada architecture, right?
NVIDIA đã đưa ra rất nhiều thiết kế thú vị trong vài năm qua, đặc biệt là bước chuyển từ Ampere, cách đây khoảng hai năm, kiến trúc GPU của họ, sang Ada hay Hopper hiện nay, kiến trúc Ada, đúng không?
So with that, during this transition, not only are there advances on the GPU, there are also interesting developments on the CPU end.
Trong giai đoạn chuyển tiếp này, không chỉ có những tiến bộ về GPU, mà còn có những phát triển thú vị ở phía CPU.
So when we think about NVIDIA, we generally always think it's like, oh, GPU platform, GPU vendor, but they also have been actually designing their own CPU for the past decades.
Khi nghĩ đến NVIDIA, chúng ta thường luôn nghĩ rằng đó là nền tảng GPU, nhà cung cấp GPU, nhưng thực ra họ cũng đã tự thiết kế CPU của riêng mình trong nhiều thập kỷ qua.
One of the, this is actually not directly from this year's announcement, this has actually been announced last year, but there's like new advances, especially building up the HGX supercomputer.
Một trong số đó, cái này thực ra không trực tiếp nằm trong thông báo năm nay, mà đã được công bố từ năm ngoái, nhưng có những tiến bộ mới, nhất là trong việc xây dựng siêu máy tính HGX.
With that, it's interesting to actually talk about NVIDIA's Grace Hopper architecture. As the name suggests, we already talked about the Hopper GPU.
Vì vậy, sẽ rất thú vị nếu nói về kiến trúc Grace Hopper của NVIDIA. Đúng như tên gọi, chúng ta đã nói về GPU Hopper rồi.
This is actually a combined CPU plus GPU architecture. So Hopper is a GPU architecture, it was introduced last year.
Đây thực ra là một kiến trúc kết hợp CPU cộng GPU. Hopper là một kiến trúc GPU, được giới thiệu từ năm ngoái.
That's basically the next generation, especially after Ampere, that's the newest NVIDIA GPU architecture. On the CPU end, NVIDIA also introduced the Grace architecture.
Về cơ bản đó là thế hệ kế tiếp, nhất là sau Ampere, và là kiến trúc GPU mới nhất của NVIDIA. Ở phía CPU, NVIDIA cũng giới thiệu kiến trúc Grace.
So Grace is actually a CPU platform. They are basically, well, of course, NVIDIA has been using CPUs from Intel and AMD, if you look at the original DGX box, right?
Grace thực chất là một nền tảng CPU. Họ về cơ bản, tất nhiên rồi, NVIDIA vẫn dùng CPU của Intel và AMD, nếu bạn nhìn vào chiếc hộp DGX ban đầu, đúng không?
But at the same time, they are really interested in building up their ecosystem, especially tighter communication connections between CPU and the GPU.
Nhưng đồng thời, họ rất muốn xây dựng hệ sinh thái của riêng mình, đặc biệt là các kết nối giao tiếp chặt chẽ hơn giữa CPU và GPU.
One of the major bottlenecks for today's GPU architecture is access to larger memory, right? If you look at today's GPU architecture, generally, the bigger memory you have, the more expensive the product is.
Một trong những nút thắt lớn của kiến trúc GPU ngày nay là khả năng truy cập bộ nhớ lớn hơn, đúng không? Nếu nhìn vào kiến trúc GPU ngày nay, nói chung bộ nhớ càng lớn thì sản phẩm càng đắt.
So having fast access to large capacity of memory is very important. And to do that, it's very hard to be constrained by the PCIe interface that has been actually defined by the CPU vendors.
Vì vậy, truy cập nhanh vào bộ nhớ dung lượng lớn là rất quan trọng. Và để làm được điều đó, rất khó để bị giới hạn bởi giao diện PCIe vốn do các hãng sản xuất CPU định nghĩa.
So recently, NVIDIA has been basically pushing this NVLink interconnect. And on top of that, they can actually build their own CPU. So now they control the entire platform.
Vì vậy gần đây NVIDIA đã thúc đẩy mạnh kết nối NVLink này. Và trên nền đó, họ còn có thể tự xây dựng CPU của riêng mình. Như vậy bây giờ họ kiểm soát toàn bộ nền tảng.
And with NVLink that actually connects between the Grace CPU and the Hopper GPU, the Hopper GPU now actually has a lot larger access to the memory system of the CPU.
Và với NVLink kết nối giữa CPU Grace và GPU Hopper, GPU Hopper giờ đây có khả năng truy cập hệ thống bộ nhớ của CPU lớn hơn nhiều.
So now this is actually a great way to enable scalability and a tighter integration between CPU and GPU for future, I guess, this kind of super chip or supercomputing platform.
Đây là một cách rất tốt để tạo điều kiện cho khả năng mở rộng và sự tích hợp chặt chẽ hơn giữa CPU và GPU cho các nền tảng siêu chip hay siêu máy tính trong tương lai.
Again, this is really designed for machine learning. I mentioned earlier, memory capacity is very important for machine learning applications, high performance computing, the same constraint, right? Getting access to fast and the bigger memory.
Một lần nữa, thiết kế này thực sự dành cho học máy. Tôi đã nói ở trên rằng dung lượng bộ nhớ rất quan trọng đối với các ứng dụng học máy, điện toán hiệu năng cao cũng có cùng ràng buộc, đúng không? Đó là truy cập được bộ nhớ nhanh và lớn hơn.
So we see a lot of interesting development from even the traditional GPU vendors. They are really becoming system vendors where they are not only just designing one part of the IPs.
Vì vậy chúng ta thấy nhiều diễn biến thú vị, ngay cả từ các hãng GPU truyền thống. Họ đang thực sự trở thành các hãng cung cấp hệ thống, không chỉ thiết kế một phần của các IP.
They are actually trying to control the entire system by providing both CPU, GPU, and interconnect solution. Any guesses what I say the Grace CPU is using?
Họ đang cố kiểm soát toàn bộ hệ thống bằng cách cung cấp cả CPU, GPU và giải pháp kết nối. Các bạn đoán xem CPU Grace mà tôi nói dùng gì?
RISC, Ben?
RISC, Ben?
Why? Oh, okay. I see.
Sao vậy? À, được rồi. Tôi hiểu.
Oversight. Yes. So this is, I was expecting a couple of RISC-V answers, which could, NVIDIA, some of the microcontrollers in NVIDIA processor actually using RISC-V, I say, but this, yes.
Sơ suất thôi. Đúng. Tôi đã mong có vài câu trả lời là RISC-V, vì NVIDIA cũng có, một số vi điều khiển trong bộ xử lý của NVIDIA thực sự dùng RISC-V, nhưng ở đây thì không.
So this is an ARM ISA. We talked, I guess, a couple of weeks ago, NVIDIA actually tried to acquire ARM a couple of years ago, right?
Đây là một ISA ARM. Chúng ta đã nói cách đây vài tuần, NVIDIA đã thử mua lại ARM vài năm trước, đúng không?
That's actually part of this vision in building up this kind of heterogeneous IP block. Although that acquisition didn't work out, NVIDIA is actually heavily using the ARM ISA.
Đó là một phần của tầm nhìn xây dựng các khối IP không đồng nhất như thế này. Mặc dù thương vụ mua lại đó không thành, NVIDIA vẫn sử dụng ISA ARM rất nhiều.
So this is another example of actually the ARM-based CPU being adopted in NVIDIA's ecosystem. So it is a multi-core CPU architecture here.
Đây là một ví dụ nữa về việc CPU dựa trên ARM được đưa vào hệ sinh thái của NVIDIA. Ở đây là kiến trúc CPU đa lõi.
Any guesses how many cores that this Grace GPU has?
Các bạn đoán xem CPU Grace này có bao nhiêu lõi?
A hand, a dozen, 64. Getting closer. Oh, that's too high.
Một chục, 64. Gần đúng hơn rồi. Ồ, cao quá.
There are 72 cores on this ARM-based CPU, which is pretty impressive.
CPU dựa trên ARM này có 72 lõi, khá ấn tượng.
Like 10 years ago when I interned at Intel, my internship project was actually working on Intel's Knights Corner HPC.
Khoảng 10 năm trước khi tôi thực tập tại Intel, dự án thực tập của tôi là làm việc trên Knights Corner HPC của Intel.
So it's basically one of the Intel's attempts to actually get into the GPU market. That platform, that was around 2012, right? That platform has 64 x86 cores. So that's supposed to be for HPC.
Đó là một trong những nỗ lực của Intel nhằm thâm nhập thị trường GPU. Nền tảng đó khoảng năm 2012, đúng không? Nền tảng đó có 64 lõi x86. Nó được dự định dành cho HPC.
And that's what I think Intel's internal code name is called a MIC, M-I-C, many core integrated computing platform, something along that.
Và tôi nghĩ tên mã nội bộ của Intel cho nó là MIC, M-I-C, viết tắt của many core integrated computing platform, đại loại như vậy.
So I guess 10 years ago, when we think about this 64 cores, there are a lot of cores there. They are really for this kind of HPC, like very special, like graphic style market.
Vậy nên cách đây khoảng 10 năm, khi nói đến 64 lõi này thì đó là rất nhiều lõi. Chúng thực sự dành cho mảng HPC, một thị trường rất đặc thù, theo kiểu đồ họa.
We do see this kind of many core platform is actually being adopted in a lot of this kind of more, I'll say machine learning, I guess HPC is still part of the target, but we see a lot.
Giờ chúng ta thấy loại nền tảng nhiều lõi này đang được áp dụng trong rất nhiều lĩnh vực như học máy, tôi nghĩ HPC vẫn là một phần mục tiêu, nhưng chúng ta thấy rất nhiều ứng dụng khác.
This is not only Intel can actually build this kind of many core platform. A lot of vendors can actually do this kind of many cores, heterogeneous cores, combined CPU and the GPU cores platform.
Không chỉ Intel mới có thể xây dựng loại nền tảng nhiều lõi này. Rất nhiều nhà cung cấp có thể làm được các nền tảng nhiều lõi, lõi không đồng nhất, kết hợp cả lõi CPU và lõi GPU.
So it's really interesting to see this kind of very scalable, large scale system actually coming also from industry. And we see this kind of consolidation in some sense, right?
Thật thú vị khi thấy những hệ thống quy mô lớn, có khả năng mở rộng cao như vậy cũng đến từ ngành công nghiệp. Và ở một khía cạnh nào đó, chúng ta thấy sự hợp nhất này, đúng không?
There's never a clear line, oh, you're a CPU vendor, you're a GPU vendor. Oh, I'm doing my memory stuff. Everyone is talking to each other. Everyone trying to get into a bigger market share.
Không bao giờ có ranh giới rõ ràng kiểu: bạn là nhà cung cấp CPU, bạn là nhà cung cấp GPU. Hay: tôi làm mảng bộ nhớ. Mọi người đều trao đổi với nhau. Ai cũng cố gắng giành thị phần lớn hơn.
So the style of Grace plus Hopper, Grace CPU plus Hopper GPU, is a very, very interesting and very cool development coming from industry and business.
Vì vậy kiểu Grace cộng Hopper, tức CPU Grace cộng GPU Hopper, là một bước phát triển rất thú vị và rất tuyệt vời đến từ ngành công nghiệp và kinh doanh.
Okay, well, a lot about interesting CPUs are being introduced. We'll also cover some of other different flavors of recent computing platforms being introduced by different, actually, semiconductor vendors.
Được rồi, có rất nhiều CPU thú vị đang được giới thiệu. Chúng ta cũng sẽ đề cập đến một số dạng khác của các nền tảng tính toán gần đây được giới thiệu bởi nhiều nhà cung cấp bán dẫn khác nhau.
It's really interesting to see a lot of innovation in this space. So this is ARM-based, as been mentioned, and as I listed on the slide.
Thật thú vị khi thấy nhiều đổi mới trong lĩnh vực này. Đây là nền tảng dựa trên ARM, như đã đề cập và như tôi liệt kê trên slide.
But now we're going to back to our RISC-V ISA, which is also very important and very popular. With that, let's get back to our lecture content.
Nhưng giờ chúng ta quay lại với ISA RISC-V, vốn cũng rất quan trọng và rất phổ biến. Vậy, chúng ta hãy quay lại nội dung bài giảng.
So this week is our RISC-V. We will talk about different RISC-V instructions, and also how we attribute data paths to support the execution of RISC-V instructions.
Tuần này chúng ta học về RISC-V. Chúng ta sẽ nói về các lệnh RISC-V khác nhau, và cả cách tổ chức đường dữ liệu để hỗ trợ việc thực thi các lệnh RISC-V.
So last lecture, we'll cover the first three types of instructions, R-type instruction, register-to-register operation, the most basic instruction type. We'll also talk about the immediate instruction type.
Trong bài giảng trước, chúng ta đã học ba loại lệnh đầu tiên, lệnh kiểu R, phép toán giữa các thanh ghi, loại lệnh cơ bản nhất. Chúng ta cũng đã nói về loại lệnh immediate.
Immediate is a way, I-type is to get the constant, right, to be immediately available so that we can process it. We can also mention the load instruction is actually a part of I-type.
Immediate, tức kiểu I, là cách để có hằng số, đúng không, sẵn có ngay lập tức để chúng ta xử lý. Chúng ta cũng đã nhắc rằng lệnh load thực ra là một phần của kiểu I.
Immediate-type instructions follow the same format.
Các lệnh kiểu immediate đều theo cùng một định dạng.
So we do need a different format for the store instruction, because store actually needs both of the two source operands, but it doesn't need the destination register ID, so it's a different type compared to I-type.
Chúng ta cần một định dạng khác cho lệnh store, vì store cần cả hai toán hạng nguồn, nhưng không cần ID thanh ghi đích, nên nó là một kiểu khác so với kiểu I.
In today's lecture, we're going to continue our discussion. We'll cover the other three, the branch, jump, and the upper immediate, the other three types of instructions.
Trong bài giảng hôm nay, chúng ta sẽ tiếp tục phần thảo luận này. Chúng ta sẽ học ba loại còn lại: lệnh rẽ nhánh, nhảy, và upper immediate, tức ba loại lệnh còn lại.
We'll also talk a little bit more about the control logic so that we can actually implement this, the different functionality, different instructions in our microarchitecture design. So, branch or B format, right?
Chúng ta cũng sẽ nói thêm một chút về logic điều khiển để có thể hiện thực hóa điều này, các chức năng khác nhau, các lệnh khác nhau trong thiết kế vi kiến trúc của chúng ta. Vậy, lệnh rẽ nhánh, hay định dạng B, nhỉ?
So this is basically a RISC-V specification in terms of supporting conditional branch, right? So as an example, we have a branch-equal instruction.
Về cơ bản đây là đặc tả RISC-V về việc hỗ trợ rẽ nhánh có điều kiện, đúng không? Ví dụ, ta có lệnh branch-equal.
Here, we basically compare two source operands, x1 and x2, to see whether they are equal, because we're doing a B-equal instruction, and then if they are, we actually jump to a label, right?
Ở đây, ta so sánh hai toán hạng nguồn, x1 và x2, xem chúng có bằng nhau không, vì ta đang thực hiện lệnh B-equal, và nếu bằng nhau thì ta nhảy tới một nhãn, đúng không?
So here, as we look at the instruction, we still need to read two registers, right, because we're comparing the value of the registers, but we are actually not updating the register file anymore, right, because we only read the values, and we are not really changing the state.
Vậy ở đây, khi nhìn vào lệnh, ta vẫn cần đọc hai thanh ghi, đúng không, vì ta đang so sánh giá trị của các thanh ghi, nhưng ta không còn cập nhật tệp thanh ghi nữa, đúng không, vì ta chỉ đọc các giá trị và không thực sự thay đổi trạng thái.
This is similar to store. We also discussed we're reading values from registers. One of the registers is used to calculate the address for store.
Điều này giống với lệnh store. Ta cũng đã bàn là ta đọc giá trị từ các thanh ghi. Một trong các thanh ghi được dùng để tính địa chỉ cho lệnh store.
The other value is actually used to get the value, right, but we're not modifying the state of the register. We're modifying the memory state with the store instruction.
Giá trị còn lại được dùng để lấy giá trị cần ghi, đúng không, nhưng ta không sửa đổi trạng thái của thanh ghi. Ta sửa đổi trạng thái bộ nhớ bằng lệnh store.
So for branch, while we're not writing to a register, which part of the state of our microarchitecture is actually updated by the branch instruction? Our program counter, right.
Vậy với lệnh rẽ nhánh, tuy ta không ghi vào thanh ghi, thì phần trạng thái nào của vi kiến trúc của ta thực sự được lệnh rẽ nhánh cập nhật? Bộ đếm chương trình, đúng không.
So I mentioned that for branch, PC is also another state in our finite state machine of our processor, right. So although we're not writing a register, we're actually writing the program counter.
Như tôi đã nói, với lệnh rẽ nhánh, PC cũng là một trạng thái khác trong máy trạng thái hữu hạn của bộ xử lý, đúng không. Vậy tuy ta không ghi vào thanh ghi, nhưng ta ghi vào bộ đếm chương trình.
So that's a state that we are updating, right. The question now is that, okay, we need to represent a label, basically another constant, right? Then it becomes an encoding question.
Đó là một trạng thái mà ta cập nhật, đúng không. Câu hỏi bây giờ là, ta cần biểu diễn một nhãn, về cơ bản cũng là một hằng số, đúng không? Khi đó nó trở thành một câu hỏi về mã hóa.
How do we actually encode this label effectively within our 32-bit instruction format?
Làm sao mã hóa nhãn này một cách hiệu quả trong định dạng lệnh 32 bit của ta?
So with that, let's take a look at our branch format, branch instruction format. There are some, like, it looks like, it looks very complicated, But let's do this step by step, right?
Vậy hãy xem định dạng lệnh rẽ nhánh của ta. Trông nó có vẻ rất phức tạp, nhưng ta hãy làm từng bước một, nhé?
We still see a lot of similarities compared to the instruction format that we have seen before, right? So we still have the 7-bit opcode. That doesn't change.
Ta vẫn thấy nhiều điểm tương đồng so với các định dạng lệnh mà ta đã thấy trước đây, đúng không? Ta vẫn có opcode 7 bit. Phần này không đổi.
We still have our func3 field so that we can actually separate different types of branch instruction. We'll get to that in a minute. We still have our two source registers, five bits each, right?
Ta vẫn có trường func3 để có thể phân biệt các loại lệnh rẽ nhánh khác nhau. Lát nữa ta sẽ nói tới. Ta vẫn có hai thanh ghi nguồn, mỗi thanh ghi năm bit, đúng không?
So all those, like, the three components, source registers, the func3 and opcode, they actually don't change.
Vậy cả ba thành phần này, các thanh ghi nguồn, func3 và opcode, đều không thay đổi.
What's actually being changed is basically how we encode our offset or the branch labels that we can actually get to our target.
Cái thay đổi là cách ta mã hóa độ dời hay các nhãn rẽ nhánh để có thể tới được đích.
This, which format of the instruction that we have covered looks actually pretty similar to this, where the three components don't change and the way we just encode the immediate different bit?
Định dạng lệnh nào mà ta đã học trông khá giống định dạng này, trong đó ba thành phần không đổi và cách chỉ là mã hóa giá trị tức thời theo cách khác thôi, đúng không?
Any instruction format we talk about look similar to this? Well, let me talk about three formats, right?
Có định dạng lệnh nào chúng ta đã nói trông giống cái này không? Để tôi nhắc đến ba định dạng nhé.
R-type, I-type, and S-type. Edison? S-type, right. So this is actually very similar to the S-type.
R-type, I-type, và S-type. Edison? S-type, đúng rồi. Vậy cái này thực ra rất giống S-type.
We still need two source registers. We don't need destination registers. And the rest of the bits, we dedicate all the rest of the bits for the immediate, right?
Chúng ta vẫn cần hai thanh ghi nguồn. Chúng ta không cần thanh ghi đích. Còn phần các bit còn lại, chúng ta dành toàn bộ cho giá trị tức thời, đúng không?
So this is basically the branch instruction format. The tricky part is really the immediate part. We also see a lot of different subfield is actually being encoded here.
Về cơ bản đây chính là định dạng lệnh rẽ nhánh. Phần khó thực sự là phần giá trị tức thời. Ở đây chúng ta cũng thấy rất nhiều trường con khác nhau được mã hóa.
So we'll talk a little bit more about how we actually separate or can cut different subfields to actually build our label.
Nên chúng ta sẽ nói thêm một chút về cách tách hoặc cắt các trường con khác nhau để tạo thành nhãn của mình.
So as we mentioned earlier, this is very similar to the S format, right? We have two source registers.
Như đã nói trước đó, cái này rất giống định dạng S, đúng không? Chúng ta có hai thanh ghi nguồn.
One thing you notice here is that if we look at the MSB, the highest bit here, right, we can actually represent 13-bit value with our branch format instead of 12-bit value that we used in our I-type instruction.
Một điều bạn để ý ở đây là nếu nhìn vào MSB, bit cao nhất ở đây, thì với định dạng rẽ nhánh, chúng ta có thể biểu diễn giá trị 13 bit thay vì giá trị 12 bit như trong lệnh I-type.
So with the 13-bit value, and it's signed, right, the first bit is signed. So we can basically cover positive, negative to the 12, the address range.
Với giá trị 13 bit có dấu, bit đầu tiên là bit dấu. Vậy chúng ta có thể bao phủ cả dương lẫn âm, đến 2^12, tức là dải địa chỉ.
So that's basically the address range that we can cover. Though we actually use 12-bit to actually cover the 13-bit, right. We only have 12-bit. That's basically what we have in the S-type or I-type.
Đó chính là dải địa chỉ mà chúng ta có thể bao phủ. Dù vậy, thực ra chúng ta dùng 12 bit để bao phủ 13 bit. Chúng ta chỉ có 12 bit. Đó là những gì có trong S-type hoặc I-type.
What we are trying to do is actually, the one thing is separate. What's interesting with branch is that we actually want to store 16-bit address, although we only have 12-bit actually available.
Điều chúng ta đang cố làm là, một điều là tách ra. Điều thú vị với lệnh rẽ nhánh là chúng ta muốn lưu địa chỉ 16 bit, mặc dù thực tế chỉ có sẵn 12 bit.
This may look a little bit confusing. We'll see an example in a minute when we actually look at the example of branch encoding.
Điều này có thể hơi khó hiểu. Chúng ta sẽ xem một ví dụ ngay sau đây khi xem ví dụ về mã hóa lệnh rẽ nhánh.
So again, our branch decode instruction, we have two registers and we have this offset, right.
Vậy lại nói về lệnh giải mã rẽ nhánh, chúng ta có hai thanh ghi và có giá trị offset này.
What we want to encode into our instruction is basically, we mentioned earlier, want to represent a 13-bit label or 13-bit immediate, which basically specifies the target of the job.
Điều chúng ta muốn mã hóa vào lệnh là, như đã nói, biểu diễn một nhãn 13 bit hay giá trị tức thời 13 bit, giá trị này xác định đích của lệnh nhảy.
While we only have actually 12-bit left, right, in our instruction format, right, we need to store our opcode.
Trong khi thực tế chúng ta chỉ còn 12 bit, đúng không, trong định dạng lệnh, vì cần lưu opcode.
Opcode is 7-bit, right, func3 is 3-bit, and two registers is 5 and 5, right. So 32-bit in total is a 10 plus 10, right. We only have 12-bit left.
Opcode là 7 bit, func3 là 3 bit, và hai thanh ghi là 5 và 5. Tổng cộng 32 bit, là 10 cộng 10. Chúng ta chỉ còn 12 bit.
So we basically want to use 12-bit to actually encode 13-bit value. The reason for that is basically we want to cover a bigger branch, right.
Vậy chúng ta muốn dùng 12 bit để mã hóa giá trị 13 bit. Lý do là chúng ta muốn bao phủ một khoảng rẽ nhánh lớn hơn.
We jump around, we want to actually jump like further, otherwise we actually need another instruction to actually get to a bigger range. So we want to cover more instructions.
Chúng ta nhảy đi, và muốn nhảy xa hơn, nếu không thì chúng ta cần thêm một lệnh khác để tới được một dải lớn hơn. Vì vậy chúng ta muốn bao phủ nhiều lệnh hơn.
One opportunity people leverage in this encoding is that when we do actually branch, right, when we do actually jump, we mentioned that we do a lot of PC equals to PC plus 4, right.
Một cơ hội mà người ta tận dụng trong cách mã hóa này là khi chúng ta rẽ nhánh, tức là khi chúng ta nhảy, như đã nói, chúng ta thường làm PC bằng PC cộng 4.
Every instruction is 32-bit, right. We actually don't need to jump to every byte. We can actually just jump to every 4-bit. We just do PC plus 4.
Mọi lệnh đều dài 32 bit, đúng không. Thực ra ta không cần nhảy tới từng byte. Ta chỉ cần nhảy tới từng 4 bit. Ta chỉ làm PC cộng 4.
With that, which means that we can't actually ignore the LSB, because it's basically only, we're not doing byte address, but we can omit some bits.
Như vậy nghĩa là ta thực ra không thể bỏ qua LSB, vì về cơ bản ta không dùng địa chỉ theo byte, nhưng ta có thể bỏ bớt một vài bit.
But if we are actually always doing PC plus 4, you may be wondering, we can actually jump, we can actually basically skip the last two bits, right, because we can actually do 4-byte increment.
Nhưng nếu ta luôn luôn làm PC cộng 4, các bạn có thể thắc mắc, ta có thể nhảy, ta có thể bỏ qua hai bit cuối, đúng không, vì ta có thể tăng theo bước 4 byte.
So why do we actually do only skip or only discard the last bit instead? Why don't we actually do 14-bit instead of 13-bit?
Vậy tại sao ta chỉ bỏ qua hay chỉ loại bỏ bit cuối cùng thôi? Tại sao ta không dùng 14 bit thay vì 13 bit?
Well, let me slow this down a little bit, right. We have 12-bit available in our instruction set, right. So in our part of, because 5 plus, like 10 plus 10, we have 12-bit left.
Để tôi nói chậm lại một chút. Ta có 12 bit khả dụng trong tập lệnh của mình. Trong phần này, vì 5 cộng, như 10 cộng 10, ta còn lại 12 bit.
We want to cover the branch, right. So we want to have a bigger range, and then what we notice is that we do a lot of PC is PC plus 4, right.
Ta muốn bao phủ lệnh rẽ nhánh. Vậy nên ta muốn có một phạm vi lớn hơn, và điều ta nhận thấy là ta thường xuyên làm PC bằng PC cộng 4.
We don't need byte addressable, which means that we could actually skip something, skip some addresses. If every time we just skip like 4-byte, we could actually encode 4-byte basically, 2-bit, right.
Ta không cần địa chỉ hóa theo byte, nghĩa là ta có thể bỏ qua một số địa chỉ. Nếu mỗi lần ta chỉ bỏ qua 4 byte, về cơ bản ta có thể mã hóa 4 byte bằng 2 bit.
We could actually encode 14-bit address, right. But in this encoding, we actually do 13-bit. We don't actually fully leverage this instruction property, right. Any reason for that? There was a hint over there.
Ta có thể mã hóa địa chỉ 14 bit. Nhưng trong cách mã hóa này, ta chỉ dùng 13 bit. Ta không tận dụng hết tính chất này của lệnh. Có lý do nào cho điều đó không? Có một gợi ý ở đằng kia.
Exactly, and your name is?
Chính xác, bạn tên là gì?
Okay, so as Junye mentioned, and we also hinted last lecture, right, most of the instructions are 32-bit, but there are actually 16-bit instruction.
Được rồi, như Junye đã nói, và bài giảng trước chúng ta cũng đã gợi ý, hầu hết các lệnh đều dài 32 bit, nhưng cũng có lệnh 16 bit.
I actually made a mistake last time. I call this embedded instruction extension. This is actually called compressed. So when you read the, I say it's actually the C extension of the E extension.
Lần trước tôi đã nhầm. Tôi gọi đây là phần mở rộng lệnh nhúng. Thực ra nó được gọi là compressed. Khi các bạn đọc, tôi nói nó là phần mở rộng C của phần mở rộng E.
So it's actually the compressed instruction that actually has 16-bit, right.
Vậy đó là lệnh nén, loại có độ dài 16 bit.
So with that, which basically means sometime instead of always doing PC plus 4, We may do PC plus 2, 2-byte, right, 16-bit instruction to actually handle those scenario.
Như vậy, nghĩa là đôi khi thay vì luôn làm PC cộng 4, ta có thể làm PC cộng 2, tức 2 byte, lệnh 16 bit để xử lý những trường hợp đó.
So to also support the compressed format, right, instead of fully leveraging this instruction address property to skip like 2-bit, we actually do something in the middle.
Vậy để hỗ trợ cả định dạng nén, thay vì tận dụng hết tính chất địa chỉ của lệnh để bỏ qua 2 bit, ta làm một giải pháp ở giữa.
We actually skip 1-bit, only the last bit so that we can also support the 16-bit instruction. Basically, we can do both PC plus 2 and PC plus 4.
Ta chỉ bỏ qua 1 bit, tức bit cuối cùng, để cũng có thể hỗ trợ lệnh 16 bit. Về cơ bản, ta có thể làm cả PC cộng 2 và PC cộng 4.
It's a little bit confusing because we want to do optimization, but we're not doing the optimization very aggressively. We basically stop somewhere in the middle, right. Any questions, Brian?
Điều này hơi khó hiểu vì ta muốn tối ưu hóa, nhưng ta không tối ưu hóa quá triệt để. Về cơ bản chúng ta dừng lại ở đâu đó giữa chừng, đúng không. Brian, em có câu hỏi gì không?
So, right, so like we're right now looking at the 32-bit, right, and you're saying this is for the 16-bit, like you said, so then for the 64-bit, then we can get rid of more, like the 33-bit.
Vậy, hiện giờ chúng ta đang xét trường hợp 32 bit, đúng không, và thầy nói cái này dành cho trường hợp 16 bit, như thầy vừa nói, vậy với 64 bit thì chúng ta có thể bỏ bớt nhiều hơn, như bit thứ 33 chẳng hạn?
Oh, that's a good question. Yeah, can we get rid of more for 64-bit? No, Ben is shaking his head. Why?
Ồ, câu hỏi hay đấy. Đúng, với 64 bit liệu có thể bỏ bớt nhiều hơn không? Không, Ben đang lắc đầu. Tại sao?
Yes, so between 32-bit and 64-bit, only the size, the bitwidth of each register is a 32-bit value.
Đúng rồi, giữa 32 bit và 64 bit, chỉ có kích thước, độ rộng bit của mỗi thanh ghi là khác nhau: giá trị 32 bit hay 64 bit.
We are doing 64-bit value, but instruction is always 32-bit. So instruction is always 32-bit.
Chúng ta xử lý giá trị 64 bit, nhưng lệnh thì luôn luôn là 32 bit. Vậy lệnh luôn luôn là 32 bit.
As I mentioned, the only exception is a 16-bit instruction compressed format that can be used for the embedded system, but this is, except for that, all the instructions are 32-bit.
Như thầy đã nói, ngoại lệ duy nhất là định dạng nén của lệnh 16 bit có thể dùng cho các hệ thống nhúng, nhưng ngoài trường hợp đó ra, tất cả các lệnh đều là 32 bit.
Any other questions, comments? Makes sense? Makes sense. So basically, we try to do optimization, but we also want to cover this corner case. Divija?
Còn câu hỏi hay ý kiến nào khác không? Hiểu chưa? Hiểu rồi. Vậy về cơ bản, chúng ta cố gắng tối ưu hóa, nhưng cũng muốn bao quát trường hợp đặc biệt này. Divija?
Yeah, yeah, yeah. So we do have, like, different extension. We'll have actually different format. For example, for the compressed format, we actually support 16-bit instruction, right?
Vâng, đúng vậy. Chúng ta có các phần mở rộng khác nhau. Thực ra sẽ có các định dạng khác nhau. Ví dụ, với định dạng nén, chúng ta hỗ trợ lệnh 16 bit, đúng không?
With 16-bit instruction, there are actually other changes so that we can actually encode all the different register IDs and some of the immediate in the 16-bit instruction.
Với lệnh 16 bit, có những thay đổi khác để có thể mã hóa tất cả các ID thanh ghi khác nhau và một phần giá trị tức thời trong lệnh 16 bit.
So there are different formats, But we also want to try to make things as consistent as possible so we don't need another branch instruction for those scenarios.
Vì vậy có nhiều định dạng khác nhau, nhưng chúng ta cũng muốn giữ mọi thứ nhất quán nhất có thể để không cần thêm một lệnh rẽ nhánh khác cho các trường hợp đó.
So we try to be consistent there, but for different extensions, there are actually a lot of different ways of encoding information there. Ethan? Can we use the compressed instruction set for embedded systems?
Vậy chúng ta cố gắng nhất quán ở đó, nhưng với các phần mở rộng khác nhau, có rất nhiều cách mã hóa thông tin khác nhau. Ethan? Có phải chỉ dùng tập lệnh nén cho hệ thống nhúng không?
Is there any reason why you want to use it on a whole desktop system? Well, there, like, instruction, like, how compact your instruction is, is always important.
Có lý do nào để dùng nó trên cả một hệ thống máy tính để bàn không? Ừ, thì lệnh ấy, lệnh gọn đến mức nào luôn luôn là điều quan trọng.
So this, the reason it's called a compressed format, I actually read it a little bit carefully with a spec, so it's all on the spec.
Vậy, lý do nó được gọi là định dạng nén, thầy đã đọc khá kỹ trong đặc tả, nên mọi thứ đều có trong đặc tả.
So this can actually be applied to 32-bit ISA, 64-bit ISA to actually support the compressed format.
Định dạng này có thể áp dụng cho ISA 32 bit, ISA 64 bit để hỗ trợ định dạng nén.
It's really interesting if you read some of the Google's papers these days, they are basically saying I-cache miss. So I-cache is basically where we store the program, right, store the instructions.
Rất thú vị nếu các em đọc một số bài báo của Google dạo gần đây, họ nói về I-cache miss. I-cache về cơ bản là nơi lưu chương trình, đúng không, lưu các lệnh.
I-cache miss is actually very significant for a lot of data center workloads.
I-cache miss rất đáng kể với nhiều tải công việc của trung tâm dữ liệu.
Because the program is very complex, they actually have very big code footprint, so we can actually get that code footprint smaller, more compact. There's always benefit, even for the data center applications.
Vì chương trình rất phức tạp, chúng có dấu vết mã rất lớn, nên nếu làm cho dấu vết mã nhỏ hơn, gọn hơn thì có lợi. Luôn có lợi ích, kể cả với các ứng dụng trung tâm dữ liệu.
So it's really interesting.
Thật sự rất thú vị.
Generally, we say actually I-cache miss is actually not very significant in actually a lot of applications, because programs are generally a lot smaller and have a very good locality, right, so it's actually not a big problem.
Nói chung, I-cache miss không đáng kể trong rất nhiều ứng dụng, vì chương trình thường nhỏ hơn nhiều và có tính cục bộ rất tốt, đúng không, nên đó không phải là vấn đề lớn.
But for data center, like, I-cache miss could be very significant, yeah. So this compressed format can also be applied to 64-bit ISA.
Nhưng với trung tâm dữ liệu, I-cache miss có thể rất đáng kể. Vậy định dạng nén này cũng có thể áp dụng cho ISA 64-bit.
Question there? So if we're going to get programs with 32-bit instructions, can we actually jump forward and use two bytes? Because then we're always going to lose our audio.
Bạn có câu hỏi không? Nếu chúng ta có các chương trình với lệnh 32-bit, thì liệu có thể nhảy tới và dùng hai byte không? Vì khi đó chúng ta sẽ luôn bị mất đồng bộ.
Yeah, it's basically, well, the hardware will decode assuming those are actually full instructions, but they're actually two parts of the instructions stitched together, right, so it's basically garbage instructions, yeah.
Vâng, về cơ bản là, phần cứng sẽ giải mã với giả định đó là các lệnh đầy đủ, nhưng thực ra đó là hai phần của các lệnh bị ghép lại với nhau, nên về cơ bản đó là các lệnh rác.
Okay, good question. So we talk about the branch. Again, this branch is, we're doing optimization somewhere in the middle where we only drop basically one bit to get a bigger instruction reach.
Được rồi, câu hỏi hay. Giờ ta nói về lệnh rẽ nhánh. Ở đây, lệnh rẽ nhánh là một dạng tối ưu hóa nằm giữa chừng, trong đó ta chỉ bỏ đi một bit để có tầm với lệnh lớn hơn.
So, like, we actually compare our instruction formats, like the four formats that we mentioned earlier, right?
Giờ hãy so sánh các định dạng lệnh, bốn định dạng mà ta đã nhắc ở trước, nhỉ?
So I-type and S-type, store, and branch, all three actually have immediate, and we see the different way of encoding immediate, right, especially between store and branch.
Loại I, loại S (store) và rẽ nhánh, cả ba đều có giá trị tức thời, và ta thấy các cách mã hóa giá trị tức thời khác nhau, đặc biệt giữa store và rẽ nhánh.
We already mentioned a big part of the encoding is actually consistent, right, while we have opcode, funct3, and the source registers, but the difference is actually the encoding in immediate.
Ta đã nói phần lớn cách mã hóa là nhất quán, vì đều có opcode, funct3, và các thanh ghi nguồn, nhưng khác biệt nằm ở cách mã hóa giá trị tức thời.
Actually, one more thing I want to mention with the immediate encoding here is that we want to encode not only, we talk about this part, right, we want to encode a 13-bit immediate.
Thêm một điều tôi muốn nói về mã hóa giá trị tức thời ở đây là ta muốn mã hóa không chỉ phần này, mà là một giá trị tức thời 13-bit.
We also have an interesting way of actually assembling those immediates. Again, the goal is actually to make things more consistent.
Ta cũng có một cách ghép các giá trị tức thời khá thú vị. Mục tiêu một lần nữa là làm cho mọi thứ nhất quán hơn.
We actually still store basically the middle part, which is actually the same as other formats, but we can cut basically the 12-bit here to replace the original zero bit.
Ta vẫn lưu phần giữa như cũ, giống với các định dạng khác, nhưng có thể cắt bit 12 ở đây để thay cho bit 0 ban đầu.
So we want to maintain some consistency so that we're not completely changing the immediate encoding, but it makes it actually very hard to read by human, but as long as we express it clearly in our hardware, it's actually fine for the hardware to parse it.
Ta muốn giữ một mức nhất quán nhất định để không thay đổi hoàn toàn cách mã hóa giá trị tức thời, nhưng điều đó khiến con người rất khó đọc, song miễn là ta diễn đạt rõ ràng trong phần cứng, thì phần cứng phân tích nó vẫn ổn.
It's a little bit confusing for a human to parse it because we are actually doing this kind of combination to keep consistency.
Con người sẽ hơi khó hiểu khi phân tích vì ta đang kết hợp như vậy để giữ tính nhất quán.
It's a little bit more clear when you look at between those two.
Sẽ rõ hơn một chút khi bạn nhìn so sánh hai định dạng này.
So we actually, instead of doing the last five bits of immediate in the original destination register component, we threw away the zero bit, but we actually put the 11-bit here.
Vậy ta thay vì đặt năm bit cuối của giá trị tức thời vào thành phần thanh ghi đích ban đầu, ta bỏ bit 0 đi, nhưng lại đặt bit 11 ở đây.
So that's the biggest difference. So here, instead of putting the 11-bit here, we actually want to make things consistent.
Đó là khác biệt lớn nhất. Vậy ở đây, thay vì đặt bit 11 ở chỗ này, ta muốn làm cho mọi thứ nhất quán.
We actually put the 11-bit in the original RD0 slot.
Ta đặt bit 11 vào vị trí RD0 ban đầu.
So that's basically the different encoding, especially between store and branch, and we can also see how those can be actually used, how we can actually reassemble the full immediate actually using the instruction format.
Đó chính là cách mã hóa khác nhau, đặc biệt giữa store và rẽ nhánh, và chúng ta cũng có thể thấy chúng thực sự được dùng như thế nào, làm thế nào để ghép lại toàn bộ giá trị tức thời bằng chính định dạng lệnh.
Ryan? So I don't understand why we need that 11 to be there and not put it over on the left. Like, we could just do one box.
Ryan? Em không hiểu tại sao chúng ta cần bit 11 nằm ở đó mà không đặt nó sang bên trái. Ví dụ, ta chỉ cần dùng một ô thôi.
Right, so if we actually do one five, then basically the 10, this part, the 10 to 5 -bit will be actually handled differently in the hardware.
Đúng, nếu ta làm theo kiểu một ô, thì phần này, bit 10, tức các bit từ 10 đến 5, sẽ được xử lý khác đi trong phần cứng.
So we want to maintain consistent as much as possible, basically. Yeah, we want to raise it from that section. We want to be basically be consistent.
Vì vậy về cơ bản chúng ta muốn giữ tính nhất quán càng nhiều càng tốt. Vâng, chúng ta muốn lấy nó ra từ phần đó. Về cơ bản chúng ta muốn nhất quán.
If you actually read basically this part, it's actually a lot easier. So we literally, so instruction 7 is basically the 11 -bit of the immediate. So we read it here.
Nếu đọc phần này thì sẽ dễ hơn rất nhiều. Nghĩa là, instruction 7 chính là bit 11 của giá trị tức thời. Vậy ta đọc nó ở đây.
We basically read it from here and put it to the 11 -bit, and everything in the middle actually stays the same. We don't actually need to change the logic, right?
Ta đọc từ đây rồi đưa vào bit 11, còn mọi thứ ở giữa vẫn giữ nguyên. Ta không cần thay đổi logic, đúng không?
So it's, again, to maintain consistency of the instruction encoding. So you still need to actually put the letter K there, right? But the middle part stays the same. Exactly. Johnny?
Vậy nên, một lần nữa, đó là để giữ tính nhất quán của mã hóa lệnh. Nên ta vẫn cần đặt bit đó vào đó, đúng không? Nhưng phần giữa vẫn giữ nguyên. Chính xác. Johnny?
So how does the format of the instructions develop with the Java program? Oh, how does the format of the instructions?
Vậy định dạng của các lệnh được phát triển như thế nào với chương trình Java? À, định dạng của các lệnh ấy à?
Are they explained from like the system, or are they fixed as they figure out?
Chúng được quy định từ hệ thống, hay được cố định dần trong quá trình họ tìm ra?
Yeah, so if you actually go to the RISC-V foundation, go to their website, they actually have a list of different ISAs. When they say actually ratified, it's basically the ISA is fixed or confirmed.
Vâng, nếu em vào RISC-V Foundation, vào trang web của họ, họ có danh sách các ISA khác nhau. Khi họ nói là đã được phê chuẩn (ratified), tức là ISA đó đã được cố định hay xác nhận.
So they stay the same. So most of the, well, the majority of ISAs that we're talking about are basically confirmed or fixed, right? So we're not changing that.
Nên chúng giữ nguyên. Phần lớn các ISA mà chúng ta đang nói đến về cơ bản đã được xác nhận hay cố định, đúng không? Nên ta không thay đổi chúng.
There are some like ISA, I think vector is probably pretty close to be ratified, But they are still, there's some discussion, there's a working group actually trying to figure it out.
Có một số ISA, tôi nghĩ vectơ có lẽ sắp được phê chuẩn, nhưng vẫn còn một số thảo luận, có một nhóm làm việc đang cố gắng chốt nó.
So there are some instructions that are still being discussed in setting up the format, but the majority of the ones we're talking about are actually already fixed.
Vậy có một số lệnh vẫn đang được thảo luận để thiết lập định dạng, nhưng phần lớn những lệnh chúng ta đang nói đến đã được cố định rồi.
So there is a process. You want to add new instructions there. So you're saying the vector instructions are not complete?
Vậy có một quy trình. Muốn thêm lệnh mới thì phải qua đó. Ý em là các lệnh vectơ chưa hoàn chỉnh?
That's what, it's pretty close, either already ratified or pretty close to be ratified for the vector extension. Yeah, I'm pretty sure there are a couple more other instruction extensions that are still being discussed.
Đúng vậy, nó gần xong rồi, phần mở rộng vectơ hoặc đã được phê chuẩn hoặc sắp được phê chuẩn. Vâng, tôi khá chắc còn vài phần mở rộng tập lệnh khác vẫn đang được thảo luận.
Yeah, so this is, that's why it's an open source ISA, right? So everyone can, there's a working group, people can contribute, people can bring in new ideas.
Vâng, đó là lý do nó là một ISA mã nguồn mở, đúng không? Ai cũng có thể, có một nhóm làm việc, mọi người có thể đóng góp, đưa ra ý tưởng mới.
Yeah, but vectors, these are already ratified or pretty close to getting ratified, yeah. If all of these instructions maximize consistency, why is 11 not in bit 31?
Vâng, nhưng vectơ thì đã được phê chuẩn hoặc sắp được phê chuẩn, vâng. Nếu tất cả các lệnh này đều tối đa hóa tính nhất quán, thì tại sao bit 11 không nằm ở bit 31?
Why is 12 not there? Why is 11, why is the 11th bit of the immediate not in the 31st bit of the instruction?
Tại sao bit 12 không ở đó? Tại sao bit 11, tại sao bit thứ 11 của immediate lại không nằm ở bit thứ 31 của lệnh?
That's a good question, right? So why do we still keep the MSB, the bit 12 here, instead of moving that bit to somewhere else?
Đó là một câu hỏi hay, đúng không? Vậy tại sao ta vẫn giữ MSB, tức bit 12 ở đây, thay vì chuyển bit đó sang một chỗ khác?
Yes, that's a sign bit. So we want to make the sign bit consistent. So the sign bit is always the MSB.
Đúng, đó là bit dấu. Nên ta muốn giữ cho bit dấu nhất quán. Vì vậy bit dấu luôn là MSB.
So then the immediate, the 11th bit of the immediate is actually basically the non-sign bit, the first bit of the non-sign bits. That's a good discussion. Any other questions, comments?
Thế nên immediate, bit thứ 11 của immediate thực chất là bit không phải bit dấu, bit đầu tiên trong các bit không phải bit dấu. Đó là một thảo luận hay. Còn câu hỏi hay nhận xét nào khác không?
Yes, I was going to ask about these two tables. I wonder why we don't have these lines right here, as I'm drawing right now.
Dạ, em định hỏi về hai bảng này. Em thắc mắc sao không có những đường này ở đây, như em đang vẽ.
Is there supposed to be some other content or some other bits in here? That's a good question. So all those bits are basically the sign.
Có phải ở đây lẽ ra phải có nội dung hay những bit nào khác không ạ? Câu hỏi hay. Tất cả những bit đó về cơ bản là bit dấu.
Remember we do sign extension? So we can only basically, right? So all of those are basically sign extended. So from the 30, the MSB of the instruction and then sign extended.
Nhớ là ta có mở rộng dấu chứ? Nên về cơ bản ta chỉ có thể, đúng không? Tất cả những bit đó về cơ bản đều được mở rộng dấu. Tức là từ bit 30, MSB của lệnh, rồi được mở rộng dấu.
How is it different from B right here? This one where I have bit number seven.
Nó khác với B ở đây như thế nào? Chỗ này, nơi em có bit số bảy.
How is it different from bit number seven? Yes, right here in the B type instruction.
Nó khác với bit số bảy như thế nào? Vâng, ngay đây, trong lệnh kiểu B.
Well, so basically everything, so remember we say we can actually get 13-bit for B type instruction, while we can only get 12-bit for other immediate instruction.
À, về cơ bản mọi thứ, nhớ là ta nói với lệnh kiểu B ta có thể có 13 bit, trong khi các lệnh immediate khác chỉ có 12 bit.
So first, those drawings are not to the scale, right? So this is actually 22-bit here or 20-bit here. So we're doing sign extension here.
Trước hết, những hình vẽ này không theo đúng tỉ lệ nhé. Chỗ này thực ra là 22 bit ở đây hoặc 20 bit ở đây. Nên ở đây ta đang mở rộng dấu.
Well, for this, we have one more extra bit, right?
Còn ở đây, ta có thêm một bit nữa, đúng không?
So you want one more extra bit for B type or instruction seven? Yeah, so we have one more extra bit. So this is basically the immediate 11, which is stored here, right?
Vậy em muốn thêm một bit cho lệnh kiểu B hay lệnh bit bảy? Vâng, vậy là ta có thêm một bit. Đây về cơ bản là immediate 11, được lưu ở đây, đúng không?
So for this bit, which is the seventh bit of the instruction.
Tức là bit này, là bit thứ bảy của lệnh.
Carol? So how can we use a different instruction? We're going to jump to the 12 and then it can jump more than that. Yeah, we need to use a different instruction.
Carol? Vậy làm sao ta dùng một lệnh khác? Ta sẽ nhảy tới 12 rồi nó có thể nhảy xa hơn thế. Vâng, ta cần dùng một lệnh khác.
We'll get to that in, I guess, a couple like five to six slides. Yeah, we also need to bigger range. So we also need to figure out how we support bigger range.
Ta sẽ nói tới phần đó sau khoảng năm đến sáu slide nữa. Vâng, ta cũng cần phạm vi lớn hơn. Nên ta cũng cần tìm cách hỗ trợ phạm vi lớn hơn.
So Anthony, does that earlier discussion, the sign extension address your question? Yeah, it does. Thank you. Okay, good. We talk a lot a little bit more in coding.
Anthony, thảo luận lúc nãy về mở rộng dấu có trả lời câu hỏi của em không? Dạ có. Cảm ơn thầy. Được rồi, tốt. Ta sẽ nói thêm một chút nữa trong phần lập trình.
One thing you want to differentiate is what we mean by we're talking about two values. One is the immediate, one is instruction, right?
Một điều em cần phân biệt là ta đang nói đến hai giá trị. Một là giá trị immediate, một là lệnh, đúng không?
So think like we're doing some of the conversion on this slide. So if you have time, take a look at that afterwards. So we talk about the RSA.
Hãy hình dung là chúng ta đang thực hiện một số phép chuyển đổi trên slide này. Nếu có thời gian, các bạn hãy xem lại phần đó sau nhé. Vậy là chúng ta đã nói về RSA.
Now let's take a look at how we actually support our branch in our data paths. So we talk about the states that we are changing, right? So we are actually changing the PC.
Bây giờ hãy xem chúng ta thực sự hỗ trợ lệnh rẽ nhánh trong datapath của mình như thế nào. Chúng ta nói về các trạng thái mà mình sẽ thay đổi, đúng không? Cụ thể là chúng ta sẽ thay đổi PC.
And then that actually depends on whether our branch is taken or not taken, right? If the branch is not taken, we just continue to the next instruction.
Và điều đó phụ thuộc vào việc rẽ nhánh có được thực hiện hay không, đúng không? Nếu không rẽ nhánh, ta chỉ việc tiếp tục sang lệnh kế tiếp.
If the branch is taken, we basically jump to the new label. There are actually different branch instructions. We'll get to this later. They're basically encoded using different combinations of func3, right?
Nếu rẽ nhánh, về cơ bản ta nhảy tới nhãn mới. Thực ra có nhiều lệnh rẽ nhánh khác nhau. Lát nữa chúng ta sẽ nói tới. Về cơ bản chúng được mã hóa bằng các tổ hợp func3 khác nhau, đúng không?
Here, we think about the computation we need to do, right? We definitely need to do this addition, right? So that we can figure out where to go, right? We need to compute the addition.
Ở đây, ta xem xét những phép tính cần thực hiện, đúng không? Chắc chắn ta cần thực hiện phép cộng này, đúng không? Để xác định nơi cần nhảy tới, đúng không? Ta cần tính phép cộng.
We also need to do a comparison, right? This is a conditional branch, right? So we'll talk about B type. It's actually a conditional branch.
Ta cũng cần thực hiện một phép so sánh, đúng không? Đây là một lệnh rẽ nhánh có điều kiện, đúng không? Vậy ta sẽ nói về loại B. Thực ra nó là lệnh rẽ nhánh có điều kiện.
So we'll compare the values of the two registers and figure out where we want to go, right? So we are doing two types of computation. One is calculating the target address.
Ta sẽ so sánh giá trị của hai thanh ghi và xác định nơi ta muốn đi tới, đúng không? Như vậy ta thực hiện hai loại tính toán. Một là tính địa chỉ đích.
The other is actually doing the comparison. So in this case, you will look at our datapath.
Hai là thực hiện phép so sánh. Vậy trong trường hợp này, các bạn hãy nhìn vào datapath của chúng ta.
So this is our datapath so far where we add load, store, and the regular R type and I type instructions. So I mentioned there are a couple of things we need to change.
Đây là datapath của chúng ta cho đến lúc này, nơi ta đã thêm lệnh load, store, và các lệnh loại R và loại I thông thường. Tôi đã nói là có một vài thứ cần thay đổi.
We're changing the PC state. We're changing the immediate generation. We're adding another unit to do actually a comparison, right? We look at, we want to support the branch instructions here.
Chúng ta thay đổi trạng thái PC. Chúng ta thay đổi khối sinh immediate. Chúng ta thêm một khối nữa để thực hiện phép so sánh, đúng không? Ta xem xét, ta muốn hỗ trợ các lệnh rẽ nhánh ở đây.
So a couple more things. The first, we have a new control signal, right? So not because we have branch taken or not taken. Whenever there are two scenarios, we add a MUX there, right?
Vậy còn một vài điều nữa. Thứ nhất, ta có một tín hiệu điều khiển mới, đúng không? Đó là vì ta có trường hợp rẽ nhánh được thực hiện hoặc không. Bất cứ khi nào có hai kịch bản, ta thêm một MUX ở đó, đúng không?
So I can figure out which condition we want to go. So we're changing, we're adding another MUX in front of our program counter so that we can actually get different values.
Để tôi có thể chọn điều kiện mà ta muốn đi theo. Vậy ta thêm một MUX nữa ở phía trước bộ đếm chương trình để có thể nhận các giá trị khác nhau.
We're changing our immediate generation. We had a lot of discussion about the format, right?
Chúng ta thay đổi khối sinh immediate. Chúng ta đã thảo luận khá nhiều về định dạng, đúng không?
So now this is different from the format that we have seen before, although we do try to make it as consistent as possible.
Giờ định dạng này khác với những định dạng ta đã thấy trước đây, dù ta đã cố làm cho nó nhất quán nhất có thể.
So we also need to modify our immediate generation so that we can actually parse that format, right? We also need a branch comparator right here because we are comparing the two values.
Vì vậy ta cũng cần sửa khối sinh immediate để có thể phân tích định dạng đó, đúng không? Ta cũng cần một bộ so sánh rẽ nhánh ngay ở đây vì ta đang so sánh hai giá trị.
So they actually read values directly from register. And then based on the result of the comparison, that actually dictate where we want to go, right? So we also need to do branch comparison here.
Chúng đọc giá trị trực tiếp từ thanh ghi. Và dựa vào kết quả của phép so sánh, điều đó quyết định nơi ta muốn đi tới, đúng không? Vậy ta cũng cần thực hiện so sánh rẽ nhánh ở đây.
We also need to actually change the inputs to the ALU because we actually need to figure out the target branch, right? The PC plus immediate, right?
Ta cũng cần thay đổi các đầu vào của ALU vì chúng ta thực sự cần xác định nhánh đích, đúng không? Tức là PC cộng với immediate, đúng không?
If the branch is taken, where we are going. So we need to figure out the target branch.
Nếu nhánh được rẽ, thì đó là nơi chúng ta sẽ đi tới. Vậy nên chúng ta cần xác định nhánh đích.
So in this case, instead of, we mentioned the source register A and B, we also need to have another MUX in front of A because the source A can either come from the register file, but also coming from PC, right?
Vậy trong trường hợp này, thay vì chỉ có thanh ghi nguồn A và B như đã nói, chúng ta còn cần thêm một MUX ở phía trước A vì nguồn A có thể đến từ tệp thanh ghi, nhưng cũng có thể đến từ PC, đúng không?
Because we're doing PC operation, we're adding the immediate to the PC to actually get a new value. So the calculated address, right? So this is basically the target address, right?
Bởi vì chúng ta đang thực hiện phép toán với PC, chúng ta cộng immediate vào PC để có được một giá trị mới. Đó chính là địa chỉ được tính ra, đúng không? Về cơ bản đây là địa chỉ đích, đúng không?
It's actually being fed back to our program counter if the branch is taken, right? So that's basically the changes that we need to do to actually support branch instruction.
Nó được đưa ngược trở lại bộ đếm chương trình nếu nhánh được rẽ, đúng không? Vậy về cơ bản đó là những thay đổi mà chúng ta cần thực hiện để hỗ trợ lệnh rẽ nhánh.
Brendan? Are we going to solve in this class? Branch, I think if I remember correctly, a branch prediction is actual credit for your project.
Brendan? Chúng ta có giải quyết việc này trong lớp không? Về rẽ nhánh, nếu tôi nhớ không nhầm, dự đoán nhánh là phần được cộng điểm trong project của các bạn.
So you are interested, yeah, you can implement a branch predictor.
Nên nếu bạn hứng thú thì có thể cài đặt một bộ dự đoán nhánh.
Any other questions? Yeah, these two MUXs, are they going to be, they're not going to be two to one, right? Are they going to be like five to one?
Còn câu hỏi nào khác không? Vâng, hai MUX này, chúng có phải là không phải loại hai đầu vào chứ? Chúng có phải là loại năm đầu vào không?
Which two, like the PC MUX? The one, I mean, oh. They're drawn here, it's two to one. Wouldn't they need to be more than that?
Hai cái nào, ví dụ MUX của PC à? Cái đó, ý em là, à. Trên hình chúng được vẽ là hai đầu vào. Chúng có cần nhiều hơn thế không ạ?
You mean those two, like the inputs? Yeah, well, we talk more, actually, especially when we get to pipeline design, there could be actually multiple sources.
Ý bạn là hai cái đó, tức là các đầu vào à? Vâng, chúng ta sẽ nói thêm, nhất là khi tới phần thiết kế đường ống, có thể sẽ có nhiều nguồn khác nhau.
We'll get to that. But so far, we only need the two inputs. For the current, yeah, we're just, we're building up the design step by step.
Chúng ta sẽ đến phần đó. Nhưng cho đến giờ, chúng ta chỉ cần hai đầu vào. Hiện tại, chúng ta đang xây dựng thiết kế từng bước một.
For the current, I say that we talk so far for a single cycle execution, yeah, we only do two inputs. Ben? Why is branch assigned as a single critical event?
Với phần hiện tại, tức là thực thi một chu kỳ như đã nói đến giờ, vâng, chúng ta chỉ dùng hai đầu vào. Ben? Tại sao branch unsigned lại được gán là một sự kiện tới hạn đơn?
Yeah, well, why is branch unsigned? It's actually coming from control input to the branch. So what does branch unsigned is trying to do?
Vâng, vậy tại sao lại có branch unsigned? Nó đến từ tín hiệu điều khiển đưa vào khối so sánh nhánh. Vậy branch unsigned có tác dụng gì?
Ethan?
Ethan?
Right, so it's actually, we'll see that, so it's actually different branch instructions, whether it actually specifies whether we want to do an unsigned or signed comparison.
Đúng rồi, chúng ta sẽ thấy là các lệnh rẽ nhánh khác nhau, sẽ quy định việc chúng ta muốn so sánh không dấu hay có dấu.
So it's from the instruction, it's a control signal.
Vậy nó đến từ lệnh, là một tín hiệu điều khiển.
We'll see the instruction in a minute.
Chúng ta sẽ xem các lệnh ngay sau đây.
Yeah, branch unsigned, yeah. So branch unsigned is actually input to the branch comparator, and then less than or equal is actually, we'll get to the different instruction, branch instructions we support in a minute.
Vâng, branch unsigned. Vậy branch unsigned là đầu vào của bộ so sánh nhánh, còn less than or equal thì chúng ta sẽ nói tới khi xét các lệnh khác nhau, tức các lệnh rẽ nhánh mà chúng ta hỗ trợ, ngay sau đây.
Okay, any other questions?
Được rồi, còn câu hỏi nào khác không?
Okay, so those are the highlighted data paths, and that, and this is basically what's been asked earlier, right?
Vậy đó là các đường dữ liệu được tô sáng, và đây, và về cơ bản đây chính là điều đã được hỏi lúc nãy, đúng không?
So we actually have three control, I guess, one input control signals, and the control actually needs the comparison result to decide whether we actually, the branch is taken or not, right?
Vậy thực ra chúng ta có ba tín hiệu điều khiển, hay đúng hơn là một tín hiệu điều khiển đầu vào, và khối điều khiển thực ra cần kết quả so sánh để quyết định xem nhánh có được rẽ hay không, đúng không?
So you will look at the input to the branch comparator, we'll have the register input.
Vậy bạn sẽ nhìn vào đầu vào của bộ so sánh nhánh, chúng ta sẽ có đầu vào từ thanh ghi.
So as Ethan mentioned, the branch unsigned, I guess earlier we have an end here, is actually input, it's because different branch instructions, some of the branch is actually doing unsigned comparison, some branch is actually doing signed comparison, so we actually need to tell the branch comparator whether we're doing a signed or unsigned comparison, and then after the comparison, we actually get the result of the comparison,
Như Ethan đã nói, tín hiệu branch unsigned, lúc nãy ở đây chúng ta có một cổng AND, là một đầu vào, vì các lệnh rẽ nhánh khác nhau: một số lệnh rẽ nhánh thực hiện so sánh không dấu, một số lệnh rẽ nhánh thực hiện so sánh có dấu, nên chúng ta cần báo cho bộ so sánh nhánh biết là đang so sánh có dấu hay không dấu, rồi sau khi so sánh, chúng ta nhận được kết quả so sánh,
whether it's equal or whether it's less than. We only do two, but we also want to support the greater than comparison, but that's basically the, basically the inverse of the less than signal, right?
là bằng nhau hay nhỏ hơn. Chúng ta chỉ làm hai phép, nhưng cũng muốn hỗ trợ phép so sánh lớn hơn, nhưng về cơ bản đó chỉ là đảo của tín hiệu nhỏ hơn, đúng không?
So we don't need three signals, we just need to see whether they're equal, A and B are equal, or whether A is actually less than B, so that's our comparison we're doing.
Vì vậy chúng ta không cần ba tín hiệu, chỉ cần xem A và B có bằng nhau không, hoặc A có nhỏ hơn B không, đó là phép so sánh chúng ta thực hiện.
Like, it would look at the instruction form we mentioned, those are actually six different instructions, so basically unsigned are actually two separate instructions.
Nếu nhìn vào định dạng lệnh mà chúng ta đã nói, đó là sáu lệnh khác nhau, nên về cơ bản các lệnh không dấu là hai lệnh riêng biệt.
We have less than and greater than, which does the signed comparison, and unsigned is another pair of instructions that tell the branch predictor to do unsigned comparison.
Chúng ta có nhỏ hơn và lớn hơn, thực hiện so sánh có dấu, và không dấu là một cặp lệnh khác báo cho bộ dự đoán nhánh thực hiện so sánh không dấu.
Makes sense? Any questions about branch, B type instruction?
Hiểu chưa? Có câu hỏi nào về lệnh rẽ nhánh, lệnh kiểu B không?
B type is probably one of the most confusing type of instruction, a lot of different components are actually embedded there, but the most important one is the immediate encoding, it's basically how we actually encode the 13-bit immediate efficiently in branch instruction.
Kiểu B có lẽ là một trong những kiểu lệnh dễ gây nhầm lẫn nhất, vì có rất nhiều thành phần khác nhau được nhúng vào đó, nhưng quan trọng nhất là cách mã hóa immediate, tức là cách chúng ta mã hóa immediate 13 bit một cách hiệu quả trong lệnh rẽ nhánh.
Okay, so we talked about conditional branch, the B type instruction, there are also unconditional branch or jump instruction, right?
Được rồi, vậy chúng ta đã nói về rẽ nhánh có điều kiện, lệnh kiểu B, còn có rẽ nhánh không điều kiện hay lệnh nhảy, đúng không?
So here, we actually don't need to do the comparison, we just always jump, so that's basically our J type instruction. We'll talk about the two instructions that we need for the J type instruction.
Ở đây chúng ta không cần so sánh, chỉ luôn luôn nhảy, đó chính là lệnh kiểu J của chúng ta. Chúng ta sẽ nói về hai lệnh cần cho kiểu J.
So first is jalr, or J-A-L-R, right? So this instruction is actually not J type, it's actually an I type instruction.
Đầu tiên là jalr, tức J-A-L-R, đúng không? Lệnh này thực ra không phải kiểu J, mà là lệnh kiểu I.
We'll see in a minute, it actually follows the same, exactly the same encoding compared to I type instruction, so we have opcode, we have our func3, and we have one source and one destination, and the rest of the bits, all the upper bits are basically, upper 12 bits are dedicated for the immediate encoding.
Lát nữa chúng ta sẽ thấy, nó theo đúng cách mã hóa của lệnh kiểu I, nên có opcode, có func3, và có một nguồn và một đích, còn các bit còn lại, tất cả các bit cao, 12 bit cao dành cho mã hóa immediate.
So for this jalr instruction, it basically jump and the link register, right? So jump and link register, right?
Với lệnh jalr này, về cơ bản nó nhảy và liên kết thanh ghi, đúng không? Tức là nhảy và liên kết thanh ghi, đúng không?
So as the name suggests, we do the jump, so we actually change our PC state, right? So here is where we do the jump.
Như tên gọi cho thấy, ta thực hiện nhảy, tức là ta thực sự thay đổi trạng thái PC, đúng không? Đây chính là chỗ ta thực hiện nhảy.
We also do the link register, basically we want to remember where we want to go back, right? Just imagine we actually write a function, We actually call the function, right?
Ta cũng thực hiện link register, về cơ bản là ta muốn ghi nhớ nơi mà ta muốn quay lại, đúng không? Hãy tưởng tượng ta viết một hàm, rồi ta gọi hàm đó, đúng không?
You also want to return eventually back to the original execution, right? So JALR is actually designed for that.
Cuối cùng bạn cũng muốn quay trở lại luồng thực thi ban đầu, đúng không? JALR được thiết kế cho mục đích đó.
We actually jump to a new PC, and then we remember where we should actually go back.
Ta nhảy tới một PC mới, rồi ta ghi nhớ nơi ta cần quay lại.
And when we go back, we actually don't go back to PC, we actually go back to PC plus four, because we will actually be executing the next instruction.
Và khi quay lại, ta thực ra không quay về PC, mà ta quay về PC cộng bốn, vì ta sẽ thực thi lệnh tiếp theo.
So this will be our return address, and then the target is basically computed by one source register plus immediate, which is the same computation as what we did with the I type instruction.
Vậy đây sẽ là địa chỉ trả về của ta, còn địa chỉ đích được tính bằng một thanh ghi nguồn cộng với immediate, giống hệt phép tính ta đã làm với lệnh kiểu I.
But instead of modifying register file, we're modifying the PC counter, which is also a state here.
Nhưng thay vì sửa register file, ta sửa bộ đếm PC, vốn cũng là một trạng thái ở đây.
So this is the same as the I type instruction, there's no multiplication by two bytes, we actually don't drop the LSB of the immediate, so only branch instruction does that.
Vậy nó giống với lệnh kiểu I, không có phép nhân với hai byte, ta không bỏ LSB của immediate, chỉ lệnh rẽ nhánh mới làm vậy.
So here we are actually talking about 12 bits immediate, so we don't need to worry about the LSB, which is different from the branch and the JAL instruction, which we'll see in a minute.
Ở đây ta đang nói về immediate 12 bit, nên ta không cần lo về LSB, khác với lệnh rẽ nhánh và lệnh JAL, mà một lát nữa ta sẽ thấy.
So this is still I type instruction, we have one source register, which is used to actually figure out where we want to jump to.
Vậy đây vẫn là lệnh kiểu I, ta có một thanh ghi nguồn, dùng để xác định nơi ta muốn nhảy tới.
We have one destination register, which is basically remember, trying to remember where we want to come back with a return address of our execution.
Ta có một thanh ghi đích, về cơ bản là để nhớ, nơi ta muốn quay lại, tức địa chỉ trả về của luồng thực thi.
Actually there's another source state, which is not a register, but it's a program counter, so we also use a program counter to both figure out the relative jump and the target, and also to store the relative, to store the target, but also to figure out where we actually want to return.
Thực ra còn một trạng thái nguồn khác, không phải thanh ghi, mà là bộ đếm chương trình, nên ta cũng dùng bộ đếm chương trình vừa để xác định bước nhảy tương đối và địa chỉ đích, vừa để lưu địa chỉ đích, đồng thời để xác định nơi ta thực sự muốn quay về.
So that's our JALR instruction. You will want to support this in our datapath, so this is our datapath so far with our branch instruction.
Đó là lệnh JALR của ta. Bạn sẽ muốn hỗ trợ lệnh này trong datapath của ta, đây là datapath của ta cho đến giờ, cùng với lệnh rẽ nhánh.
So again, we see a couple of modifications, We are using the ALU to actually update our PC counter, there's another PC counter update, and we also need to write to the register to store the return address.
Một lần nữa, ta thấy một vài thay đổi, Ta dùng ALU để cập nhật bộ đếm PC, có thêm một lần cập nhật bộ đếm PC khác, và ta cũng cần ghi vào thanh ghi để lưu địa chỉ trả về.
You may think about how we want to support the JALR instruction. We basically still need to generate immediate, but this is actually consistent with I type, right?
Bạn có thể nghĩ xem ta muốn hỗ trợ lệnh JALR như thế nào. Về cơ bản ta vẫn cần sinh immediate, nhưng điều này thực ra nhất quán với kiểu I, đúng không?
We're not actually adding a new immediate generation.
Ta không thêm bộ sinh immediate mới.
When we actually write back the calculated address that we want to calculate, we actually want to store PC plus 4, basically the return address, right?
Khi ta ghi lại địa chỉ mà ta muốn tính, ta thực ra muốn lưu PC cộng 4, về cơ bản là địa chỉ trả về, đúng không?
So we want to also store the return address to the register file, right? So there's another source of the writeback, so now it's become a straight input mux to actually store the register.
Vậy chúng ta cũng muốn lưu địa chỉ trả về vào register file, đúng không? Như vậy có thêm một nguồn nữa cho bước ghi ngược, nên bây giờ nó trở thành một bộ dồn kênh đầu vào để lưu vào thanh ghi.
We can actually use the same mux that we added before to the ALU, so one of the source input is actually PC counter here.
Chúng ta có thể dùng lại chính bộ dồn kênh đã thêm trước đó cho ALU, trong đó một trong các đầu vào nguồn chính là bộ đếm chương trình PC ở đây.
So that's basically the changes that we need to do to support JALR in our datapath. Makes sense? Questions?
Vậy đó là những thay đổi mà chúng ta cần làm để hỗ trợ JALR trong datapath của mình. Hợp lý chứ? Có câu hỏi nào không?
Okay, let's see, a couple of questions here for PC.
Được rồi, để xem, có vài câu hỏi ở đây về PC.
So, earlier, I guess there is a question about this part.
Lúc nãy, tôi nghĩ có một câu hỏi về phần này.
Right, so here we're basically does PC is register plus immediate.
Đúng rồi, ở đây về cơ bản PC bằng thanh ghi cộng với giá trị tức thời.
Original slide, if you download the slide like yesterday, there is a note where we basically say we actually set the LSB to be zero. I just deleted this note in the morning.
Trong slide gốc, nếu các bạn tải slide hôm qua, có một ghi chú nói rằng chúng ta đặt LSB bằng không. Sáng nay tôi đã xóa ghi chú này.
You guys always, you guys basically don't do the drop, right? So the LSB is always zero, so there's, we don't need to set it, we always jump by at least two bytes, right?
Các bạn luôn, các bạn về cơ bản không có phần bỏ bit đó, đúng không? Vì LSB luôn bằng không, nên chúng ta không cần đặt nó, chúng ta luôn nhảy ít nhất hai byte, đúng không?
So LSB of this offset is always zero. Brian? I just have a kind of viral question on this.
Vậy LSB của độ dời này luôn bằng không. Brian? Tôi có một câu hỏi hơi mông lung về chỗ này.
Is there a reason we have these instructions rather than, I don't remember if there's a reason to not have them in this case, but if we just add directly to the program counter instead of branch at all.
Có lý do nào để có các lệnh này thay vì tôi không nhớ có lý do nào để không có chúng trong trường hợp này không, mà chỉ cộng trực tiếp vào bộ đếm chương trình thay vì rẽ nhánh.
You may just add.
Bạn có thể chỉ cần cộng.
You may want to add to the program. You can delete all the branches.
Bạn có thể cộng vào chương trình. Có thể xóa hết các lệnh rẽ nhánh.
Say that again, what? I guess the branch instructions are just adding to the program counter, right? It's adding to, yeah, we're adding an offset to the program counter.
Bạn nói lại đi, gì cơ? Tôi nghĩ các lệnh rẽ nhánh chỉ là cộng vào bộ đếm chương trình, đúng không? Nó cộng, vâng, chúng ta cộng một độ dời vào bộ đếm chương trình.
Yeah, so if I just remove the branch instructions before the read, I can still jump using the add.
Vâng, vậy nếu tôi bỏ các lệnh rẽ nhánh trước khi đọc, tôi vẫn có thể nhảy bằng lệnh add.
Oh, you just jump, you set the register and then jump to that register, yeah, we'll actually talk about how we can actually do that, but you cannot do the conditional branch, right?
À, bạn chỉ nhảy, bạn đặt thanh ghi rồi nhảy tới thanh ghi đó, vâng, chúng ta sẽ nói về cách làm điều đó, nhưng bạn không thể làm rẽ nhánh có điều kiện, đúng không?
We always need to do the branch comparison. Right, so we always need to actually do the branch comparison.
Chúng ta luôn cần thực hiện phép so sánh rẽ nhánh. Đúng vậy, nên chúng ta luôn cần thực hiện phép so sánh rẽ nhánh.
You will actually do this, right, so this, we are basically, we are adding this immediate here, right, but we are basically just jump to this register, this instruction.
Bạn sẽ làm thế này, đúng không, vậy ở đây chúng ta về cơ bản chúng ta cộng giá trị tức thời này vào đây, đúng không, nhưng về cơ bản chúng ta chỉ nhảy tới thanh ghi này, lệnh này.
What this instruction does, it basically jumps to this register, right? Is PC one of the 32 registers we have access to? No, PC is not one of them.
Lệnh này về cơ bản nhảy tới thanh ghi này, đúng không? PC có phải một trong 32 thanh ghi mà chúng ta truy cập được không? Không, PC không phải.
So we cannot do that, right, because we need a destination register, and if PC cannot be a destination register, we can never add to it.
Vậy chúng ta không thể làm thế, vì cần có một thanh ghi đích, và nếu PC không thể là thanh ghi đích thì chúng ta không bao giờ cộng vào nó được.
We actually cannot do that, because it's not one of the 32 registers.
Chúng ta thực sự không thể làm vậy, vì nó không phải một trong 32 thanh ghi.
Oh, I see, yes, I see, that's what you mean, okay, yes, so PC is not a source register, so we cannot use a regular R-type instruction to actually multiply.
À, tôi hiểu rồi, vâng, ý bạn là vậy, được rồi, vậy PC không phải là thanh ghi nguồn, nên chúng ta không thể dùng lệnh R-type thông thường để nhân.
Yeah, I actually have some questions, because x86, actually, the PC is one of the registers, we can just add to it, right?
Vâng, tôi có vài thắc mắc, vì trong x86 thì PC là một trong các thanh ghi, chúng ta có thể cộng vào nó, đúng không?
x86 PC is one of the registers? Yeah, like, is it? Actually, it's not. Yeah, so there are only eight registers.
PC của x86 là một trong các thanh ghi? Vâng, kiểu vậy? Thực ra là không. Vâng, vì chỉ có tám thanh ghi.
Actually, this is actually even tighter in terms of, it's very tight with the register, yes.
Thực ra cái này còn chặt chẽ hơn về mặt nó gắn rất chặt với các thanh ghi, đúng vậy.
Say that again.
Bạn nói lại được không?
The RAP? Oh, for x86, I see.
RAP à? Ồ, ý bạn là với x86, tôi hiểu rồi.
So why don't we do that? Wouldn't that kill a whole bunch of instructions, make it simpler? Wait, say that again. And we just make PC something we can write.
Vậy tại sao chúng ta không làm như thế? Làm vậy chẳng phải sẽ loại bỏ được cả loạt lệnh, giúp mọi thứ đơn giản hơn sao? Khoan, nói lại nhé. Và chúng ta cứ coi PC là thứ mà ta có thể ghi vào.
So that's, are you talking about unconditional jump?
Vậy bạn đang nói về lệnh nhảy không điều kiện à?
Yeah, like, I was just talking about, instead of, like, adding all these branch things, like, all the ones you can remove, you can really add to PC, you can add.
Vâng, tôi chỉ đang nói về việc, thay vì thêm tất cả những lệnh rẽ nhánh này, tức là loại bỏ được hết những lệnh đó, vì thực sự có thể cộng vào PC được.
So we just add to the PC, so instead of doing this, we treat PC as a register?
Thế nên ta chỉ cần cộng vào PC, vậy thay vì làm thế này, ta coi PC như một thanh ghi?
Yeah, like, now we're pretty free, but I don't, I was, I couldn't remember the reason we can't, we don't treat it as one.
Vâng, như vậy giờ ta khá tự do, nhưng tôi không nhớ được lý do vì sao ta không làm thế, không coi nó như một thanh ghi.
Well, yeah, well, I guess if we do that, then with add instruction, there are actually two possibilities, actually, changing the PC state, right?
Ừ, tôi đoán nếu làm vậy thì với lệnh add, thực ra sẽ có hai khả năng làm thay đổi trạng thái PC, đúng không?
Because regular add, we just always do PC plus four, right? Yeah.
Vì với lệnh add thông thường, ta luôn thực hiện PC cộng bốn, đúng không? Vâng.
Now you will actually do this, then it's actually, basically, you'll combine two instructions into a complex instruction that supports those two PC jumps. Yeah. Yeah. Okay. Yeah. Ethan?
Giờ nếu làm như vậy thì về cơ bản, bạn sẽ gộp hai lệnh thành một lệnh phức tạp hỗ trợ cả hai kiểu nhảy PC đó. Vâng. Được rồi. Ethan?
What happens if the result of the register must be hidden on the next? Ah, it's an invalid address. Well, it depends on implementation, right?
Điều gì xảy ra nếu kết quả trong thanh ghi phải được ẩn ở lệnh kế tiếp? À, đó là một địa chỉ không hợp lệ. Điều đó tùy thuộc vào cách hiện thực, đúng không?
How you define this undefined behavior. If you don't do anything, then it's basically SACBOT is actually touching an address that hasn't been actually, or it basically.
Tùy cách bạn định nghĩa hành vi không xác định này. Nếu bạn không làm gì cả, thì về cơ bản là nó sẽ truy cập một địa chỉ chưa được dùng đến.
You could actually do, you could actually do that in your, in your design, but for example, in your instruction memory interface, right?
Bạn có thể xử lý điều đó ngay trong thiết kế của mình, chẳng hạn trong giao diện bộ nhớ lệnh, đúng không?
If you actually detect an odd instruction, then it's up to the implementer. Yeah. Good question. Good discussion. Any other, Brendan?
Nếu phát hiện một lệnh ở địa chỉ lẻ, thì việc xử lý do người hiện thực quyết định. Vâng. Câu hỏi hay. Thảo luận tốt. Còn ai nữa không, Brendan?
If you jump to a label, whether the label could be...
Nếu bạn nhảy tới một nhãn, thì nhãn đó có thể...
When you compile, so compiler needs to guarantee that, right? So compiler, right? So you were actually writing like manually, that is up to the, our program, right?
Khi biên dịch, trình biên dịch cần đảm bảo điều đó, đúng không? Trình biên dịch ấy. Còn nếu bạn tự viết bằng tay, thì đó là việc của chương trình của chúng ta, đúng không?
But compiler can actually guarantee that this label is actually a valid address. So some of the complexity can be uploaded by the software. Good discussion.
Nhưng trình biên dịch có thể đảm bảo nhãn này là một địa chỉ hợp lệ. Vì vậy một phần độ phức tạp có thể được chuyển sang phần mềm. Thảo luận tốt.
Okay. A lot of discussions on jump and branch on the implementation. Let's see. Oh, we have another jump instruction.
Được rồi. Đã có nhiều thảo luận về nhảy và rẽ nhánh trong hiện thực. Xem nào. Ồ, ta còn một lệnh nhảy khác.
This is actually the J format. This is actually a new format.
Đây là định dạng J. Đây là một định dạng mới.
We see this one has actually even more complex encoding here, But it's also mostly, again, for immediate, but it actually doesn't need to actually encode all the other opcode or func3 and the source register.
Ta thấy định dạng này có cách mã hóa còn phức tạp hơn nữa, nhưng nó cũng chủ yếu là cho giá trị tức thời, và không cần mã hóa tất cả các opcode khác hay func3 và thanh ghi nguồn.
So we actually only have 12 bits that actually needed to do opcode and specify the destination register, but the rest of the bits can be actually used for the immediate.
Vì vậy ta chỉ cần 12 bit cho opcode và để chỉ định thanh ghi đích, còn các bit còn lại có thể dùng cho giá trị tức thời.
So this is, again, a jump instruction, right? We're modifying the PC, right?
Đây lại là một lệnh nhảy, đúng không? Ta đang sửa đổi PC, đúng không?
So here, instead of reading from the source register to the increment, we have to actually use PC directly and jump to a PC relative address.
Vậy ở đây, thay vì đọc từ thanh ghi nguồn để lấy giá trị tăng, thì chúng ta phải dùng trực tiếp PC và nhảy tới một địa chỉ tương đối so với PC.
And then, again, similar to JAL instruction, we actually write the return address to a register. That's why we have a destination register. So we'll have the return address to the destination register.
Và sau đó, tương tự như lệnh JAL, chúng ta ghi địa chỉ trả về vào một thanh ghi. Đó là lý do chúng ta có một thanh ghi đích. Vậy địa chỉ trả về sẽ được lưu vào thanh ghi đích.
That's our JAL instruction. We also have a pseudo instruction that jump is basically, we don't need to, we don't care about the return address. We just want to jump to the relative PC address.
Đó là lệnh JAL của chúng ta. Chúng ta cũng có một giả lệnh jump, về cơ bản là, chúng ta không cần, không quan tâm đến địa chỉ trả về. Chúng ta chỉ muốn nhảy tới địa chỉ tương đối so với PC.
So we then, we use jump and then we just set the destination register to be x0 so that we are actually not saving the return address.
Vậy chúng ta dùng jump và đặt thanh ghi đích là x0 để thực sự không lưu địa chỉ trả về.
So what we are doing is basically doing a PC relative jump. We're changing the program counters, and then we store the return address to our destination register.
Vậy về cơ bản, những gì chúng ta làm là một lệnh nhảy tương đối so với PC. Chúng ta thay đổi bộ đếm chương trình, rồi lưu địa chỉ trả về vào thanh ghi đích.
So we also actually, so with this, we basically have 12 bits here, right? So this is actually very similar to the branch instruction, the branch format that we actually mentioned earlier.
Vậy ở đây chúng ta có 12 bit, đúng không? Điều này rất giống với lệnh rẽ nhánh, định dạng rẽ nhánh mà chúng ta đã nhắc tới trước đó.
We can still, we can basically cover with 20 bits, right? So one bit is a signed bit. So we can actually jump to the 19th location, right? We have a signed bit.
Chúng ta vẫn có thể bao phủ bằng 20 bit, đúng không? Một bit là bit dấu. Vậy chúng ta có thể nhảy tới vị trí thứ 19, đúng không? Chúng ta có một bit dấu.
And then this is actually consistent with the B-type format. Each location is two bytes apart, right? To support both 16-bit and the 32-bit instruction, right?
Và điều này nhất quán với định dạng B-type. Mỗi vị trí cách nhau hai byte, đúng không? Để hỗ trợ cả lệnh 16 bit và 32 bit, đúng không?
So you will only do 32-bit instruction. So it's actually to the 18th, right? Because it's two bytes apart. So this is the same as the branch instruction.
Còn bạn sẽ chỉ làm lệnh 32 bit. Vậy thực ra là tới vị trí thứ 18, đúng không? Vì chúng cách nhau hai byte. Vậy điều này giống với lệnh rẽ nhánh.
So that's another, this is actually the J-type instruction. We'll see the majority 20-bit is actually basically dedicated to the immediate encoding.
Và đây là lệnh J-type. Chúng ta thấy phần lớn trong 20 bit về cơ bản được dành cho việc mã hóa số tức thời.
So you will look at the datapath that we need to support this instruction. The majority of the change is basically in the immediate generation, right?
Giờ hãy xem đường dữ liệu mà chúng ta cần để hỗ trợ lệnh này. Phần lớn thay đổi nằm ở khâu tạo số tức thời, đúng không?
We need to actually assemble all the different bits together to produce the 32-bit immediate from the 20-bit value that's already provided by the instruction.
Chúng ta cần ghép tất cả các bit khác nhau lại với nhau để tạo ra số tức thời 32 bit từ giá trị 20 bit đã có sẵn trong lệnh.
You want to execute. Those are the paths that need to be executed. Largely consistent with what we have seen before. The key difference is the immediate generation. Any question, Ryan?
Bạn muốn thực thi. Đó là những đường cần được thực thi. Phần lớn nhất quán với những gì chúng ta đã thấy trước đây. Khác biệt chính là khâu tạo số tức thời. Ryan, bạn có câu hỏi nào không?
Can you clarify again what the generation is doing again? Immediate generation? It's just getting the immediate value? It's just getting the immediate value.
Bạn có thể giải thích lại khâu tạo này làm gì không? Tạo số tức thời? Nó chỉ lấy giá trị số tức thời thôi à? Đúng, chỉ lấy giá trị số tức thời.
So we look back here. So we have our 20-bit immediate here. And then we basically, immediate generation is basically get this to a 32-bit immediate here.
Hãy nhìn lại đây. Chúng ta có số tức thời 20 bit ở đây. Và khâu tạo số tức thời về cơ bản là biến nó thành số tức thời 32 bit ở đây.
32-bit, so zero padding. Well, sign extension. Sign extension, right? Not zero padding. Sign extension, right? And also, yeah, sign extension. And I guess we already talked about it's two bytes apart.
32 bit, vậy là đệm số không. À, mở rộng dấu. Mở rộng dấu, đúng không? Không phải đệm số không. Mở rộng dấu, đúng không? Và đúng vậy, mở rộng dấu. Và tôi nghĩ chúng ta đã nói là chúng cách nhau hai byte.
So we don't save actually the LSB in the instruction format. Mm-hmm. So those are the basic combination that we're seeing. But it takes it in for all the instructions, right?
Nên chúng ta không thực sự lưu LSB trong định dạng lệnh. Vâng. Đó là những cách kết hợp cơ bản mà chúng ta thấy. Nhưng nó áp dụng cho tất cả các lệnh, đúng không?
Finds the immediate in every type of instruction, right? From? From all the different types of instructions, it'll find the immediate. Based on the opcode. Based on the opcode, you will find the immediate.
Tìm giá trị immediate trong mọi loại lệnh, đúng không? Từ? Từ tất cả các loại lệnh khác nhau, nó sẽ tìm ra immediate. Dựa vào opcode. Dựa vào opcode, bạn sẽ tìm được immediate.
Yeah, so when you see the jal opcode, you will actually, this is the immediate. But you do need to assemble this, right? We see this format.
Đúng, nên khi thấy opcode jal, thì thực ra đây chính là immediate. Nhưng bạn vẫn cần ghép nó lại, đúng không? Ta thấy định dạng này.
You do need to assemble this to generate the full immediate. Questions.
Bạn cần ghép nó lại để tạo ra immediate đầy đủ. Có câu hỏi nào không?
So for the questions online, set PC plus PC to offset. Is it right that offset can be positive and negative to the 20th?
Có câu hỏi trực tuyến: đặt PC bằng PC cộng với offset. Offset có thể dương và âm đến 2^20 phải không?
Well, so we mentioned earlier we have 20 bits here.
À, như ta đã nói lúc nãy ở đây ta có 20 bit.
30-bit instruction, right? We have 12 bits here. So we have 20 bits for the immediate. Remember, there is always a signed bit, right? So we signed bits.
Lệnh 32 bit, đúng không? Ở đây ta có 12 bit. Vậy ta có 20 bit cho immediate. Nhớ rằng luôn có một bit dấu, đúng không? Vậy ta có bit dấu.
Now we have actually 19 bits to represent the value. So we jump to the 19th locations.
Giờ thực ra ta có 19 bit để biểu diễn giá trị. Vậy ta nhảy đến 2^19 vị trí.
And you're asking the value. So the value is yes, yes. The value, because it's multiplied, yes, yes. So the value is positive and negative to the 20th. Mm-hmm. Yes, you're right.
Và bạn đang hỏi về giá trị. Vậy giá trị thì đúng, đúng vậy. Giá trị, vì nó được nhân lên, đúng vậy. Vậy giá trị dương và âm đến 2^20. Ừm. Vâng, bạn nói đúng.
OK, any other questions?
Được rồi, còn câu hỏi nào khác không?
OK, so we talk about the jump instruction. Like Carol already mentioned, asked earlier, right? So far, we are talking about immediate.
Được rồi, vậy ta đã nói về lệnh nhảy. Như Carol đã đề cập, đã hỏi lúc nãy, đúng không? Cho đến giờ, ta đang nói về immediate.
We're trying to do as large as possible, that either 12 bits, 13 bits, 20 bits. That's basically the widest immediate that we have seen before, right?
Ta cố làm cho nó lớn nhất có thể, hoặc 12 bit, 13 bit, 20 bit. Đó cơ bản là immediate rộng nhất mà ta đã thấy trước đây, đúng không?
But we're talking about 32-bit values, how we get actually more the higher bits of the immediate or the constant actually represented in our hardware. So that's basically the U-type instruction or upper immediate.
Nhưng ta đang nói về các giá trị 32 bit, vậy làm sao để lấy thêm các bit cao hơn của immediate hay hằng số được biểu diễn trong phần cứng của ta. Đó chính là lệnh kiểu U, hay immediate cao.
So that's what this instruction format is. So U-format will actually get the upper immediate value. So it's still getting the immediate, getting the constant.
Đó là định dạng lệnh này. Vậy định dạng U sẽ lấy giá trị immediate cao. Nên nó vẫn là lấy immediate, lấy hằng số.
But instead of focusing on lower, like so far, our discussion always start from the LSB, either 12 bits or 13 bits, 20 bits.
Nhưng thay vì tập trung vào phần thấp như từ nãy giờ, phần thảo luận của ta luôn bắt đầu từ LSB, hoặc 12 bit, 13 bit, 20 bit.
But then to actually get the higher order bits, we use the U-format to get the upper immediate instruction. This is actually similar to JAL, like the J-type instruction that we have seen before.
Còn để lấy các bit bậc cao hơn, ta dùng định dạng U để lấy lệnh immediate cao. Cái này khá giống JAL, lệnh kiểu J mà ta đã thấy trước đây.
We actually only need 12 bits to represent the opcode and the destination register, right? So those are the minimum that we build. We actually load the data to the destination register.
Thực ra ta chỉ cần 12 bit để biểu diễn opcode và thanh ghi đích, đúng không? Đó là mức tối thiểu mà ta xây dựng. Ta nạp dữ liệu vào thanh ghi đích.
And then we can actually dedicate all the upper 20 bits. So this is another upper 20-bit immediate, right? We get another 20-bit immediate.
Và sau đó ta có thể dành toàn bộ 20 bit cao. Đây là một immediate 20 bit cao khác, đúng không? Ta có thêm một immediate 20 bit.
This is different from the J-type immediate we see earlier in term of the formation, Right? So it's still a 20-bit, but this one is a lot more straightforward.
Cái này khác với immediate kiểu J mà ta thấy trước đó về cách hình thành, đúng không? Nó vẫn là 20 bit, nhưng cái này đơn giản hơn nhiều.
This is basically getting the upper 20 bits of the immediate. So we don't need to do all the bit swizzling.
Cái này cơ bản là lấy 20 bit cao của immediate. Nên ta không cần xáo trộn bit gì cả.
In the J-type instruction, we can just directly grab the upper 20 bits and store in the upper 20 bits of the immediate. So we only have one destination register.
Ở lệnh kiểu J, ta có thể lấy thẳng 20 bit cao và lưu vào 20 bit cao của immediate. Vậy là chúng ta chỉ có một thanh ghi đích.
So we basically store this upper 20 bits in our destination register. So this is related to, I think, some of our discussion we had before, right? Whether a PC is actually a source register.
Về cơ bản, ta lưu 20 bit cao này vào thanh ghi đích. Điều này liên quan đến một phần thảo luận trước đó, đúng không? Đó là việc PC có thực sự là một thanh ghi nguồn hay không.
So we actually have two instructions here. Both are actually loading the data to the upper bits of our register, our destination register. But the source register or source can be different.
Ở đây thực ra ta có hai lệnh. Cả hai đều nạp dữ liệu vào các bit cao của thanh ghi, tức thanh ghi đích. Nhưng thanh ghi nguồn, hay nguồn dữ liệu, có thể khác nhau.
For the LUI, load upper immediate, we basically directly get the upper immediate and concoct with zero-bit LSB, the top zero bits and lower bits, and then directly store in the register.
Với LUI, load upper immediate, ta lấy trực tiếp giá trị tức thời cao rồi ghép với các bit thấp bằng không, phần bit cao và các bit thấp, rồi lưu thẳng vào thanh ghi.
Versus we can also actually treat PC as a source register. For the AUIPC, it's basically adding upper immediate to the PC.
Còn ở trường hợp kia, ta có thể coi PC là một thanh ghi nguồn. Với AUIPC, về cơ bản là cộng giá trị tức thời cao vào PC.
We can actually initialize PC directly so that we can actually use PC and do the PC relative address to add this upper immediate to the PC.
Ta có thể khởi tạo PC trực tiếp để dùng PC và tính địa chỉ tương đối theo PC, tức là cộng giá trị tức thời cao này vào PC.
So we have two ways of actually two instructions. One is the load upper immediate and our AUIPC, we can actually use PC as a register.
Vậy ta có hai cách, tức hai lệnh. Một là load upper immediate, còn AUIPC thì ta có thể dùng PC như một thanh ghi.
So those are the two upper immediate design instructions that we support to actually get to the higher-order bits of our values, our constant.
Đó là hai lệnh giá trị tức thời cao mà ta hỗ trợ để lấy các bit bậc cao của giá trị, tức hằng số của ta.
So if we think about hardware for the upper immediate, you will want to actually load upper immediate to our hardware.
Nếu nghĩ về phần cứng cho giá trị tức thời cao, ta sẽ muốn nạp giá trị tức thời cao vào phần cứng.
Again, we need to actually have a different instruction immediate generation to actually support, but this one is actually a lot straightforward, just getting the upper immediate and the rest of them is actually the same, right?
Một lần nữa, ta cần một kiểu sinh giá trị tức thời khác cho lệnh để hỗ trợ, nhưng cái này đơn giản hơn nhiều, chỉ lấy phần giá trị tức thời cao, còn lại đều giống nhau, đúng không?
We basically load data to the register.
Về cơ bản ta nạp dữ liệu vào thanh ghi.
Versus LUI, one of the sources is actually, we still do this, but one of the sources is actually we're writing PC to the register.
Với LUI, một trong các nguồn thì ta vẫn làm như vậy, nhưng một nguồn ở đây là ta ghi PC vào thanh ghi.
We're adding PC, adding the constants to the PC, so PC is a source register versus a register from register file. So that's how we get to the upper immediate.
Ta cộng hằng số vào PC, nên PC là một thanh ghi nguồn, thay vì thanh ghi từ tệp thanh ghi. Đó là cách ta có được giá trị tức thời cao.
Any questions on upper immediate, how we get it, the 20-bit immediate, how we actually use it?
Có câu hỏi nào về giá trị tức thời cao, cách ta lấy nó, giá trị tức thời 20 bit, và cách dùng nó không?
So the AUIPC, that's just like LUI, right? Is it a jump? Like, does it change the branch destination? Mm-hmm.
AUIPC thì giống như LUI, đúng không? Nó có phải là lệnh nhảy không? Nó có thay đổi đích rẽ nhánh không? Ừm.
It does, it just changes the program. It reads the program counter. Does it write to the program counter? Yeah, so it reads the program counter.
Có, nó chỉ thay đổi chương trình. Nó đọc bộ đếm chương trình. Nó có ghi vào bộ đếm chương trình không? Vâng, nó đọc bộ đếm chương trình.
It writes to the register.
Nó ghi vào thanh ghi.
Question, Brendan?
Brendan, em hỏi đi?
For load upper immediate, it doesn't take in another register, but does it just take X0 and then it'll add the shifted immediate to the destination plus?
Với load upper immediate, nó không lấy thêm thanh ghi nào, vậy nó có lấy X0 rồi cộng giá trị tức thời đã dịch vào đích không?
Yeah, so this could be different implementation. You can have to use X0 as a register to do that, or you can actually have a special mode in your ALU.
Vâng, đây có thể là một cách cài đặt khác. Bạn có thể dùng X0 như một thanh ghi để làm việc đó, hoặc có thể có một chế độ đặc biệt trong ALU.
You just pass the value of A to the output. Don't do anything, right? Yeah, again, this is implementation.
Bạn chỉ cần chuyển giá trị của A ra đầu ra. Không làm gì cả, đúng không? Vâng, một lần nữa, đây là chuyện của cách triển khai.
You can read the X0, or you can just pass A so that you don't need to do anything in the ALU.
Bạn có thể đọc X0, hoặc bạn có thể chỉ cần cho A đi qua để không phải làm gì trong ALU.
Other questions? Johnny?
Còn câu hỏi nào khác không? Johnny?
Oh, for those zeros?
À, về những số không đó phải không?
Yeah, so this is basically how we implement the immediate generation, right? So you can basically just add those zeros in the immediate generation.
Vâng, về cơ bản đây là cách chúng ta triển khai khối sinh số tức thời, đúng không? Vậy bạn chỉ cần thêm những số không đó vào trong khối sinh số tức thời.
This can cut the zeros, yeah, directly get it there, right? So this is the immediate generation.
Có thể cắt bớt các số không, vâng, lấy trực tiếp ra ở đó, đúng không? Đây chính là phần sinh số tức thời.
But back to Ryan's question, but AUIPC can be used with a jump instruction to actually jump to a further range, right?
Nhưng quay lại câu hỏi của Ryan, AUIPC có thể được dùng cùng với một lệnh nhảy để nhảy tới một phạm vi xa hơn, đúng không?
So itself is not a jump, but it's being used combined with a jump because you can actually jump to a further range, right? Now we just jump further. We jump further.
Bản thân nó không phải là lệnh nhảy, nhưng nó được dùng kết hợp với một lệnh nhảy vì nhờ đó bạn có thể nhảy tới phạm vi xa hơn, đúng không? Giờ ta nhảy xa hơn. Ta nhảy xa hơn.
We first do LEPC so that we have a bigger range, and then we do a regular jump instruction so we can actually jump further.
Trước tiên ta thực hiện LEPC để có phạm vi lớn hơn, rồi sau đó ta thực hiện một lệnh nhảy thông thường để thực sự nhảy xa hơn.
But we still have the same problem if we want to jump further, right? We could always want to jump further, right?
Nhưng nếu muốn nhảy xa hơn nữa thì ta vẫn gặp vấn đề tương tự, đúng không? Lúc nào ta cũng có thể muốn nhảy xa hơn, đúng không?
Well, this is a much larger range, right? This is 2 to the 32, right? So this basically covers the memory space. Any other questions? Ethan.
Nhưng đây là một phạm vi lớn hơn nhiều, đúng không? Đây là 2 mũ 32, đúng không? Vậy về cơ bản nó bao phủ toàn bộ không gian bộ nhớ. Còn câu hỏi nào khác không? Ethan.
All of them are 32-bit addressing, yeah.
Tất cả đều là địa chỉ hóa 32 bit, vâng.
Any other comments?
Còn ý kiến nào khác không?
Like why we want to load upper immediate?
Ví dụ như tại sao ta muốn nạp số tức thời phần cao?
Oh, what's the purpose of using the upper immediate? Oh, let's say we want to do, like, addition, add, addition, add a constant, right? So that's the I-type instruction we mentioned earlier.
À, mục đích của việc dùng số tức thời phần cao là gì? À, giả sử ta muốn làm một phép cộng, cộng, cộng một hằng số, đúng không? Đó là lệnh kiểu I mà chúng ta đã nhắc tới trước đó.
It can only cover 12-bit, right? Which means that you can only add a 12-bit constant to your value, right? Let's say you actually have a much bigger value.
Nó chỉ bao được 12 bit, đúng không? Nghĩa là bạn chỉ có thể cộng một hằng số 12 bit vào giá trị của mình, đúng không? Giả sử bạn có một giá trị lớn hơn nhiều.
You just want to do a bigger addition, right? So how to do that? Because you actually need the upper immediate, right?
Bạn muốn thực hiện một phép cộng lớn hơn, đúng không? Vậy làm thế nào? Vì khi đó bạn thực sự cần số tức thời phần cao, đúng không?
If we want to do that, you can actually first, basically, you can think about this as initialize your register, initialize the upper bit of your register.
Nếu muốn làm vậy, trước hết bạn có thể về cơ bản, bạn có thể xem đây là việc khởi tạo thanh ghi của bạn, khởi tạo các bit cao của thanh ghi.
And then you can follow it by a regular add immediate, right? And then you can basically add 32-bit immediate instead of being constrained to the 12-bit immediate, yeah.
Sau đó bạn có thể theo sau bằng một lệnh cộng số tức thời thông thường, đúng không? Và như vậy bạn có thể cộng một số tức thời 32 bit thay vì bị giới hạn ở số tức thời 12 bit, vâng.
Okay, so a lot of instructions, a lot of interesting discussion, right? I just had one more thing on the 64-bit thing.
Được rồi, vậy là có rất nhiều lệnh, rất nhiều thảo luận thú vị, đúng không? Tôi chỉ có thêm một thắc mắc về chuyện 64 bit.
What's the point of having, like, this? Like, I have double the bits, right? But I'm not, the instruction is still 32 long.
Có ích gì khi có cái này? Ví dụ, tôi có số bit gấp đôi, đúng không? Nhưng lệnh vẫn dài 32 bit.
Why wouldn't I make it more detailed? It would be more bits. It won't be super. You use more bits.
Tại sao không làm nó chi tiết hơn? Sẽ có nhiều bit hơn. Nó sẽ không quá tuyệt. Bạn dùng nhiều bit hơn.
So you would actually have a 60, you are talking about 64 bits, I say. Yeah. Why wait? So out of 32 bits, Like, wouldn't we want it to be long?
Vậy thực ra bạn sẽ có 60, ý bạn là 64 bit, đúng không. Vâng. Sao lại phải chờ? Vậy trong 32 bit, Chẳng phải ta muốn nó dài hơn sao?
Oh, oh, oh, oh, oh, sure, sure. So first, the trade-off is basically whether we also want to make all the, like, for 64-bit, make the instruction basically to become 64-bit, right?
À, à, à, à, à, đúng rồi, đúng rồi. Trước hết, sự đánh đổi về cơ bản là liệu ta có muốn làm cho tất cả, chẳng hạn với 64 bit, biến lệnh thành lệnh 64 bit hay không, đúng không?
So that's one way of designing.
Đó là một cách thiết kế.
Alternatively, you could still use a 32-bit ISA, but you actually specify, when you write the 32 bits to a 64-bit register, whether you're writing to the upper 32 bits or lower 32 bits, right?
Cách khác là vẫn dùng ISA 32 bit, nhưng bạn chỉ định rõ, khi ghi 32 bit vào một thanh ghi 64 bit, là bạn đang ghi vào 32 bit cao hay 32 bit thấp, đúng không?
So it's a trade-off. You can achieve the same thing. You want to initialize a 64-bit value. You can, so you read the 64-bit extension.
Vậy đây là một sự đánh đổi. Bạn có thể đạt được cùng một kết quả. Bạn muốn khởi tạo một giá trị 64 bit. Bạn có thể làm được, nên bạn đọc phần mở rộng 64 bit.
They actually have specific instructions to actually assign value to the upper 32 and the lower 32 bits. So that's how they do that versus making all the instructions much bigger.
Họ thực sự có các lệnh riêng để gán giá trị cho 32 bit cao và 32 bit thấp. Đó là cách họ làm, thay vì làm cho mọi lệnh dài hơn nhiều.
So you could do it that way. You could just do it the other way.
Vậy bạn có thể làm theo cách đó. Hoặc làm theo cách còn lại.
Yeah, that's an alternative, but the RISC-V spec decided to do this with 32-bit instead of making every instruction too long. Yeah, because if the instruction is long, your code is not very compact.
Vâng, đó là một phương án thay thế, nhưng đặc tả RISC-V đã quyết định dùng 32 bit thay vì làm cho mọi lệnh quá dài. Vâng, vì nếu lệnh dài thì mã của bạn không gọn lắm.
Then you have a lot of I-cache misses, right? That's a problem we discussed earlier.
Rồi bạn sẽ có nhiều I-cache miss, đúng không? Đó là vấn đề chúng ta đã thảo luận trước đó.
Yeah, you can, even for 64-bit ISA, you can actually assign explicitly to the upper or lower 32 bits to actually do the operation.
Vâng, bạn có thể, ngay cả với ISA 64 bit, bạn vẫn có thể chỉ định rõ 32 bit cao hoặc thấp để thực hiện phép toán.
Yeah, I see. Okay, well, a lot of very good discussion. This is basically the complete 32-bit RISC-V integer RISC-V datapath.
Vâng, tôi hiểu. Được rồi, đã có nhiều thảo luận rất hay. Đây về cơ bản là đường dữ liệu RISC-V số nguyên 32 bit hoàn chỉnh.
We support all the six instruction types. Start from R type, register to register, immediate. We mentioned a lot about immediate generation. Store, right?
Chúng ta hỗ trợ cả sáu loại lệnh. Bắt đầu từ loại R, thanh ghi với thanh ghi, và giá trị tức thời. Chúng ta đã nói nhiều về việc sinh giá trị tức thời. Còn lệnh store, đúng không?
We also want to do write enable to actually store to memory. We talk about branch, right? We have our branch comparator so that we can change the PC, right?
Chúng ta cũng cần write enable để lưu vào bộ nhớ. Chúng ta đã nói về lệnh rẽ nhánh, đúng không? Chúng ta có bộ so sánh rẽ nhánh để có thể thay đổi PC, đúng không?
So the PC is not only PC plus four, but also from ALU. We talked about the jump so that we can actually do unconditional jump. Also talk about U type.
Vậy PC không chỉ là PC cộng bốn, mà còn có thể đến từ ALU. Chúng ta đã nói về lệnh nhảy để có thể thực hiện nhảy không điều kiện. Cũng đã nói về loại U.
In the immediate generation, we can actually generate the upper immediate. So that's all the instructions that we can actually support in our RISC-V.
Trong khối sinh giá trị tức thời, chúng ta có thể sinh giá trị tức thời cao. Đó là tất cả các lệnh mà chúng ta có thể hỗ trợ trong RISC-V của mình.
So those are all the instructions that we support. This will also be the instruction set you actually want to implement in your final project.
Đó là tất cả các lệnh mà chúng ta hỗ trợ. Đây cũng sẽ là tập lệnh mà các bạn cần hiện thực trong đồ án cuối kỳ.
This is a very compact RISC-V, not a lot of instructions. That actually makes it doable as a course project. And you can actually run basically any C program.
Đây là một RISC-V rất gọn, không có nhiều lệnh. Điều đó làm cho nó khả thi như một đồ án môn học. Và về cơ bản bạn có thể chạy bất kỳ chương trình C nào.
We also provide a lot of tests that will help you to test your design. So this will be the ISA that we will use for your final project.
Chúng tôi cũng cung cấp nhiều bài kiểm thử giúp các bạn kiểm tra thiết kế của mình. Vậy đây sẽ là ISA mà chúng ta dùng cho đồ án cuối kỳ của các bạn.
And you will actually be able to implement your design in either FPGA or ASIC flow and run a list of programs actually on this hardware.
Và các bạn thực sự sẽ có thể hiện thực thiết kế của mình theo quy trình FPGA hoặc ASIC và chạy một danh sách các chương trình ngay trên phần cứng này.
A quick recap. So those are all the instructions we have seen before. Again, we try to make things as consistent as possible.
Nhắc lại nhanh. Đây là tất cả các lệnh mà chúng ta đã thấy trước đó. Một lần nữa, chúng tôi cố gắng làm cho mọi thứ nhất quán nhất có thể.
You'll see across different formats, there are also some consistencies to make it easier to decode. And those cover all the different six types of instructions that we want to implement.
Các bạn sẽ thấy giữa các định dạng khác nhau, cũng có một số điểm nhất quán để việc giải mã dễ dàng hơn. Và chúng bao quát toàn bộ sáu loại lệnh khác nhau mà chúng ta muốn hiện thực.
Before I move to the announcement, any questions, comments? Already have a lot. Johnny.
Trước khi chuyển sang phần thông báo, có câu hỏi hay ý kiến nào không? Đã có nhiều rồi. Johnny.
I like whether there are motivations to make the ISA more complex.
Em muốn hỏi liệu có động cơ nào để làm cho ISA phức tạp hơn không.
So it's a pretty big question. How is the ISA designed? So you were actually having this discussion.
Đây là một câu hỏi khá lớn. ISA được thiết kế như thế nào? Vậy là các bạn đang thảo luận về chuyện này.
And I say 20, 30 years ago, the RISC versus CISC battle was one of the most important discussions, especially in the hardware industry, right?
Và tôi cho rằng cách đây 20, 30 năm, cuộc chiến RISC đối đầu CISC là một trong những thảo luận quan trọng nhất, đặc biệt trong ngành phần cứng, đúng không?
There were a lot of discussions about the pros and the cons of different designs. And especially here, Berkeley, and it's Berkeley, Stanford, and IBM also have their RISC design in the 60s, right?
Đã có rất nhiều tranh luận về ưu và nhược điểm của các thiết kế khác nhau. Và đặc biệt ở đây, Berkeley, tức là Berkeley, Stanford, và IBM cũng có thiết kế RISC của họ vào những năm 60, đúng không?
So they proposed the RISC-based architecture and made the argument that with a reduced instruction set architecture, it's a lot easier for the compiler, especially from a compiler point of view, to actually generate programs instead of actually having a lot of weird, weird instructions.
Họ đã đề xuất kiến trúc dựa trên RISC và lập luận rằng với một kiến trúc tập lệnh rút gọn, trình biên dịch sẽ dễ dàng hơn nhiều, đặc biệt xét từ góc nhìn của trình biên dịch, trong việc sinh chương trình, thay vì phải có rất nhiều lệnh kỳ quặc, kỳ quặc.
So it was a very important and a very hot topic, like 20, like 30, 40 years ago. These days, the ISA discussion is actually less about RISC versus CISC.
Vì vậy đó từng là một chủ đề rất quan trọng và rất nóng, cách đây khoảng 20, 30, 40 năm. Ngày nay, thảo luận về ISA không còn xoay quanh RISC đối đầu CISC nhiều nữa.
It's actually less relevant today. Sometimes you will actually read articles saying, "Oh, this processor is more efficient because it's actually a RISC ISA." It's actually less relevant these days.
Thực ra nó ít liên quan hơn ngày nay. Đôi khi các bạn sẽ đọc những bài báo nói rằng, "Ồ, bộ xử lý này hiệu quả hơn vì nó là ISA RISC." Thực ra ngày nay điều đó ít liên quan hơn.
Actually, even for CISC instruction, the x86 instruction is actually eventually decoded into microcode and being executed. So the RISC versus CISC instruction debate is actually less relevant today.
Thậm chí với các lệnh CISC, lệnh x86 cuối cùng cũng được giải mã thành vi mã và được thực thi. Vì vậy cuộc tranh luận RISC đối đầu CISC ngày nay ít liên quan hơn.
A lot of the discussion is actually, especially with the whole RISC-V movement, it's actually more about the governance model of the instruction set, how we actually maintain those.
Phần lớn thảo luận hiện nay, đặc biệt với cả phong trào RISC-V, thực ra nói về mô hình quản trị của tập lệnh, tức là chúng ta duy trì chúng như thế nào.
So the benefit of RISC-V is actually it's an open instruction set.
Lợi ích của RISC-V là nó là một tập lệnh mở.
We have the different working groups and everyone can contribute and they discuss, versus either ARM ISA or x86 ISA, which is actually proprietary.
Có các nhóm làm việc khác nhau, ai cũng có thể đóng góp và họ thảo luận, so với ISA ARM hay ISA x86, vốn là độc quyền.
So that difference is actually making a bigger, that's actually a bigger difference with the ISA design.
Vậy nên sự khác biệt đó tạo ra một khác biệt lớn hơn trong thiết kế ISA.
In terms of adding new functionality, adding new complexity, that's basically related to the governance model of the different ISA foundation. It's the same as a software, any kind of open source project.
Về việc thêm chức năng mới, thêm độ phức tạp mới, về cơ bản điều đó liên quan đến mô hình quản trị của từng tổ chức ISA. Nó giống như phần mềm, bất kỳ dự án mã nguồn mở nào.
Everyone is using that. Everyone benefits from it. But then we actually want to make the change, how we consolidate different inputs and make an unbiased decision to decide what kind of features are needed.
Mọi người đều dùng nó. Mọi người đều hưởng lợi từ nó. Nhưng khi chúng ta thực sự muốn thay đổi, cách chúng ta tổng hợp các ý kiến đóng góp khác nhau và đưa ra quyết định khách quan để xác định cần những tính năng nào.
So a lot of discussion on the governance model for this kind of open source ISA project that kind of adding different complexity.
Vì vậy có rất nhiều thảo luận về mô hình quản trị cho loại dự án ISA mã nguồn mở này, tức là việc bổ sung thêm những độ phức tạp khác nhau.
So that's why there are some instruction extensions being evaluated in different working groups.
Đó là lý do có một số phần mở rộng tập lệnh đang được đánh giá trong các nhóm làm việc khác nhau.
But we do see at least the majority, at least we want to have a stable instruction set to make sure everyone can use it.
Nhưng ít nhất đối với phần lớn, chúng ta muốn có một tập lệnh ổn định để đảm bảo ai cũng có thể sử dụng.
Yeah, so that's, I guess, more the complexity of ISA management these days. Good question. Any other questions? Yes, I...
Vâng, tôi nghĩ đó là độ phức tạp của việc quản lý ISA ngày nay. Câu hỏi hay. Còn câu hỏi nào khác không? Vâng, em...
All the slide clusters are going to be virtual web space. Does that mean that the slide can support programs with all clusters that are going for the device frame?
Tất cả các cụm slide sẽ nằm trong không gian web ảo. Vậy điều đó có nghĩa là slide có thể hỗ trợ các chương trình với tất cả các cụm đang hướng tới khung thiết bị không ạ?
Oh, oh, oh, oh, that's a correction. I didn't mean that. So there's a slide that supports 64-bit address. Like instruction is 32-bit, but the address space can be 64-bit. Yeah, yeah.
À, à, à, à, đó là một chỗ cần đính chính. Ý tôi không phải vậy. Có một slide hỗ trợ địa chỉ 64-bit. Lệnh thì 32-bit, nhưng không gian địa chỉ có thể là 64-bit. Vâng, vâng.
Oh, excuse me, sorry. There's instruction in 32-bit. Yeah, mm-hmm. Yeah. Is there a question online? Yes, I was going to address my question.
À, xin lỗi. Lệnh là 32-bit. Vâng, ừm. Vâng. Có câu hỏi nào trực tuyến không? Vâng, em định hỏi câu hỏi của em.
So I see that in J-type instruction, we don't store the zero bit because always zero.
Em thấy trong lệnh kiểu J, chúng ta không lưu bit 0 vì nó luôn bằng không.
So once you figure out the 20 bits, bits one to 20, we always add zero to the point of immediate before we add to PC or jump instruction.
Vậy sau khi xác định được 20 bit, từ bit 1 đến 20, chúng ta luôn thêm bit 0 vào giá trị immediate trước khi cộng vào PC hoặc lệnh nhảy.
Yes, so we assemble this into a 32-bit value, right? So we add the zero, yeah, mm-hmm. Yes, and one more question.
Đúng, chúng ta ghép nó thành một giá trị 32-bit, đúng không? Nên chúng ta thêm bit 0, vâng, ừm. Vâng, và thêm một câu hỏi nữa.
I noticed that in slide 26, we have a MUX for LDX. Why do we have that?
Em thấy ở slide 26 có một MUX cho LDX. Tại sao lại có nó ạ?
Good catch, Anthony. So Anthony is asking, so for slide 26, we actually have a MUX for LDX.
Phát hiện hay đấy, Anthony. Anthony hỏi là ở slide 26 thực sự có một MUX cho LDX.
Any guesses? What are we trying to do with this MUX? Or this control signal? Mm-hmm.
Có ai đoán được không? Chúng ta định dùng MUX này, hay tín hiệu điều khiển này, để làm gì? Ừm.
But this one, outside the memory, the data read port.
Nhưng cái này nằm bên ngoài bộ nhớ, ở cổng đọc dữ liệu.
So this is for load, right? So for load, but we want to manipulate the data after we load from memory.
Vậy đây là cho lệnh load, đúng không? Cho lệnh load, nhưng chúng ta muốn xử lý dữ liệu sau khi load từ bộ nhớ.
The operand, what? What did you say, Anthony? The operands, excuse me, like the bits of the buffer, right? Yeah, yeah, if you recall the load instruction, right?
Toán hạng, gì cơ? Em nói gì, Anthony? Các toán hạng, xin lỗi, ví dụ như các bit của bộ đệm, đúng không? Vâng, nếu các em nhớ lại lệnh load, đúng không?
We don't only have a single load instruction. Remember the load byte, load half words? We actually can load actually different parts on the address, right, the memory.
Chúng ta không chỉ có một lệnh load duy nhất. Còn nhớ load byte, load half word không? Thực ra chúng ta có thể load các phần khác nhau tại địa chỉ, tức là trong bộ nhớ, đúng không?
So this is basically doing the load data selection. We read to the full 32-bit, but sometimes we only use the buffer, right? And that way, they are extended. Sometimes a sign extended.
Vậy về cơ bản đây là việc chọn dữ liệu load. Chúng ta đọc đủ 32-bit, nhưng đôi khi chỉ dùng phần bộ đệm, đúng không? Và như vậy chúng được mở rộng. Đôi khi là mở rộng dấu.
Sometimes we use a half word. So this is basically to handle all the different variants of the load instruction.
Đôi khi chúng ta dùng một half word. Vậy về cơ bản đây là để xử lý tất cả các biến thể khác nhau của lệnh load.
How many bits do we have in LD selection?
LD selection có bao nhiêu bit?
What's the question again? How many bits do we have in LD selection? How many select bits? How do we select this? You're asking how do we decide?
Câu hỏi là gì nhỉ? LD selection có bao nhiêu bit? Bao nhiêu bit chọn? Chúng ta chọn cái này như thế nào? Bạn đang hỏi là chúng ta quyết định ra sao?
How many, the number of bits. The number of bits? Yeah. You mean how many bits in this LD select signal? Is that the question?
Bao nhiêu, ý em là số lượng bit. Số bit ạ? Ừ. Ý bạn là tín hiệu LD select này có bao nhiêu bit? Câu hỏi là vậy phải không?
Yeah, that's exactly what I'm asking. Okay, so we basically want to support load byte, load half word and load word, right?
Vâng, đúng là điều em đang hỏi. Được rồi, về cơ bản chúng ta muốn hỗ trợ load byte, load half word và load word, đúng không?
So those are three scenarios which we actually need to get the different part of the address, a different part of the data, right? So at least two bits here.
Vậy là có ba trường hợp mà chúng ta thực sự cần để lấy các phần khác nhau của địa chỉ, các phần khác nhau của dữ liệu, đúng không? Nên ở đây cần ít nhất hai bit.
Does it answer your question, Anthony? Yeah, it answers that. Thank you. Okay. Okay, good. We have a long discussion.
Vậy đã trả lời câu hỏi của em chưa, Anthony? Vâng, đã trả lời rồi ạ. Cảm ơn thầy. Được rồi. Tốt. Chúng ta đã thảo luận khá lâu.
I guess we'll just, not a lot of things to announce. Our lab four starts this week. It's a two-week lab and moving forward, every lab will be two-week.
Chắc là cũng không có nhiều thứ cần thông báo. Lab 4 bắt đầu từ tuần này. Đây là lab kéo dài hai tuần, và từ giờ trở đi lab nào cũng kéo dài hai tuần.
We do have a homework due this week and we'll have a new homework coming out. It should be pretty short, mostly just getting you folks familiar with the RISC-V ISA again.
Tuần này có một bài tập về nhà đến hạn và sẽ có một bài tập mới được đưa ra. Bài đó sẽ khá ngắn, chủ yếu giúp các bạn làm quen lại với RISC-V ISA.
So it will be a new homework. Any questions? Yeah, I have a question back to the opcodes, back to the codings, the other thing.
Vậy sẽ có một bài tập mới. Có câu hỏi nào không? Vâng, em có một câu hỏi quay lại phần opcode, quay lại phần mã hóa, một điều khác ạ.
So you said before, like some of the reasons why we kept the 11 bit when we typed in that position was the same.
Trước đó thầy nói một trong những lý do chúng ta giữ bit 11 ở cùng một vị trí khi mã hóa các kiểu lệnh là như vậy.
And the reason we're doing that, I guess, is so we don't have to add more units to figure out how to decode it and send it, right?
Và lý do làm vậy, em đoán, là để không phải thêm các khối để tìm cách giải mã rồi gửi đi, đúng không ạ?
So it seems like the language is functioning as a way to simplify the circuit or simplify the actual end of the circuit.
Nên có vẻ như ngôn ngữ này đóng vai trò như một cách để đơn giản hóa mạch, hay đơn giản hóa phần cuối của mạch.
Right, right. So is there a more fundamental reason why this is laid out?
Vâng. Vậy có lý do nào cơ bản hơn cho cách bố trí này không ạ?
Like, in other words, is there an optimal way to end up making your circuit digitally that the person who created these opcodes had in mind? Like, is there, you know what I'm saying? Oh.
Ý em là, có cách tối ưu nào để xây dựng mạch số mà người tạo ra các opcode này đã nghĩ tới không ạ? Thầy hiểu ý em chứ ạ? À.
It seems like it was laid out this way for a reason that would make it be as fast as possible.
Có vẻ như nó được bố trí như vậy vì một lý do giúp mạch chạy nhanh nhất có thể.
And it's like a balance between, like, how many units you have versus the speed. So how is it, like, done?
Và đó là sự cân bằng giữa số lượng khối và tốc độ. Vậy người ta đã làm điều đó như thế nào ạ?
Was it made for the fastest speed and you don't care how many units you have to have? Or is it, like, I don't know. I don't know.
Nó được thiết kế để có tốc độ nhanh nhất và không quan tâm phải dùng bao nhiêu khối? Hay là, em cũng không biết nữa.
Like, if there's a fastest way for reading to, like, figure out what instruction you have and send it to the next part of the code. I see.
Kiểu như có cách nhanh nhất để đọc, xác định đó là lệnh gì rồi gửi nó tới phần tiếp theo. Tôi hiểu rồi.
So all we are doing is basically grab certain bits from the instruction and the copy certain bits to the immediate. That's basically all the operation we're doing, right?
Về cơ bản, tất cả những gì chúng ta làm là lấy một số bit nhất định từ lệnh rồi sao chép chúng vào immediate. Về cơ bản đó là toàn bộ thao tác chúng ta thực hiện, đúng không?
So all the design, part of the design, what they're trying to do is that we can copy as consistently as possible.
Vậy trong toàn bộ thiết kế, một phần của thiết kế, điều họ cố gắng làm là để chúng ta có thể sao chép nhất quán nhất có thể.
So here, as you mentioned, for those four bits, we can basically do the same wiring, right? But here we actually need to do two scenarios, right?
Vậy ở đây, như bạn đã nói, với bốn bit này, về cơ bản chúng ta có thể đi dây giống nhau, đúng không? Nhưng ở đây chúng ta thực sự cần xử lý hai trường hợp, đúng không?
What this translates eventually to digital circuit is basically a mux, right? So it depends on the opcode.
Cuối cùng, điều này được chuyển thành mạch số về cơ bản là một mux, đúng không? Vậy nó phụ thuộc vào opcode.
So basically, 11th bit of the immediate have two sources there. Yeah, exactly. So is there, like, I don't know. Like, it's an open source thing, I guess.
Về cơ bản, bit thứ 11 của immediate có hai nguồn. Vâng, chính xác. Vậy có, kiểu như, em không biết nữa. Kiểu như, nó là thứ mã nguồn mở, em đoán vậy.
So to a degree, is there, like, a fastest implementation of RISC-V? It seems like there's only one fast way, right? There's only...
Vậy ở mức độ nào đó, có cách triển khai RISC-V nhanh nhất không? Có vẻ như chỉ có một cách nhanh, đúng không? Chỉ có...
Like, there should be a minimal amount of architecture to do everything. All right. So I guess one thing you can say, you can reduce the number of muxes needed, right?
Kiểu như, hẳn phải có một kiến trúc tối thiểu để làm mọi thứ. Được rồi. Vậy em đoán một điều có thể nói là bạn có thể giảm số lượng mux cần dùng, đúng không?
Basically here, like, different scenarios. But this is actually just a small part of the RISC-V design. It is important.
Về cơ bản ở đây, là các trường hợp khác nhau. Nhưng đây thực ra chỉ là một phần nhỏ của thiết kế RISC-V. Nó quan trọng.
The length of the immediate generation and complexity of the design could actually change the speed. And actually, the immediate generation is actually one of the most time-consuming modules for this microarchitecture.
Độ dài của khâu sinh immediate và độ phức tạp của thiết kế thực sự có thể thay đổi tốc độ. Và thực ra, sinh immediate là một trong những môdun tốn thời gian nhất của vi kiến trúc này.
But there are also other components. And we'll talk about pipelining later. That could also change the speed.
Nhưng cũng còn các thành phần khác. Và chúng ta sẽ nói về pipelining sau. Điều đó cũng có thể thay đổi tốc độ.
I don't know whether there is, absolutely, theoretically, a way to prove there is the most efficient implementation, per se. I guess we can at least quantitate it.
Tôi không biết liệu có hay không, một cách tuyệt đối, về mặt lý thuyết, một cách để chứng minh có triển khai hiệu quả nhất, nói đúng nghĩa. Tôi đoán ít nhất chúng ta có thể định lượng nó.
It's always microarchitecture-dependent, technology-dependent, which, yeah, there are, like, lots of factors. There's a lot of factors. Like, it seems like, for instance, like, say we're checking, oh, is it this instruction?
Nó luôn phụ thuộc vào vi kiến trúc, phụ thuộc vào công nghệ, tức là, vâng, có rất nhiều yếu tố. Có rất nhiều yếu tố. Kiểu như, có vẻ như, chẳng hạn, giả sử chúng ta đang kiểm tra, ồ, có phải lệnh này không?
We might not have to check every bit, right? Yeah, yeah. We only have to check, like, maybe x amount. Right, right.
Có thể chúng ta không phải kiểm tra mọi bit, đúng không? Vâng, vâng. Có thể chúng ta chỉ cần kiểm tra x bit nào đó. Đúng, đúng.
Is there a way to determine, like, can they lay it out in a way where it's, like? Right. We don't have time to go through that.
Có cách nào để xác định, kiểu như, họ có thể bố trí theo cách mà, kiểu như? Đúng. Chúng ta không có thời gian để đi qua phần đó.
But when we talk about the control, you will actually see we only check, actually, a small set of bits to determine the operation.
Nhưng khi nói về điều khiển, bạn sẽ thấy chúng ta chỉ kiểm tra một tập nhỏ các bit để xác định phép toán.
We'll talk about the control operation next lecture. Well, good to see you all. I'll see you next week.
Chúng ta sẽ nói về phép điều khiển ở bài giảng tới. Rất vui được gặp các bạn. Hẹn gặp lại các bạn vào tuần sau.
Đăng nhập để đánh giá học liệu này.
Đăng nhập để bình luận — chưa ai bình luận về học liệu này.
Không có khóa học liên quan.