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. Good to see you again. Welcome to EECS 151/251A, Introduction to Digital Design and Integrated Circuits. We are almost halfway through our semester.
Được rồi, chào buổi sáng mọi người. Rất vui được gặp lại các bạn. Chào mừng các bạn đến với EECS 151/251A, Nhập môn Thiết kế số và Mạch tích hợp. Chúng ta đã đi gần được nửa học kỳ.
At this point, we're going to actually wrap up our discussion on RISC-V, as I say, today, before we transition to actually implementation, the CMOS logic.
Đến thời điểm này, chúng ta sẽ kết thúc phần thảo luận về RISC-V, như tôi đã nói, trong hôm nay, trước khi chuyển sang phần hiện thực hóa, tức là logic CMOS.
In particular, briefly talk about FPGA this Thursday, and I'll talk a little bit later, we'll actually have a guest lecture next Monday.
Cụ thể, chúng ta sẽ nói ngắn gọn về FPGA vào thứ Năm này, và lát nữa tôi sẽ nói thêm, thứ Hai tuần sau chúng ta sẽ có một bài giảng của khách mời.
So have an FPGA module that will transition to CMOS, which is one of the most important transistor technologies that has been actually very popular, used for the past three decades, and in the foreseeable future it will also still play a very important role in the semiconductor industry.
Vậy sẽ có một mô-đun về FPGA để chuyển tiếp sang CMOS, một trong những công nghệ transistor quan trọng nhất, đã rất phổ biến và được sử dụng trong ba thập kỷ qua, và trong tương lai gần nó vẫn sẽ đóng một vai trò rất quan trọng trong ngành công nghiệp bán dẫn.
So with that, before we start our topic today in talking about RISC-V pipeline, it'll be interesting to see some exciting developments in, I guess we call, the semiconductor industry, but it's pretty broad, because a lot of vendors, a lot of actually companies are making their own silicons.
Vậy trước khi bắt đầu chủ đề hôm nay về đường ống RISC-V, sẽ khá thú vị nếu xem qua một vài diễn biến đáng chú ý trong ngành mà ta gọi là công nghiệp bán dẫn, nhưng nó khá rộng, vì có rất nhiều nhà cung cấp, rất nhiều công ty đang tự sản xuất chip silicon của riêng mình.
We talk about different startups, we talk about wafer scale computing, and there's actually another style of wafer scale computing that is actually introduced more recently by Tesla.
Chúng ta đã nói về các công ty khởi nghiệp khác nhau, về tính toán cỡ wafer, và còn có một kiểu tính toán cỡ wafer khác được Tesla giới thiệu gần đây hơn.
So we see Tesla as a self driving car company, right?
Chúng ta xem Tesla là công ty xe tự lái, đúng không?
It's actually an automotive company, but especially more recently, in the past couple of years, they also have actually started making their own silicon.
Thực ra đó là một công ty ô tô, nhưng đặc biệt trong vài năm gần đây, họ cũng đã bắt đầu tự chế tạo silicon.
So this is a very interesting trend in today's generally the technology area, where when software or system companies, either Google or Tesla, they have a lot of very important use cases, they have their application.
Đây là một xu hướng rất thú vị trong lĩnh vực công nghệ ngày nay, khi các công ty phần mềm hay hệ thống, như Google hoặc Tesla, có rất nhiều trường hợp sử dụng quan trọng, có các ứng dụng của riêng họ.
They see that demand for more computing power first hand, and whatever available on the market these days are not able to meet the compute demand for their internal use cases.
Họ trực tiếp thấy nhu cầu về sức mạnh tính toán nhiều hơn, và những gì hiện có trên thị trường ngày nay không đáp ứng được nhu cầu tính toán cho các trường hợp sử dụng nội bộ của họ.
These are Google's tensor processing unit for machine learning, or their transcoding unit for their data center, Or in this case, for Tesla, machine learning efficient, the training and inference machine learning unit for their self driving car.
Đó là tensor processing unit của Google cho học máy, hoặc bộ chuyển mã (transcoding unit) cho trung tâm dữ liệu của họ, hoặc trong trường hợp này, với Tesla, là đơn vị học máy hiệu quả, đơn vị huấn luyện và suy luận học máy cho xe tự lái của họ.
In a lot of scenarios, we see that more and more often these days, those companies, again traditional system software, data center, cloud providers, then they started, instead of waiting for other Silicon companies like Intel and Nvidia or other companies to deliver silicon that actually meet their demand,
Trong nhiều tình huống, chúng ta thấy ngày càng thường xuyên hơn, những công ty này, lại là các công ty phần mềm hệ thống truyền thống, trung tâm dữ liệu, nhà cung cấp đám mây, đã bắt đầu thay vì chờ các công ty silicon khác như Intel và Nvidia hoặc các công ty khác cung cấp chip đáp ứng nhu cầu của mình,
they start building their own Silicon. So that's why Tesla actually started building their Silicon a couple years ago.
họ bắt đầu tự xây dựng silicon của riêng mình. Đó là lý do Tesla đã bắt đầu xây dựng silicon của họ từ vài năm trước.
They have, you actually releasing details in the past couple years, they had a talk at Hot Chips. We talked about Hot Chips, right? Very important chip conference.
Họ đã công bố các chi tiết trong vài năm qua, họ có một bài trình bày tại Hot Chips. Chúng ta đã nói về Hot Chips rồi, đúng không? Một hội nghị chip rất quan trọng.
It's always in the Bay Area every year.
Hội nghị luôn được tổ chức ở Bay Area hằng năm.
So they really reviewed the micro architecture detail last year at Hot Chips, and this year they actually have two talks on their Dojo system-wise, on the micro architecture.
Họ đã trình bày chi tiết về vi kiến trúc tại Hot Chips năm ngoái, và năm nay họ có hai bài trình bày về hệ thống Dojo của họ, về vi kiến trúc.
The other is actually on how they are actually using this Dojo tile, or Dojo chip, and then assemble a really a supercomputer by leveraging TSMC's chip on wafer technology.
Bài còn lại nói về cách họ dùng tile Dojo này, hay chip Dojo, rồi lắp ráp thành một siêu máy tính thực thụ bằng cách tận dụng công nghệ chip on wafer của TSMC.
So they are also doing another different style of wafer scale computing. It's very interesting to look at.
Vậy là họ cũng đang làm một kiểu điện toán quy mô wafer khác. Rất thú vị để xem.
Their micro architecture is basically what people call a spatial array these days, basically a parallel architecture with many computing units in parallel.
Vi kiến trúc của họ về cơ bản là thứ mà ngày nay người ta gọi là spatial array, tức là một kiến trúc song song với nhiều đơn vị tính toán chạy song song.
So they also have, in their own design, and then the goal is basically to meet their self driving car requirement.
Họ cũng có, trong thiết kế riêng của mình, và mục tiêu về cơ bản là đáp ứng yêu cầu cho xe tự lái của họ.
After fabricating each chip, they basically, the basic assemble what they call known good dies, basically assemble 25 different chips, actually putting them together to actually build a super node.
Sau khi chế tạo từng chip, về cơ bản họ lắp ráp những gì họ gọi là known good dies, tức là ghép 25 chip khác nhau, đặt chúng lại với nhau để tạo thành một super node.
And guess, how much power does this kind of super node actually burn? This is designed for self driving cars, need to be very efficient for machine learning.
Và thử đoán xem, một super node như thế tiêu thụ bao nhiêu điện năng? Nó được thiết kế cho xe tự lái, nên phải rất hiệu quả cho machine learning.
Over 28 watts? Oh, what's that, typical CPU GPU server power these days? Seven, I will get included, right?
Hơn 28 watt? Ồ, vậy công suất của một máy chủ CPU GPU điển hình ngày nay là bao nhiêu? Bảy, tôi sẽ tính cả vào, đúng không?
So typical CPU is like, especially large scale GPU 700, is more like bigger GPU. CPU is more like 200, 300 watts. It's pretty big.
GPU điển hình, nhất là GPU quy mô lớn thì khoảng 700, tức là GPU lớn hơn. CPU thì khoảng 200, 300 watt. Khá lớn rồi.
They are talking about putting multiple things together, like more like wafer scale. How much power does this thing, for 15 kilowatt, you have the exact number?
Họ đang nói đến việc đặt nhiều thứ lại với nhau, giống như quy mô wafer hơn. Thứ này tiêu thụ bao nhiêu điện, 15 kilowatt, bạn có con số chính xác không?
Yes, this thing actually 15 kilowatts. It's almost like an appliance. So this is very power consuming. It's like very, actually look at all those metals, all those infrastructure there.
Đúng, thứ này thực sự là 15 kilowatt. Gần như một thiết bị gia dụng. Vậy là nó rất tốn điện. Cứ nhìn tất cả những phần kim loại, toàn bộ hạ tầng ở đó mà xem.
Basically, while you need to power a car, right? So a lot of computation going on. And then they actually assemble multiple of them in their data center to actually do a large scale inference.
Về cơ bản là bạn còn phải cấp điện cho một chiếc xe, đúng không? Nên có rất nhiều tính toán diễn ra. Và rồi họ lắp ghép nhiều cái như vậy trong trung tâm dữ liệu để thực hiện suy luận quy mô lớn.
Yes, exactly, 15k, 15 kilowatts. So they're using TSMC. We talked about their chip on wafer technology. Any idea which generational technology node they're using? Which nanometer?
Đúng vậy, 15k, 15 kilowatt. Họ dùng TSMC. Chúng ta đã nói về công nghệ chip on wafer của họ. Có ai đoán được họ dùng node công nghệ thế hệ nào không? Bao nhiêu nanomet?
We talked about a different nanometer node from the five. It's not that advanced yet. So this one is actually released last year.
Chúng ta đã nói về một node nanomet khác với node năm. Nó chưa tiên tiến đến thế. Cái này mới được công bố năm ngoái.
So they're using seven nanometer technology, still state of art, very advanced, right?
Họ dùng công nghệ bảy nanomet, vẫn là hiện đại nhất, rất tiên tiến, đúng không?
You see now this kind of system company, or at least, I guess we wouldn't call it a startup at this point, right?
Bạn thấy bây giờ loại công ty hệ thống này, hoặc ít nhất, tôi đoán lúc này không thể gọi là startup nữa, đúng không?
System company are actually using basically very advanced technology node to actually build their system. Their core is actually interesting to look at.
Các công ty hệ thống đang dùng node công nghệ rất tiên tiến để xây dựng hệ thống của họ. Lõi của họ cũng thú vị để xem.
Their core is basically, basically an order core with actually a very large vector unit to actually support machine learning. Any guesses? We're talking about ISA, this space, right? Which ISA are they using?
Lõi của họ về cơ bản là một lõi thực thi theo thứ tự với một đơn vị vectơ rất lớn để hỗ trợ machine learning. Có ai đoán được không? Chúng ta đang nói về ISA mà, đúng không? Họ dùng ISA nào?
Are they using RISC-V? That's a good guess. Unfortunately, MIPS? That's also a good guess.
Họ có dùng RISC-V chăng? Đó là một dự đoán hay. Tiếc là không phải. MIPS chăng? Đó cũng là một dự đoán hay.
PowerPC. Well, at least we actually sampled all the important ISAs, right? So you folks are familiar with all the different ISAs. They actually decided to build their own custom ISA.
PowerPC. Ít nhất thì chúng ta cũng đã thử qua tất cả các ISA quan trọng rồi nhỉ? Vậy là các bạn đều quen thuộc với các ISA khác nhau. Thực ra họ quyết định tự xây dựng một ISA riêng.
So they're not using any standard ISA.
Tức là họ không dùng bất kỳ ISA tiêu chuẩn nào.
They are actually building up their custom ISA, which also means they actually develop their own software stack, right, to make sure things from machine learning, PyTorch, can actually compile to their system.
Họ tự xây dựng ISA tùy biến của riêng mình, điều này cũng có nghĩa là họ tự phát triển cả software stack riêng, đúng không, để bảo đảm các công cụ từ học máy, như PyTorch, có thể biên dịch lên hệ thống của họ.
So this is very custom: my custom hardware, custom compiler. Was exactly, they have a lot of cash, they have a lot of money, they can actually make this kind of investment.
Vậy nên đây là thứ rất tùy biến: phần cứng riêng, trình biên dịch riêng. Đúng vậy, họ có rất nhiều tiền, họ có rất nhiều vốn nên có thể thực hiện khoản đầu tư như thế.
So this is a very interesting, like, situation these days when we actually take a look at the landscape of today's hardware industry, right?
Đây là một tình huống rất thú vị hiện nay khi chúng ta nhìn vào bức tranh toàn cảnh của ngành phần cứng ngày nay, đúng không?
It's a lot, not just the traditional hardware vendors, a lot of newcomers.
Không chỉ có các nhà cung cấp phần cứng truyền thống mà còn có rất nhiều người mới.
They actually understand their application really well, understand their demand very well: what's the scale of the computing they need, and what are the different scenarios that they actually require to support their unique application.
Họ hiểu ứng dụng của mình rất rõ, hiểu nhu cầu của mình rất rõ: quy mô tính toán họ cần là bao nhiêu, và các kịch bản khác nhau nào mà họ cần hỗ trợ cho ứng dụng đặc thù của mình.
And yes, they have a lot of cash to burn and they can actually build very complex and a very advanced system.
Và đúng vậy, họ có rất nhiều tiền để đầu tư nên có thể xây dựng những hệ thống rất phức tạp và rất tiên tiến.
So this is really interesting to see all the different new things actually coming out in our semiconductor industry. I will see more. We'll actually also talk about other vendors, not only Tesla.
Thật thú vị khi thấy đủ thứ mới mẻ đang xuất hiện trong ngành bán dẫn của chúng ta. Các bạn sẽ còn thấy nhiều hơn. Chúng ta cũng sẽ nói về các hãng khác, không chỉ Tesla.
A lot of really interesting systems developed these days are actually from all the different hardware vendors, system vendors, startups, so the landscape is actually very interesting.
Rất nhiều hệ thống thú vị được phát triển ngày nay đến từ nhiều nhà cung cấp phần cứng khác nhau, nhà cung cấp hệ thống, các công ty khởi nghiệp, nên bức tranh toàn cảnh này rất thú vị.
So we'll see where this will, mostly talk about the Dojo, you know, right, how we actually build.
Chúng ta sẽ xem điều này đi về đâu, chủ yếu sẽ nói về Dojo, tức là họ xây dựng nó như thế nào.
They also have very complex infrastructure to scale that up to build actually what they call super node or supercomputer. You will have time.
Họ cũng có hạ tầng rất phức tạp để mở rộng quy mô lên thành cái mà họ gọi là super node hay siêu máy tính. Các bạn sẽ có thời gian.
Well, so for a few talk about how, like, how we actually scale things up moving forward. Okay, well, see, this is Tesla.
Vậy, chúng ta sẽ nói một chút về cách chúng ta mở rộng quy mô trong thời gian tới. Được rồi, đây là Tesla.
Although they're doing actually custom ISA, you actually read, there at least whatever they disclose, it's actually very RISC-V like. Again, they have their vector engine.
Dù họ dùng ISA tùy biến, nhưng như các bạn đọc được, ít nhất theo những gì họ công bố, nó rất giống RISC-V. Một lần nữa, họ có vector engine của riêng mình.
So a lot of the things that we cover in this class, really thinking about how we approach generally and specific open source ISA, and building up the hardware, is actually very transferable.
Vì vậy nhiều điều chúng ta học trong lớp này, tức là cách tiếp cận nói chung và với một ISA mã nguồn mở cụ thể, cũng như việc xây dựng phần cứng, đều có thể áp dụng rất tốt.
Even we're actually designing a different ISA, a lot of the considerations are still need to be factored in when we actually build a hardware.
Ngay cả khi ta thiết kế một ISA khác, nhiều cân nhắc vẫn cần được tính đến khi xây dựng phần cứng.
Okay, with that, let's transition to the topic of today, RISC-V pipeline. So last lecture we basically, last week, we wrapped up all the different instructions.
Được rồi, bây giờ chuyển sang chủ đề hôm nay: đường ống RISC-V. Vậy bài giảng trước, tức là tuần trước, chúng ta đã hoàn tất tất cả các loại lệnh.
We started with register-register operations, also started talking about, I'll talk about the immediate generation, right, how we support constant, storing structure, memory operation, branch, right, how we do the conditional B-type branch instruction and unconditional jump instruction.
Chúng ta bắt đầu với các phép toán thanh ghi-thanh ghi, và cũng bắt đầu nói về, tôi sẽ nói về việc sinh immediate, đúng không, cách chúng ta hỗ trợ hằng số, cấu trúc lưu trữ, các thao tác bộ nhớ, rẽ nhánh, đúng không, cách chúng ta thực hiện lệnh rẽ nhánh có điều kiện kiểu B và lệnh nhảy không điều kiện.
I will also talk about upper immediate, how we can actually populate data to the upper immediate.
Tôi cũng đã nói về immediate cao (upper immediate), cách chúng ta có thể nạp dữ liệu vào phần immediate cao.
In today's lecture we're going to talk about a little bit more, rough, our discussion, really think how we actually think about the control logic, how we make sure the control logic can generate all the signals required to make sure things actually propagate correctly in our datapaths.
Trong bài giảng hôm nay, chúng ta sẽ nói thêm một chút, sơ lược, về phần thảo luận của mình, thực sự suy nghĩ xem chúng ta nghĩ về logic điều khiển như thế nào, làm sao để đảm bảo logic điều khiển tạo ra được tất cả các tín hiệu cần thiết để dữ liệu lan truyền đúng trong các datapath của chúng ta.
And then we'll also transition to pipeline, you know, we can actually pipeline the design so it can be a lot faster.
Sau đó chúng ta cũng sẽ chuyển sang đường ống, tức là chúng ta có thể chia thiết kế thành đường ống để nó nhanh hơn rất nhiều.
So this is a datapath that we have seen before, right, we have all the different components to support different types of instruction.
Đây là một datapath mà chúng ta đã thấy trước đây, đúng không, chúng ta có tất cả các thành phần khác nhau để hỗ trợ các loại lệnh khác nhau.
What we haven't talked too much about is all the control logic, right.
Điều chúng ta chưa nói nhiều là toàn bộ logic điều khiển, đúng không.
We mentioned there are a lot of muxes, right, whenever we see muxes that means the hardware will actually behave differently based on the instruction that has actually been seen from the decoder, right.
Chúng ta đã nhắc là có rất nhiều mux, đúng không, bất cứ khi nào thấy mux nghĩa là phần cứng sẽ hoạt động khác nhau tùy theo lệnh mà bộ giải mã nhận được, đúng không.
So basically the control logic basically takes the instruction after it's read from memory, and then sets up all the different muxes correctly, so that we can actually control the behavior of the datapaths.
Về cơ bản, logic điều khiển nhận lệnh sau khi nó được đọc từ bộ nhớ, rồi thiết lập đúng tất cả các mux khác nhau, để chúng ta có thể điều khiển hành vi của datapath.
So that's basically what the control logic is trying to do.
Đó chính là điều mà logic điều khiển cố gắng làm.
We will take a look at, like, the addition of instruction that we have seen so far, is our R-type instruction, we read registers and then write to registers.
Chúng ta sẽ xem xét, chẳng hạn, lệnh add trong số những lệnh đã thấy cho đến giờ, là lệnh kiểu R, chúng ta đọc thanh ghi rồi ghi vào thanh ghi.
The control logic, we think about the behavior of the datapaths, right, so first one clock is triggered, We have the PC.
Với logic điều khiển, chúng ta nghĩ về hành vi của datapath, đúng không, đầu tiên khi một xung clock được kích, chúng ta có PC.
Right, when, after I have the PC, again, we're doing asynchronous read, so data is immediately available to instruction memory. We can actually get the instruction out.
Đúng rồi, sau khi có PC, một lần nữa, chúng ta đọc không đồng bộ, nên dữ liệu có sẵn ngay lập tức ở bộ nhớ lệnh. Chúng ta có thể lấy được lệnh ra.
Right, once we have the PC, of course we want to, it's an add instruction, right? We want to actually add four, so we can advance, increment our PC counter to the next instruction.
Đúng rồi, khi đã có PC, dĩ nhiên chúng ta muốn, đây là lệnh add, đúng không? Chúng ta muốn cộng thêm bốn, để có thể tăng bộ đếm PC lên lệnh kế tiếp.
At the same time, we pass the instruction to our control logic so that we can set all the different muxes correctly. What are the different control signals we need to set?
Đồng thời, chúng ta chuyển lệnh cho logic điều khiển để có thể thiết lập đúng tất cả các mux khác nhau. Chúng ta cần thiết lập những tín hiệu điều khiển nào?
Right, so once we get the instruction, but first, a PC select. Right, so this is a register to register operation, we're not doing branch. So next PC, program counter, is basically PC plus four.
Đúng rồi, khi đã có lệnh, nhưng trước hết là PC select. Đây là phép toán thanh ghi với thanh ghi, chúng ta không rẽ nhánh. Nên PC kế tiếp, tức bộ đếm chương trình, đơn giản là PC cộng bốn.
We also need to set immediate selection. Right, so here again, register to register operation, we don't need to actually touch the immediate generation.
Chúng ta cũng cần thiết lập lựa chọn immediate. Đúng rồi, ở đây, một lần nữa, là phép toán thanh ghi với thanh ghi, nên chúng ta không cần đụng đến phần sinh immediate.
We do need to write to the register in the end, so we want to set the write enable signal to our register file.
Cuối cùng chúng ta cần ghi vào thanh ghi, nên chúng ta muốn đặt tín hiệu cho phép ghi cho tập thanh ghi.
We're not doing any branch instructions, so all of those branch signals don't really matter. For the selection to our ALU inputs, right, we're basically just grabbing the data from the register directly.
Chúng ta không thực hiện lệnh rẽ nhánh nào, nên tất cả các tín hiệu rẽ nhánh đó thực ra không quan trọng. Còn với phần chọn đầu vào cho ALU của chúng ta, đúng không, về cơ bản chúng ta chỉ lấy dữ liệu trực tiếp từ thanh ghi.
Right, we don't need other sources of ALU inputs. We also need to tell the ALU we're doing addition, right, so this is another control signal we need to set.
Đúng không, chúng ta không cần các nguồn đầu vào ALU khác. Chúng ta cũng cần báo cho ALU biết là đang thực hiện phép cộng, nên đây là một tín hiệu điều khiển nữa mà chúng ta cần thiết lập.
We don't need to actually write to memory, right, we're not touching memory, so we don't need to set the write enable in our memory.
Chúng ta không cần ghi vào bộ nhớ, vì chúng ta không động đến bộ nhớ, nên không cần thiết lập tín hiệu cho phép ghi của bộ nhớ.
Again, we're not doing memory operations, and then the data is actually written back to the register file. So all the different boxes, all the different control steps actually need to be configured.
Một lần nữa, chúng ta không thực hiện các thao tác bộ nhớ, và sau đó dữ liệu được ghi ngược lại vào register file. Vậy tất cả các khối khác nhau, tất cả các bước điều khiển khác nhau đều cần được cấu hình.
And all of this is basically based on the instruction. Right, whenever we see the instruction, we know what the expected behaviors are.
Và tất cả những điều này về cơ bản dựa trên lệnh. Mỗi khi thấy lệnh, chúng ta biết các hành vi mong đợi là gì.
So that's basically the different behaviors, using addition as an example, of what the control signal is trying to do. Again, read the instruction, Set the signals to control all the different boxes.
Đó về cơ bản là các hành vi khác nhau, lấy phép cộng làm ví dụ, mà tín hiệu điều khiển đang cố thực hiện. Một lần nữa, hãy đọc lệnh, đặt các tín hiệu để điều khiển tất cả các khối khác nhau.
Again, we look at a timing diagram, right? We have already seen how the timing actually propagates for the add instruction, again single cycle.
Một lần nữa, chúng ta xem một giản đồ thời gian nhé? Chúng ta đã thấy thời gian thực sự lan truyền như thế nào với lệnh add, vẫn là chu kỳ đơn.
What's new here is that we actually add the control logic, right?
Điểm mới ở đây là chúng ta thêm vào logic điều khiển, đúng không?
Again, whenever the instruction becomes available after we read the instruction from iMemory, then we can actually start, because the instruction, and then set up the control signals accordingly, based on the instruction format.
Một lần nữa, khi lệnh sẵn sàng sau khi chúng ta đọc lệnh từ iMemory, thì chúng ta mới có thể bắt đầu, vì lệnh, rồi thiết lập các tín hiệu điều khiển tương ứng, dựa trên định dạng lệnh.
Right, so this is, again, it also takes time; it happens immediately after the instruction becomes available.
Vậy đây cũng là một bước tốn thời gian; nó xảy ra ngay sau khi lệnh sẵn sàng.
We won't, we'll talk about basically how the control signals are basically based on the instruction.
Chúng ta sẽ nói về việc các tín hiệu điều khiển dựa trên lệnh như thế nào.
We'll want to go through this, but you can actually go through, you will, you will need to actually go through this, especially when you start your project, right?
Chúng ta sẽ muốn xem qua phần này, nhưng bạn cũng có thể tự xem, và bạn sẽ bạn sẽ cần phải xem qua phần này, đặc biệt là khi bạn bắt đầu làm dự án, đúng không?
Based on the different instructions, how we set different control signals to make sure that instructions can be executed correctly, right?
Dựa trên các lệnh khác nhau, chúng ta đặt các tín hiệu điều khiển khác nhau như thế nào để đảm bảo các lệnh có thể được thực thi đúng, phải không?
So all the different steps, all the different control signals need to be selected correctly.
Vậy tất cả các bước khác nhau, tất cả các tín hiệu điều khiển khác nhau đều cần được chọn đúng.
It may seem a little bit overwhelming when we just look at this big table, but you will actually look at our instructions, that are ISA, right?
Có thể hơi choáng ngợp khi chúng ta nhìn vào bảng lớn này, nhưng bạn sẽ nhìn vào các lệnh của chúng ta, tức là ISA, đúng không?
We actually don't need to actually read all the different bits, we have very strong patterns.
Thực ra chúng ta không cần đọc tất cả các bit khác nhau, vì có những quy luật rất rõ ràng.
If you remember our discussion when we actually went through the ISA, right, we repeated multiple times, right, we want to maintain consistency as much as possible, right?
Nếu bạn nhớ phần thảo luận khi chúng ta xem qua ISA, chúng ta đã lặp lại nhiều lần, rằng chúng ta muốn duy trì tính nhất quán càng nhiều càng tốt, đúng không?
All the opcode is the lower seven bits on the, on the right, and then we'll have funct3, and then funct7, and we actually, I think I already mentioned this, right, we actually just use basically the second MSB there, so we only actually need a very small subset of the bits to actually do the decode to figure out what the control signal is.
Toàn bộ opcode là bảy bit thấp ở bên phải, rồi đến funct3, và sau đó là funct7, và thực ra, tôi nghĩ tôi đã đề cập điều này rồi, chúng ta thực ra chỉ dùng bit MSB thứ hai ở đó, nên chúng ta thực sự chỉ cần một tập con rất nhỏ các bit để giải mã và xác định tín hiệu điều khiển là gì.
So that also makes the decoding a lot easier, right?
Như vậy việc giải mã cũng dễ hơn nhiều, đúng không?
Other signals are actually more related to register operation, immediate generation or memory accesses; they are actually Not related to the control logic decoding, setting up the control signal.
Các tín hiệu khác thực ra liên quan nhiều hơn đến thao tác với thanh ghi, tạo giá trị immediate hoặc truy cập bộ nhớ; chúng không liên quan đến việc giải mã của logic điều khiển, tức là việc thiết lập tín hiệu điều khiển.
So it may seem like you need to actually look at all the 32 bits, but it's really only those nine bits that are actually needed when we actually come to decoding.
Vậy nên có vẻ như ta phải xem cả 32 bit, nhưng thực ra chỉ cần đúng chín bit đó thôi khi ta đến bước giải mã.
So, this is the decoding, right, how we actually realize the control operations. There are multiple different ways of realizing the control operations.
Đây là phần giải mã, tức là cách ta hiện thực các thao tác điều khiển. Có nhiều cách khác nhau để hiện thực các thao tác điều khiển.
Like, earlier days you may also have heard people actually talking about using ROM to actually store, but also, although like different microcode to decode it correctly, to decode it directly.
Ví dụ, ngày xưa có thể bạn cũng đã nghe người ta nói về việc dùng ROM để lưu trữ, và cả các vi mã (microcode) khác nhau để giải mã cho đúng, để giải mã trực tiếp.
It was more popular before, when actually RAM was actually, we'll talk about how we actually do the SRAM later, was a lot more expensive.
Cách này phổ biến hơn trước đây, khi RAM (lát nữa ta sẽ nói về SRAM) đắt hơn nhiều.
ROM is like read only memory, is a lot cheaper, right, because we only need to read it, we don't need to write it, right? So also a lot. Also can be also faster.
ROM là bộ nhớ chỉ đọc, rẻ hơn nhiều, đúng không, vì ta chỉ cần đọc nó, không cần ghi, đúng không? Nó cũng có thể nhanh hơn.
When there's like a strong benefit, it can be actually implemented using read only memory, we're just the programs memory in terms of how the different control signals are supposed to be set.
Khi có lợi ích rõ rệt, nó có thể được hiện thực bằng bộ nhớ chỉ đọc, ta chỉ lập trình bộ nhớ đó về cách thiết lập các tín hiệu điều khiển khác nhau.
Again, based on the instruction type. These days, RAM, SRAM, we'll talk about SRAM technology later, it's pretty fast, the density is actually pretty high. It's actually still pretty well.
Một lần nữa, dựa trên loại lệnh. Ngày nay, RAM, SRAM (lát nữa ta sẽ nói về công nghệ SRAM), khá nhanh và mật độ khá cao. Nó vẫn hoạt động khá tốt.
So this is what we actually just designed directly in combinational logic, instead of doing this ROM versus RAM trade off.
Vì vậy ta thiết kế trực tiếp bằng logic tổ hợp, thay vì cân nhắc đánh đổi giữa ROM và RAM.
We'll talk a little bit more later how we actually decode this, again hierarchically, but if you can basically, like, all the different things that we learned in combinational logic, right, we have input, we have output.
Lát nữa ta sẽ nói thêm về cách giải mã phần này, cũng theo kiểu phân cấp, nhưng về cơ bản, tất cả những gì ta đã học trong logic tổ hợp, tức là có đầu vào, có đầu ra.
This is basically an example.
Đây chính là một ví dụ.
This decoder is a combinational logic, we have input, which are those nine bits from the instructions, we have output, all the different signals controlling all the different boxes, and ALU and immediate generation, right?
Bộ giải mã này là logic tổ hợp, có đầu vào là chín bit đó từ lệnh, có đầu ra là tất cả các tín hiệu điều khiển các khối khác nhau, cả ALU và khối tạo immediate, đúng không?
So that's basically a combinational logic that we can use to actually decode the operation. In term of doing decoding hierarchically, right?
Vậy đó là một mạch logic tổ hợp mà ta có thể dùng để giải mã thao tác. Còn về giải mã theo kiểu phân cấp, đúng không?
So for example, we actually have a discussion last week, like when we come to the branch instruction, right, sometime we actually want to do an unsigned comparison, because we have two instructions of actually doing this unsigned comparison.
Ví dụ, tuần trước ta đã thảo luận rằng khi nói đến lệnh rẽ nhánh, đúng không, đôi khi ta muốn so sánh không dấu, vì có hai lệnh dùng để so sánh không dấu này.
Right. In this case, how do we decide whether we actually need to set this branch unsigned control signal to one when we actually see that?
Đúng không. Trong trường hợp này, làm sao ta quyết định có cần đặt tín hiệu điều khiển branch unsigned bằng một khi gặp lệnh đó?
We can actually do this hierarchically, in the sense we always need to decide whether, first, whether this is a branch signal or not.
Ta có thể làm việc này theo kiểu phân cấp, theo nghĩa là chúng ta luôn cần quyết định xem, trước hết, đây có phải là tín hiệu rẽ nhánh hay không.
Once it is a branch signal, we actually just look at one more bit to actually figure out whether we want to do unsigned or signed comparison.
Một khi đó là tín hiệu rẽ nhánh, chúng ta chỉ cần xem thêm một bit nữa để xác định xem mình muốn so sánh không dấu hay có dấu.
So we can actually do this hierarchically, and that actually makes the design a lot modular. Again, this become a standard combinational logic optimization problem, right? We can use Boolean algebra to do this.
Vậy là chúng ta có thể làm điều này theo phân cấp, và điều đó làm cho thiết kế có tính mô-đun hơn rất nhiều. Một lần nữa, đây trở thành một bài toán tối ưu logic tổ hợp tiêu chuẩn, đúng không? Chúng ta có thể dùng đại số Boolean để làm việc này.
We also talk about Karnaugh map, a very handy way to do this, right?
Chúng ta cũng đã nói về bản đồ Karnaugh, một cách rất tiện để làm việc này, đúng không?
So this become a standard Boolean simplification problem, input and output, but modularity help make the code a lot more readable, makes it a lot easier to debug.
Vậy đây trở thành một bài toán rút gọn Boolean tiêu chuẩn, có đầu vào và đầu ra, nhưng tính mô-đun giúp mã dễ đọc hơn nhiều, và gỡ lỗi dễ dàng hơn nhiều.
So with that, you will actually come back to our datapath, right? So we need the datapath to execute all the different components to support all the different operations.
Với điều đó, chúng ta quay lại datapath của mình, đúng không? Chúng ta cần datapath để thực thi tất cả các thành phần khác nhau nhằm hỗ trợ mọi phép toán khác nhau.
We also need our control signals that need to be set up correctly. Again, the most important thing is that we can set up the control signal purely based on the instructions.
Chúng ta cũng cần các tín hiệu điều khiển được thiết lập đúng. Một lần nữa, điều quan trọng nhất là chúng ta có thể thiết lập tín hiệu điều khiển hoàn toàn dựa trên lệnh.
Once the instruction becomes available, we can actually set up all the different control bits accordingly for those instructions. So that's the control signal.
Khi lệnh đã sẵn sàng, chúng ta có thể thiết lập tất cả các bit điều khiển khác nhau tương ứng cho các lệnh đó. Đó chính là tín hiệu điều khiển.
That's wrap up our discussion on the datapath and the control side.
Vậy là kết thúc phần thảo luận về datapath và phần điều khiển.
This will be the foundation of our discussion in before we actually transition to the pipeline, how we actually make things faster, based on this.
Đây sẽ là nền tảng cho phần thảo luận của chúng ta trước khi chuyển sang đường ống, tức là làm thế nào để làm mọi thứ nhanh hơn, dựa trên nền tảng này.
Before we transition to pipelining, any questions, thoughts, comments? Fine.
Trước khi chuyển sang kỹ thuật đường ống, có câu hỏi, suy nghĩ hay nhận xét nào không? Được rồi.
This one. To tell all the different.
Cái này. Để phân biệt tất cả các loại khác nhau.
Right. We look at other bits, right? So they are basically either for immediate or for that register, which register we want to read. I will actually, it will come back to the datapath, right?
Đúng. Chúng ta xem các bit khác, đúng không? Về cơ bản chúng dành cho số tức thời hoặc cho thanh ghi, tức là thanh ghi nào chúng ta muốn đọc. Tôi sẽ quay lại datapath, đúng không?
So for the register we want to read, right, so those are basically passed directly to the register file, which is also from the instruction. Right.
Với thanh ghi mà chúng ta muốn đọc, đúng không, những bit đó về cơ bản được chuyển thẳng đến tệp thanh ghi, cũng lấy từ lệnh. Đúng.
So the different bits, and the immediate is passed to immediate generation. So, based on a pilot again.
Các bit khác nhau, còn số tức thời được chuyển đến khối sinh số tức thời. Vậy, dựa trên một pilot một lần nữa.
Yeah, if you look at like all the RS1, they are like, they are basically RS lines, always those five bits, right? They are very consistent.
Vâng, nếu bạn nhìn tất cả các RS1, chúng về cơ bản là các đường RS, luôn là năm bit đó, đúng không? Chúng rất nhất quán.
So this is, so that's why it's actually very modular, so they're always the fixed points, fixed positions for those. I said, "Oh, we check all of them."
Vì vậy nó rất mô-đun, chúng luôn nằm ở những điểm cố định, vị trí cố định. Tôi nói: “Ồ, chúng ta kiểm tra tất cả chúng.”
So everything's actually going in parallel, so we can always grab the data from the register file. You will actually don't need the data eventually, these will just be garbage data, right?
Vậy nên mọi thứ thực ra đều diễn ra song song, nên lúc nào ta cũng có thể lấy dữ liệu từ register file. Cuối cùng thì có thể bạn không cần đến dữ liệu đó, chúng sẽ chỉ là dữ liệu rác, đúng không?
You will actually, like for example, instead of using register file data, based on the decoding we actually want to use the immediate, right?
Ví dụ, thay vì dùng dữ liệu từ register file, dựa trên kết quả giải mã, ta lại muốn dùng giá trị immediate, đúng không?
Eventually it will be selected correctly when it comes to that stage. So, otherwise you'll propagate, right, still propagate. It just doesn't matter because they won't be used. Yeah, Lucy.
Đến giai đoạn đó, giá trị đúng sẽ được chọn. Còn nếu không thì chúng vẫn lan truyền, đúng không, vẫn cứ lan truyền. Chỉ là không quan trọng vì chúng sẽ không được dùng. Vâng, Lucy.
Right, that's a good question.
Vâng, câu hỏi hay đấy.
Yes, I saw the question in chat, so we actually, for this ISA, we actually didn't use the last two bits, because this is actually just for the 32-bit integer ISA.
Vâng, tôi đã thấy câu hỏi trong chat, với ISA này, ta không dùng hai bit cuối, vì đây chỉ là ISA số nguyên 32 bit.
You actually respect, there are actually a lot of different extensions. So we'll actually, those bits will actually be used to actually support the different extensions.
Thực ra còn có rất nhiều phần mở rộng khác nhau. Vậy nên, những bit đó sẽ được dùng để hỗ trợ các phần mở rộng khác nhau.
So for this one, so again, this is not the response, I say this is a response, 32-bit integer ISA, right? So we have a lot of qualifiers for this ISA.
Với trường hợp này, một lần nữa, đây không phải là phản hồi, ý tôi là đây là ISA số nguyên 32 bit, đúng không? Ta có rất nhiều chỉ định bổ sung cho ISA này.
So for this particular ISA, those are the bits, actually. Good question.
Với ISA cụ thể này, đó chính là những bit ấy. Câu hỏi hay.
Okay, so we talked a lot about the different ISA, different encodings, and how we actually developed a datapath to support an efficient execution of this.
Được rồi, ta đã nói nhiều về các ISA khác nhau, các cách mã hóa khác nhau, và cách ta phát triển một datapath để hỗ trợ thực thi chúng hiệu quả.
In this lecture we will actually transition to pipelining, right? So this is more about, okay, this is a baseline design; how can we make it faster?
Trong bài giảng này ta sẽ chuyển sang pipelining, đúng không? Nội dung này nói về việc, đây là thiết kế cơ sở; làm sao để làm cho nó nhanh hơn?
There are different constraints that actually limit the throughput that we can get from our system.
Có nhiều ràng buộc khác nhau giới hạn thông lượng mà hệ thống của ta có thể đạt được.
Again, many of you have seen this either in another computer architecture class or in 61C before, so we will go actually pretty quickly.
Một lần nữa, nhiều bạn đã học nội dung này trong một lớp kiến trúc máy tính khác hoặc trước đây trong 61C, nên ta sẽ đi khá nhanh.
And again, if you have questions, feel free to reach out to the staff, or the textbook also has a very good summary with details of all the different things.
Và nếu có câu hỏi, các bạn cứ liên hệ với đội ngũ giảng dạy, hoặc giáo trình cũng có phần tóm tắt rất tốt với đầy đủ chi tiết về mọi vấn đề.
So, pipelining, right? Why are we interested in really thinking about pipelining?
Vậy, pipelining, đúng không? Tại sao ta quan tâm đến việc suy nghĩ kỹ về pipelining?
A lot of optimization, the majority of today's, especially, not necessarily today, today's hardware optimization is more of a multi-objective optimization problem, but
Rất nhiều việc tối ưu hóa, phần lớn hiện nay, đặc biệt là, không hẳn là hiện nay, tối ưu hóa phần cứng ngày nay thiên về bài toán tối ưu đa mục tiêu hơn, nhưng
a lot of designs actually are really thinking about performance. So here's the idea: really thinking about how we can, again, make sure things are actually executing faster.
nhiều thiết kế thực sự rất chú trọng đến hiệu năng. Ý tưởng ở đây là: nghĩ xem làm thế nào để, đảm bảo mọi thứ được thực thi nhanh hơn.
We will actually compare a single-cycle implementation, a single-cycle design, with a pipelined design, right? So in a single-cycle design you will actually think about already how things actually propagate over time, right?
Ta sẽ so sánh một cách triển khai đơn chu kỳ, một thiết kế đơn chu kỳ, với một thiết kế pipelined, đúng không? Trong thiết kế đơn chu kỳ, ta đã phải nghĩ đến cách mọi thứ lan truyền theo thời gian, đúng không?
You will actually execute one instruction per cycle. We talked about there are five different stages, or five different steps. Well, different stages: some stages are longer, some stages are slower, right?
Mỗi chu kỳ ta thực thi một lệnh. Ta đã nói là có năm giai đoạn, hay năm bước khác nhau. Các giai đoạn khác nhau: có giai đoạn dài hơn, có giai đoạn chậm hơn, đúng không?
Different stages may actually take different times; for this particular example maybe like 100, 200 picoseconds, right? It depends on the complexity, right?
Các giai đoạn khác nhau có thể mất thời gian khác nhau; với ví dụ cụ thể này có thể khoảng 100, 200 picosecond, đúng không? Nó phụ thuộc vào độ phức tạp, đúng không?
But when we actually think about total instruction execution time, we basically need to add all of those together, right?
Nhưng khi nghĩ về tổng thời gian thực thi lệnh, về cơ bản chúng ta cần cộng tất cả các thời gian đó lại, đúng không?
So in this particular example it's roughly a tenth of a picosecond that actually dictates the clock rate, right? So, because we need to execute one cycle per instruction. Right.
Vậy trong ví dụ cụ thể này, đại khái là một phần mười picosecond quyết định tốc độ xung nhịp, đúng không? Vì chúng ta cần thực thi một lệnh trong mỗi chu kỳ. Đúng vậy.
So this is the total instruction execution time that basically takes the clock period. This is basically our focus. The idea is really thinking about how we can actually get a better throughput.
Vậy đây là tổng thời gian thực thi lệnh, và nó chính là chu kỳ xung nhịp. Đây chính là trọng tâm của chúng ta. Ý tưởng là nghĩ xem làm thế nào để đạt thông lượng tốt hơn.
Can we actually run things faster with a higher frequency? If you actually want to run things faster with a higher frequency, we basically need to reduce the clock period time, right?
Liệu chúng ta có thể chạy nhanh hơn với tần số cao hơn không? Nếu muốn chạy nhanh hơn với tần số cao hơn, về cơ bản chúng ta cần giảm chu kỳ xung nhịp, đúng không?
We need to have a shorter clock cycle. So how can we do that?
Chúng ta cần chu kỳ xung nhịp ngắn hơn. Vậy làm thế nào?
The idea is that instead of every cycle needing to finish all the instructions, what if we only need to, say, we actually break down our pipeline into multiple stages or steps, right, and then every cycle we only need to actually finish one of the steps, instead of the entire instruction.
Ý tưởng là thay vì mỗi chu kỳ phải hoàn thành toàn bộ lệnh, nếu chúng ta chỉ cần, chẳng hạn, chia đường ống của mình thành nhiều giai đoạn hay nhiều bước, đúng không, và mỗi chu kỳ chúng ta chỉ cần hoàn thành một trong các bước đó, thay vì cả lệnh thì sao?
With that, our cycle time can basically be the longest step time or longest stage time, right.
Như vậy, thời gian chu kỳ có thể bằng thời gian của bước dài nhất hay giai đoạn dài nhất, đúng không.
This may make actually our latency of instructions longer, but then we can actually have higher throughput by running things a lot faster, because now the clock frequency is actually dictated by the stage time, like the longest execution stage, instead of the total instruction latency.
Điều này có thể làm độ trễ của lệnh dài hơn, nhưng chúng ta lại có thông lượng cao hơn nhờ chạy nhanh hơn rất nhiều, vì giờ đây tần số xung nhịp được quyết định bởi thời gian của một giai đoạn, tức giai đoạn thực thi dài nhất, thay vì tổng độ trễ của lệnh.
Right, so that's basically a trade off.
Đúng vậy, đó chính là một sự đánh đổi.
We want to get higher throughput, we want to still get, we want to actually produce one instruction per cycle, and with the cycle time actually a lot faster, with higher frequency.
Chúng ta muốn có thông lượng cao hơn, vẫn muốn, vẫn muốn tạo ra một lệnh mỗi chu kỳ, và với thời gian chu kỳ nhanh hơn nhiều, tức tần số cao hơn.
And instead of actually doing one cycle like support all the instructions at once, all the instruction operations in one cycle, we break down the instruction execution into different stages, and each cycle only needs to support one of the stages.
Và thay vì một chu kỳ phải hỗ trợ tất cả các lệnh cùng một lúc, tất cả các thao tác của lệnh trong một chu kỳ, chúng ta chia việc thực thi lệnh thành các giai đoạn khác nhau, và mỗi chu kỳ chỉ cần hỗ trợ một giai đoạn.
With that we can actually make things, the throughput will be faster, we can actually get a higher frequency. But we also get a better latency now for this, for each instruction execution.
Nhờ vậy thông lượng sẽ nhanh hơn, chúng ta có thể đạt tần số cao hơn. Nhưng đồng thời độ trễ của mỗi lệnh khi thực thi cũng dài ra.
Right, right. So there is also a distinction between actually, especially for here we're talking about throughput.
Đúng, đúng vậy. Vậy cũng có một sự phân biệt, đặc biệt ở đây chúng ta đang nói về thông lượng.
Right, we are actually getting one instruction out every cycle and the cycle time is smaller, We get throughput higher.
Đúng, chúng ta nhận được một lệnh ra mỗi chu kỳ và thời gian chu kỳ nhỏ hơn, thông lượng cao hơn.
But the instruction time or instruction latency is actually longer, because now, instead of just adding different step time, different step stages' time together, we actually need to pick the longest stage and then multiply by the number.
Nhưng thời gian của lệnh, hay độ trễ của lệnh, thực ra lại dài hơn, vì giờ đây, thay vì chỉ cộng thời gian của các bước khác nhau, thời gian của các giai đoạn khác nhau lại với nhau, chúng ta cần chọn giai đoạn dài nhất rồi nhân với số giai đoạn.
This is the worst case latency across all the steps, and then multiply by the number of pipeline cycles, stages, that we actually need. Right. And in, in fact, it is actually a little bit...
Đây là độ trễ trong trường hợp xấu nhất trên tất cả các bước, rồi nhân với số chu kỳ, số giai đoạn của đường ống mà chúng ta cần. Đúng. Và thực ra, nó hơi...
In reality, so, actually a little bit longer than just the worst case execution latency, because we're actually adding registers, and register also takes time, right?
Trên thực tế, độ trễ thực sự dài hơn một chút so với độ trễ thực thi trong trường hợp xấu nhất, vì chúng ta thêm các thanh ghi, mà thanh ghi cũng tốn thời gian, đúng không?
So the latency per each instruction execution actually gets longer, but we get better throughput in the design. So that's important when we actually think about pipelining, right?
Vì vậy độ trễ cho mỗi lệnh thực thi thực ra dài hơn, nhưng đổi lại ta có thông lượng tốt hơn trong thiết kế. Đó là điều quan trọng khi ta nghĩ về pipelining, đúng không?
So latency for each instruction actually gets longer, because we're doing, first, worst case, and second, we're adding registers. Both actually introduce additional latency. So we look at pipelining, right?
Độ trễ của mỗi lệnh thực ra dài hơn, vì thứ nhất, ta tính theo trường hợp xấu nhất, và thứ hai, ta thêm các thanh ghi. Cả hai đều làm tăng thêm độ trễ. Vậy ta xem xét pipelining nhé?
So we have already talked about, like, different five stages, right? So that's a pretty natural way to actually partition the design into five different pipeline stages.
Ta đã nói về năm giai đoạn khác nhau rồi, đúng không? Đó là một cách khá tự nhiên để chia thiết kế thành năm giai đoạn của đường ống.
Again, this is just one particular implementation; you actually will do a different design in your project. So, again, when it comes to microarchitecture, right, there are a lot of different ways to realize this.
Một lần nữa, đây chỉ là một cách hiện thực cụ thể; trong dự án, các bạn sẽ làm một thiết kế khác. Vậy nên, khi nói đến vi kiến trúc, có rất nhiều cách khác nhau để hiện thực.
We'll actually use this style of diagram consistently.
Chúng ta sẽ dùng kiểu sơ đồ này một cách nhất quán.
So whenever we see a diagram like this, it's always time, this time, horizontally, and then we have different instructions vertically.
Mỗi khi thấy một sơ đồ như thế này, trục ngang luôn là thời gian, thời gian này nằm theo chiều ngang, còn các lệnh khác nhau nằm theo chiều dọc.
So when we actually see horizontally, it's basically resources used for each instruction over time.
Khi ta nhìn theo chiều ngang, đó là các tài nguyên được dùng cho mỗi lệnh theo thời gian.
For each instruction we still go to fetch, decode, execute, memory operation and write back accesses, right?
Với mỗi lệnh, ta vẫn đi qua nạp lệnh, giải mã, thực thi, thao tác bộ nhớ và ghi lại kết quả, đúng không?
Sometimes we also look at it vertically: all the different resources that are used at a particular time slot.
Đôi khi ta cũng nhìn theo chiều dọc: tất cả các tài nguyên khác nhau được dùng tại một khe thời gian nhất định.
So when we look at things vertically at a particular time slot, all the different parts of resources are actually used by different instructions.
Khi nhìn theo chiều dọc tại một khe thời gian nhất định, các phần tài nguyên khác nhau đang được các lệnh khác nhau sử dụng.
So we'll see this multiple times at the end of the end. So horizontally, resource for each instruction; vertically, resources for different instructions.
Chúng ta sẽ còn gặp điều này nhiều lần nữa. Vậy theo chiều ngang là tài nguyên cho mỗi lệnh; theo chiều dọc là tài nguyên cho các lệnh khác nhau.
Right. You will, you are not moving all those, like you're in the blue, blue rectangle, we're using all five, or I guess we're not using all, but we're using our five, right?
Đúng vậy. Bạn sẽ, bạn không bỏ đi tất cả những cái đó, như trong hình chữ nhật màu xanh, ta đang dùng cả năm, hay đúng hơn là không dùng hết, nhưng ta đang dùng năm giai đoạn, đúng không?
If we're not, say we're only using one, then we can just delete the pipeline, delete these, right, stages, we wouldn't be speeding anything up, right?
Nếu không, giả sử ta chỉ dùng một, thì ta có thể bỏ đường ống, bỏ các giai đoạn này đi, và cũng chẳng tăng tốc được gì, đúng không?
It's only speeding it up when we're using all the stages, right? It's only, it's only speeding up when we're actually using them. So what do you mean you were only using?
Chỉ tăng tốc khi ta dùng tất cả các giai đoạn, đúng không? Chỉ tăng tốc khi ta thực sự đang dùng chúng. Ý bạn là chỉ dùng như thế nào?
You want to be able to put like five instructions in flight. So, right, if it's never starting the next one while the other ones are still running, there's no point.
Bạn muốn có thể đưa khoảng năm lệnh vào thực thi cùng lúc. Vậy nên, nếu nó không bao giờ bắt đầu lệnh tiếp theo khi các lệnh khác còn đang chạy, thì chẳng có ý nghĩa gì.
Right. So we'll actually talk about that. So it actually could appear that our resources are not fully utilized if there actually is a hazard.
Đúng vậy. Ta sẽ nói về điều đó. Có thể trông như các tài nguyên của ta không được tận dụng hết nếu có xung đột (hazard).
So we'll talk about hazard and stall later, where the resources will not be fully utilized.
Ta sẽ nói về hazard và stall sau, khi các tài nguyên sẽ không được tận dụng đầy đủ.
But the benefit of pipelining is most pronounced when we're actually fully utilizing all the resources so that we can get more things going on in parallel. Sure. Yeah.
Nhưng lợi ích của pipelining thể hiện rõ nhất khi chúng ta tận dụng đầy đủ tất cả các tài nguyên để có thể có nhiều việc diễn ra song song hơn. Được ạ. Vâng.
That's a, that's a really good question. So the question is, how do we determine the number of stages when we're using the pipeline execution?
Đó là một câu hỏi rất hay. Câu hỏi là: làm sao để xác định số tầng khi chúng ta thực thi theo đường ống?
It's less popular as a research topic, but if you go back, I would say 20-30 years, there's actually a lot of research work in determining what they call optimal pipeline depths.
Nó ít phổ biến hơn như một đề tài nghiên cứu, nhưng nếu nhìn lại khoảng 20-30 năm trước, đã có rất nhiều công trình nghiên cứu về việc xác định cái mà người ta gọi là độ sâu đường ống tối ưu.
It's basically the number of pipeline. Well, basically the latency per pipeline stage and the number of pipeline stages that we want to have in the execution.
Về cơ bản đó là số tầng của đường ống. Nói cho đúng, đó là độ trễ trên mỗi tầng của đường ống và số tầng đường ống mà chúng ta muốn có khi thực thi.
Again, in the early, I would say 30, 30, maybe even a little bit more than three decades ago, it's more like performance oriented. Right.
Một lần nữa, vào thời kỳ đầu, khoảng 30 năm trước, thậm chí hơn ba thập kỷ trước một chút, người ta thiên về hiệu năng hơn. Đúng không.
We'll actually talk about later how the different CMOS timings are to determine. So there is an optimal, because if you actually insert too many pipeline stages, you're adding a lot of registers, right?
Sau này chúng ta sẽ nói về việc các thông số thời gian CMOS khác nhau quyết định điều đó như thế nào. Vậy nên có một giá trị tối ưu, vì nếu chèn quá nhiều tầng đường ống, bạn đang thêm rất nhiều thanh ghi, đúng không?
So that will actually make things also longer. So there's actually a trade-off, even just from a performance point of view. If it's too deeply pipelined, that could also get a performance penalty.
Điều đó cũng làm mọi thứ chậm đi. Vì vậy có một sự đánh đổi, ngay cả chỉ xét về hiệu năng. Nếu đường ống quá sâu, hiệu năng cũng có thể bị giảm.
So there is a trade-off there. If you read research work, maybe more like late 90s, early 2000s, that's when power became a bigger issue.
Vậy nên ở đây có một sự đánh đổi. Nếu đọc các công trình nghiên cứu, khoảng cuối thập niên 90, đầu những năm 2000, đó là lúc công suất tiêu thụ trở thành vấn đề lớn hơn.
So then when people actually approached this problem, they were basically looking for power and performance optimal. So it's not both performance, get a better performance, but also not consuming too much power.
Vì thế khi người ta tiếp cận bài toán này, họ tìm điểm tối ưu cả về công suất lẫn hiệu năng. Tức là không chỉ đạt hiệu năng tốt hơn, mà còn không tiêu thụ quá nhiều điện năng.
The same, you add a lot of registers, it actually adds a lot of power on top of that. If there are so many things executing in parallel, that also brings power.
Tương tự, khi bạn thêm nhiều thanh ghi, nó cũng làm tăng thêm đáng kể công suất tiêu thụ. Nếu có quá nhiều thứ thực thi song song thì cũng tốn thêm điện năng.
So it actually became a pretty complex design trade-off. There was a lot of research work to figure out what is the optimal number of pipeline stages, roughly.
Vì vậy nó trở thành một bài toán đánh đổi thiết kế khá phức tạp. Đã có rất nhiều công trình nghiên cứu để tìm ra số tầng đường ống tối ưu, một cách tương đối.
Yeah, that's a good question. So it's not always that deeper pipelines are better. There's a trade-off, and also how we can actually utilize that, especially when you get to an advanced architecture, right?
Vâng, câu hỏi hay. Không phải lúc nào đường ống sâu hơn cũng tốt hơn. Có sự đánh đổi, và cả việc chúng ta tận dụng nó như thế nào, đặc biệt khi đi đến các kiến trúc tiên tiến, đúng không?
So there's like a branch; we will actually also talk about the branch penalty, right? The penalty could also be large. So there is also a fairly complex trade-off there.
Chẳng hạn có lệnh rẽ nhánh; chúng ta cũng sẽ nói về cái giá của rẽ nhánh (branch penalty), đúng không? Cái giá đó cũng có thể lớn. Nên ở đây cũng có một sự đánh đổi khá phức tạp.
Yes. So the benefit is mostly pronounced when we actually fully utilize the pipeline. We'll also talk about later, there are actually a lot of issues, even for our simple pipeline.
Vâng. Vậy lợi ích rõ rệt nhất khi chúng ta tận dụng đầy đủ đường ống. Sau này chúng ta cũng sẽ nói rằng có rất nhiều vấn đề, ngay cả với đường ống đơn giản của chúng ta.
We cannot fully utilize this pipeline. So I mentioned earlier, this is the design we have.
Chúng ta không thể tận dụng hoàn toàn đường ống này. Như tôi đã nói lúc nãy, đây là thiết kế mà chúng ta có.
We talked about our five-stage execution before; we mostly just used those stages as a way to describe different functional units, right?
Trước đó chúng ta đã nói về quá trình thực thi năm tầng; chúng ta chủ yếu chỉ dùng các giai đoạn đó để mô tả các đơn vị chức năng khác nhau, đúng không?
But that also leads to a pretty natural way to actually pipeline the execution, where we're adding. Pipeline the registers, all those green, all those squares.
Nhưng điều đó cũng dẫn đến một cách khá tự nhiên để thực sự đưa việc thực thi vào đường ống, trong đó chúng ta thêm vào. Các thanh ghi đường ống, tất cả những ô vuông màu xanh lá đó.
It's basically a clocked register, right? So those are basically pipeline registers that we use to actually store intermediate values. It is also a way to actually get pipelined execution.
Về cơ bản nó là một thanh ghi có xung nhịp, đúng không? Vậy đó về cơ bản là các thanh ghi đường ống mà chúng ta dùng để lưu các giá trị trung gian. Đó cũng là một cách để có được việc thực thi theo đường ống.
Again, this is only one implementation; this is not the only implementation.
Một lần nữa, đây chỉ là một cách cài đặt; không phải là cách duy nhất.
We like to use a five-stage pipeline because it actually matches pretty well with the five different execution stages that we have in our pipeline.
Chúng ta thích dùng đường ống năm giai đoạn vì nó khớp khá tốt với năm giai đoạn thực thi khác nhau mà chúng ta có trong đường ống của mình.
It's a natural way to partition it, but there are different ways to do that. Question?
Đó là một cách chia tự nhiên, nhưng còn có những cách khác để làm điều đó. Có câu hỏi không?
That's a good question. We will actually get to that later. We actually also have registers for control logic.
Câu hỏi hay. Chúng ta sẽ nói đến phần đó sau. Thực ra chúng ta cũng có các thanh ghi cho logic điều khiển.
We actually need to have different control signals for different stages, right, because there are actually multiple instructions in flight.
Chúng ta cần có các tín hiệu điều khiển khác nhau cho các giai đoạn khác nhau, đúng không, vì có nhiều lệnh đang được xử lý cùng lúc.
So that's also, so far we only see datapaths, but we'll actually see in a couple of slides we will actually also need registers for control logic.
Vậy nên, cho đến giờ chúng ta mới chỉ thấy đường dữ liệu, nhưng trong vài slide nữa chúng ta sẽ thấy là cũng cần có các thanh ghi cho logic điều khiển.
So, yeah, we can actually, so now we can actually support different instructions in flight, different parts of the pipeline actually executing different instructions.
Vậy, đúng rồi, chúng ta có thể, giờ chúng ta có thể hỗ trợ nhiều lệnh khác nhau đang được xử lý cùng lúc, các phần khác nhau của đường ống thực thi các lệnh khác nhau.
We'll have pipeline registers where we can keep track of what's going on. We also actually need registers for control signals so that we can actually have different control throughout different stages.
Chúng ta sẽ có các thanh ghi đường ống để theo dõi những gì đang diễn ra. Chúng ta cũng cần các thanh ghi cho tín hiệu điều khiển để có thể có điều khiển khác nhau ở các giai đoạn khác nhau.
We'll actually be executing different instructions, we'll have different control signals for different stages, we'll actually make sure things are propagated right.
Chúng ta sẽ thực thi các lệnh khác nhau, nên sẽ có các tín hiệu điều khiển khác nhau cho từng giai đoạn, và phải bảo đảm mọi thứ được truyền đi đúng.
So this is not only the datapath, but also control signals; we also need to set things up.
Vậy đây không chỉ là đường dữ liệu, mà còn cả các tín hiệu điều khiển; chúng ta cũng cần thiết lập chúng.
We'll talk a little bit more about how we do that, and especially how we actually handle different hazards, different situations that actually stop us from actually achieving the full throughput in a pipelined execution.
Chúng ta sẽ nói thêm một chút về cách làm việc đó, và đặc biệt là cách xử lý các hazard khác nhau, tức những tình huống khác nhau ngăn chúng ta đạt được thông lượng tối đa khi thực thi theo đường ống.
Just some quick announcements. We don't have a lot of things to announce this week. We don't have a lab. Just, I heard a majority of you already finished last three. Very good, good job.
Xin thông báo nhanh vài việc. Tuần này không có nhiều thông báo. Chúng ta không có buổi lab. Tôi nghe nói đa số các em đã làm xong lab ba rồi. Rất tốt, làm tốt lắm.
Start a lot for as soon as possible, if you haven't. Right, so this is very important to actually keep things on track. I do have a, like, emergency or different scenario.
Nếu chưa làm thì hãy bắt đầu càng sớm càng tốt. Đúng vậy, điều này rất quan trọng để theo kịp tiến độ. Tôi có một tình huống khẩn cấp hay trường hợp khác.
We do have 14 sleep days, right? So the reason we have that huge number of sleep days is to make sure things are on track. There's always benefit to finish your labs, right?
Chúng ta có 14 sleep day, đúng không? Lý do chúng ta có số lượng sleep day lớn như vậy là để bảo đảm mọi thứ theo kịp tiến độ. Hoàn thành lab luôn có lợi, đúng không?
Don't feel like they're, like, a couple days late, there's no purpose of actually doing your labs. Always do your lab, you need to use a sleep days, right?
Đừng nghĩ rằng nếu trễ vài ngày thì làm lab chẳng còn ý nghĩa gì. Cứ luôn làm lab, nếu cần thì dùng sleep day, đúng không?
Always very important, make sure things are on track and get you very well prepared for the project. We'll have a new homework on the pipeline this week, I should be pretty sure.
Điều này luôn rất quan trọng, hãy đảm bảo mọi thứ đi đúng tiến độ và giúp các bạn chuẩn bị thật tốt cho đồ án. Tuần này chúng ta sẽ có một bài tập về nhà mới về đường ống, tôi khá chắc là vậy.
Just make sure you folks actually review the material. I saw some discussions on instruction format, whether we need to memorize anything. In this class we never need to memorize anything.
Các bạn nhớ ôn lại tài liệu nhé. Tôi thấy có một số thảo luận về định dạng lệnh, về việc có cần học thuộc gì không. Trong lớp này, các bạn không bao giờ cần học thuộc bất cứ thứ gì.
The RISC-V green card will be provided during the exam, both midterm and the final. You can also bring your own notes, whatever you feel you want to actually add for the exam.
Bảng RISC-V green card sẽ được cung cấp trong kỳ thi, cả giữa kỳ lẫn cuối kỳ. Các bạn cũng có thể mang theo ghi chú của riêng mình, bất cứ thứ gì bạn muốn bổ sung cho kỳ thi.
You are not supposed to memorize anything. We're teaching this principle, all you need to do is basically apply those principles to different scenarios, different cases.
Các bạn không phải học thuộc gì cả. Chúng tôi dạy các nguyên lý này, việc bạn cần làm về cơ bản là áp dụng các nguyên lý đó vào những tình huống khác nhau, những trường hợp khác nhau.
We did have basically a hand assembly question in the homework.
Trong bài tập về nhà có một câu hỏi dịch hợp ngữ bằng tay.
The reason for that, of course, you can basically use GCC or Venus to actually get the assembled, like, binary directly, feel free to do that.
Lý do là, tất nhiên, bạn hoàn toàn có thể dùng GCC hoặc Venus để lấy trực tiếp mã nhị phân đã được dịch, cứ làm như vậy cũng được.
The reason we put that there is, if you're interested, that's a good example, good opportunity to actually get a little bit more familiar with the instruction encoding so that you understand how things are actually encoded.
Chúng tôi đưa câu đó vào vì, nếu bạn quan tâm, đó là một ví dụ hay, một cơ hội tốt để bạn làm quen hơn một chút với cách mã hóa lệnh để hiểu các lệnh thực sự được mã hóa như thế nào.
That's all we want to do. Of course, there are a lot of resources available, but no need to memorize anything, and there are also a lot of tools available.
Đó là tất cả những gì chúng tôi muốn. Tất nhiên có rất nhiều tài nguyên sẵn có, nhưng không cần học thuộc gì cả, và cũng có rất nhiều công cụ sẵn có.
So if you want to use the tools, that's also fine. I'm very excited about the guest lecture. Next Tuesday we'll have a guest lecture from Apple.
Nên nếu bạn muốn dùng công cụ thì cũng không sao. Tôi rất háo hức với buổi giảng của khách mời. Thứ Ba tuần sau chúng ta sẽ có một bài giảng của khách mời đến từ Apple.
They will actually talk about how they use FPGA in their design to actually emulate fairly complex SoCs that they are building.
Họ sẽ nói về cách họ dùng FPGA trong thiết kế để mô phỏng các SoC khá phức tạp mà họ đang xây dựng.
So, so far we are mostly using our PYNQ boards for folks in the FPGA lab.
Cho đến nay, chúng ta chủ yếu dùng bo mạch PYNQ trong buổi thực hành FPGA.
Those are pretty good dev boards that can be, especially for a lot of different signal processing, just like getting something processed, interacting with sensor. That's one of the very important use cases of FPGA.
Đó là những bo mạch phát triển khá tốt, có thể dùng, đặc biệt cho nhiều loại xử lý tín hiệu khác nhau, chẳng hạn xử lý một thứ gì đó, tương tác với cảm biến. Đó là một trong những trường hợp sử dụng rất quan trọng của FPGA.
But another very important use case of FPGA, especially in today's hardware industry, is actually using FPGA to emulate SoC, so you can actually emulate how the hardware would behave before, we actually both before and after we actually do chip tape out, because the turnaround time is pretty long,
Nhưng một trường hợp sử dụng rất quan trọng khác của FPGA, đặc biệt trong ngành phần cứng ngày nay, là dùng FPGA để mô phỏng SoC, để bạn có thể mô phỏng phần cứng sẽ hoạt động ra sao trước khi, thực ra là cả trước và sau khi chúng ta thực hiện chip tape out, vì thời gian hoàn tất khá dài,
and the cost is pretty expensive to do a chip tape out.
và chi phí để thực hiện chip tape out khá đắt đỏ.
We want to make sure our designs are correct and we can set up things, especially for the software, run correctly, so FPGA is very useful for emulation.
Chúng ta muốn đảm bảo thiết kế đúng và có thể thiết lập mọi thứ, đặc biệt là để phần mềm chạy đúng, nên FPGA rất hữu ích cho việc mô phỏng.
So we'll have a guest lecture from Apple, who will actually share with us how they use FPGA to actually emulate, especially multiple FPGA to emulate pretty large SoCs that they are building, and some of the challenges that they are facing in their group, so it should be fun.
Vì vậy chúng ta sẽ có một bài giảng của khách mời từ Apple, người sẽ chia sẻ với chúng ta cách họ dùng FPGA để mô phỏng, đặc biệt là dùng nhiều FPGA để mô phỏng các SoC khá lớn mà họ đang xây dựng, và một số thách thức mà nhóm của họ đang gặp phải, nên chắc sẽ rất thú vị.
So next Tuesday we'll have a guest lecture on FPGA. Before I move on, any questions, thoughts, or anything?
Vậy thứ Ba tuần sau chúng ta sẽ có một buổi giảng khách mời về FPGA. Trước khi em đi tiếp, có câu hỏi, suy nghĩ hay ý kiến gì không?
Okay, things are going okay. Okay, good, good. So we're almost halfway. Again, lab is very important. I do use the actual week to actually catch up the lab.
Được rồi, mọi thứ có vẻ ổn. Tốt, tốt. Vậy là chúng ta đã đi gần nửa chặng đường. Một lần nữa, bài thực hành rất quan trọng. Hãy tận dụng tuần này để bắt kịp các bài thực hành.
We'll start lab six and five.
Chúng ta sẽ bắt đầu bài thực hành sáu và năm.
Next we'll basically have two more labs, lab five and lab six, and then roughly mid-October, the end of October, we'll actually get our project started so that you have enough time to actually do a substantial project.
Tiếp theo về cơ bản sẽ còn hai bài thực hành nữa, bài năm và bài sáu, và sau đó khoảng giữa tháng Mười, cuối tháng Mười, chúng ta sẽ bắt đầu đồ án để các bạn có đủ thời gian làm một đồ án thực sự có chiều sâu.
Okay, good. So with that, we'll transition back to our pipelining.
Được rồi. Vậy bây giờ chúng ta quay lại với kỹ thuật đường ống.
Right, so we talked about the basics of five-stage pipelining, but some of the discussion we had earlier, right, so the benefit of pipelining is basically, assuming we can actually get high throughput, making sure our hardware is actually running nonstop.
Chúng ta đã nói về những điều cơ bản của đường ống năm tầng, nhưng trong phần thảo luận lúc trước, lợi ích của đường ống về cơ bản là, giả sử chúng ta đạt được thông lượng cao, đảm bảo phần cứng luôn chạy liên tục không nghỉ.
That's actually a pretty ideal scenario, and there are actually a lot of situations, or what people call hazards, that stop us from getting full throughput when we actually do pipeline execution.
Đó là một tình huống khá lý tưởng, và thực tế có rất nhiều tình huống, hay còn gọi là các hazard, ngăn chúng ta đạt thông lượng tối đa khi thực thi theo đường ống.
So we'll take a look at what are the different hazards that stop us from fully utilizing our hardware, right.
Vì vậy ta sẽ xem có những hazard nào khiến chúng ta không tận dụng hết được phần cứng.
So again, when we talk about microarchitecture, I want to say a hazard is basically a scenario where we cannot start a new instruction immediately in the next clock cycle.
Khi nói về vi kiến trúc, hazard về cơ bản là một tình huống mà ta không thể bắt đầu một lệnh mới ngay ở chu kỳ xung nhịp kế tiếp.
There are a lot of, there are different reasons that actually stop us from doing that. We generally categorize those into three different reasons, or three different hazards.
Có rất nhiều, có nhiều lý do khác nhau khiến ta không làm được điều đó. Chúng ta thường chia thành ba lý do, hay ba loại hazard.
Right, the first one is actually structural hazard. That actually turned out to be the easiest one.
Loại đầu tiên là hazard cấu trúc. Đây hóa ra là loại dễ nhất.
That's basically there is some competition for a shared resource or structure unit, right, that is actually needed by multiple instructions in multiple stages.
Về cơ bản là có sự tranh chấp một tài nguyên dùng chung hoặc một đơn vị cấu trúc, mà nhiều lệnh ở nhiều tầng khác nhau cùng cần đến.
That actually stops us from actually pipelining our execution completely. We'll talk about what it is and how we actually work around it. So that's structural hazard. The second one is actually more fundamental.
Điều đó khiến ta không thể chạy đường ống hoàn toàn được. Chúng ta sẽ nói nó là gì và cách khắc phục. Đó là hazard cấu trúc. Loại thứ hai mang tính căn bản hơn.
This is actually more intrinsic to the instructions, where there are data dependencies between instructions.
Loại này gắn liền với bản chất của các lệnh, khi có sự phụ thuộc dữ liệu giữa các lệnh.
In a scenario, we actually need the result from the previous instruction to actually execute my current, to support my current execution. So that's actually very fundamental, very intrinsic to the program, right?
Trong tình huống này, ta cần kết quả từ lệnh trước để thực thi lệnh hiện tại, để phục vụ việc thực thi hiện tại của mình. Điều này rất căn bản, gắn liền với chính chương trình, đúng không?
That also stops us from actually fully utilizing our flow. Finally, control hazard. The name suggests it's related to the control flow, right? We do mention, we did talk about the conditional branch instruction, right?
Nó cũng khiến ta không tận dụng hết được luồng thực thi. Cuối cùng là hazard điều khiển. Tên gọi cho thấy nó liên quan đến luồng điều khiển, đúng không? Chúng ta đã nhắc đến lệnh rẽ nhánh có điều kiện, đúng không?
We talked about how a branch is actually executed in a pipeline fashion and why that actually executed branch instruction could also stop us from actually fully pipelining.
Chúng ta đã nói về cách một lệnh rẽ nhánh được thực thi theo kiểu đường ống và vì sao lệnh rẽ nhánh được thực thi đó có thể cũng ngăn chúng ta chạy đường ống hoàn toàn quá trình thực thi. Một lần nữa, loại đầu tiên thiên về tài nguyên.
Our execution. Again, the first one is very resource oriented. The second one, the last two are actually more intrinsic to the program, right?
Loại thứ hai, hai loại cuối thực ra mang tính nội tại của chương trình hơn, đúng không?
Whether there's data dependencies, or whether we have control flow divergence, that we cannot actually predict which path that we are going to take.
Đó là việc có phụ thuộc dữ liệu hay không, hoặc có rẽ nhánh luồng điều khiển hay không, khiến ta không thể dự đoán được mình sẽ đi theo đường nào.
So those are the three different hazards that we're going to talk about when it comes to pipeline execution. So we'll start with structural hazard, right? We already discussed earlier, right?
Vậy đó là ba loại hazard khác nhau mà chúng ta sẽ nói đến khi bàn về việc thực thi theo đường ống. Chúng ta sẽ bắt đầu với structural hazard nhé? Chúng ta đã thảo luận ở trước rồi, đúng không?
So this is basically whenever we have competition, where multiple instructions actually compete for a shared physical resource. This is actually pretty easy, right?
Về cơ bản đây là khi có sự tranh chấp, trong đó nhiều lệnh cùng tranh nhau một tài nguyên vật lý dùng chung. Cái này thực ra khá dễ, đúng không?
If this is actually just purely about resources, it's actually an easy problem. Basically, we can always have a solution by actually putting more resources to address the problem, right?
Nếu vấn đề thuần túy là về tài nguyên thì đó là một bài toán dễ. Về cơ bản lúc nào ta cũng có cách giải quyết bằng việc bổ sung thêm tài nguyên để xử lý vấn đề, đúng không?
So if this is actually purely just a resource problem, it's always the easiest one, right? Okay, so of course, there are different solutions.
Nên nếu đây hoàn toàn chỉ là vấn đề tài nguyên, thì nó luôn là loại dễ nhất. Dĩ nhiên là có nhiều giải pháp khác nhau.
We'll see solution again and again, multiple times when we handle hazard. Basically, we can always stop. Whenever there is a scenario that stops us from fully utilizing the pipeline, right?
Chúng ta sẽ gặp lại giải pháp này nhiều lần khi xử lý hazard. Về cơ bản, lúc nào ta cũng có thể dừng lại. Bất cứ khi nào có tình huống ngăn ta tận dụng hết đường ống, đúng không?
We cannot support either because of control hazard, because of data hazard, or because of structural hazard.
Ta không thể hỗ trợ được, dù là do control hazard, do data hazard, hay do structural hazard.
We can always stop our execution so that they are not competing for the same resources in this context. Again, there's a performance penalty, right?
Ta luôn có thể dừng việc thực thi lại để chúng không tranh nhau cùng một tài nguyên trong trường hợp này. Nhưng lại phải trả giá về hiệu năng.
So there's performance will get worse, right? So it's not free. This is easy. We can always stop, but it hurts performance. You will actually want to fundamentally address the problem without hurting performance.
Hiệu năng sẽ kém đi, nên nó không miễn phí. Cái này dễ hiểu. Ta luôn có thể dừng lại, nhưng điều đó làm giảm hiệu năng. Ta sẽ muốn giải quyết tận gốc vấn đề mà không làm giảm hiệu năng.
Again, for structural hazard, it's actually easy. So if this is a resource problem, we just add more resources so that they are actually not competing for shared resources.
Một lần nữa, với structural hazard thì việc đó dễ. Nếu đây là vấn đề về tài nguyên, ta chỉ cần thêm tài nguyên để chúng không phải tranh nhau tài nguyên dùng chung.
You will have enough of the same instruction.
Bạn sẽ có đủ các bản của cùng một đơn vị.
Mm hmm.
Vâng.
Right. I mean, eventually, maybe we still need to stop, right? So we'll actually talk about that. For example, I guess you mentioned like the second stage, the decoding and register file access, right?
Đúng. Ý tôi là, rốt cuộc có thể ta vẫn phải dừng, đúng không? Chúng ta sẽ nói về điều đó. Ví dụ, tôi nghĩ bạn vừa nhắc đến giai đoạn thứ hai, giải mã và truy cập tệp thanh ghi, đúng không?
It's not for you. We have a superscalar processor. We have multiple instructions. All of them need to actually read instruction, read data from the register file.
Không chỉ có thế. Ta có bộ xử lý superscalar, có nhiều lệnh cùng lúc. Tất cả chúng đều cần đọc lệnh, đọc dữ liệu từ tệp thanh ghi.
It's very expensive to actually build a multi-ported register file, right? So it's really like your threshold, how many more resources you are comfortable actually putting there. It's not unlimited, right?
Việc xây dựng một tệp thanh ghi nhiều cổng rất tốn kém. Nên thực chất đó là ngưỡng của bạn, bạn thấy ổn khi bỏ thêm bao nhiêu tài nguyên vào đó. Nó không phải là vô hạn.
So you can have, we'll talk about the way to actually have a multi-ported register file, but two ports are pretty comfortable, maybe four, but it's going to be very hard to actually grow.
Vì vậy bạn có thể có, chúng ta sẽ nói về cách tạo ra tệp thanh ghi nhiều cổng, nhưng hai cổng thì khá thoải mái, có thể là bốn, nhưng sẽ rất khó để mở rộng thêm.
So, yes. So solution two, as long as we can afford the resource, we go with solution two, but if we cannot afford the additional resources, we still need to revert back to solution one.
Vâng. Vậy với giải pháp hai, miễn là chúng ta đủ khả năng chi trả tài nguyên, thì ta chọn giải pháp hai, nhưng nếu chúng ta không đủ khả năng chi trả thêm tài nguyên, thì ta vẫn phải quay lại giải pháp một.
And your name is? Ruben. Ruben. Okay, good. Good question, Ruben.
Bạn tên là gì? Ruben. Ruben. Được rồi, tốt. Câu hỏi hay, Ruben.
Yeah, so solution two will work as long as we can add more hardware, but at some point, we will actually also need to stop.
Đúng vậy, giải pháp hai sẽ hiệu quả miễn là ta có thể thêm phần cứng, nhưng đến một lúc nào đó, ta cũng sẽ phải dừng lại.
So we'll talk a lot, talk a little bit more about different scenarios. Oh, well, actually, that's basically what I was talking about earlier.
Vì vậy chúng ta sẽ nói thêm một chút về các tình huống khác nhau. À, thật ra đó chính là điều tôi đã nói lúc nãy.
So one of the common resource structures is basically register file access. Even if you look at basically the base encoding, right? So each instruction will need to read two operands.
Một trong những cấu trúc tài nguyên phổ biến chính là việc truy cập register file. Ngay cả khi bạn nhìn vào cách mã hóa cơ bản, đúng không? Mỗi lệnh sẽ cần đọc hai toán hạng.
We think about register-to-register operation, right? We need to read two operands, and we also need to write the value in the write back stage, right?
Hãy nghĩ về phép toán giữa các thanh ghi, đúng không? Ta cần đọc hai toán hạng, và ta cũng cần ghi giá trị ở giai đoạn ghi lại, đúng không?
A very straightforward way to actually handle register file hazard is basically having dedicated ports, right? In a lot of discussion, we basically would actually discuss this earlier, right?
Một cách rất đơn giản để xử lý hazard của register file là dùng các cổng riêng, đúng không? Trong nhiều buổi thảo luận, ta đã bàn về điều này trước đó, đúng không?
We'll have two read ports and one write port, right? So this will even just intrinsically fit with the instruction decoding, encoding, right?
Ta sẽ có hai cổng đọc và một cổng ghi, đúng không? Điều này vốn dĩ khớp với việc giải mã lệnh, mã hóa, đúng không?
Always two register, two memory accesses and two register file accesses and reads and one register, one register actually writes, right?
Luôn là hai thanh ghi, hai lần truy cập bộ nhớ và hai lần truy cập register file để đọc, và một thanh ghi, một thanh ghi được ghi, đúng không?
So that basically this can also happen simultaneously. We'll actually talk about how we do actually multi-ported register file later.
Nhờ vậy các thao tác này cũng có thể diễn ra đồng thời. Sau này chúng ta sẽ nói về cách xây dựng register file nhiều cổng.
We'll actually start our CMOS session, so we'll actually come back in terms of how this can be implemented, right? So we also mentioned that you will actually talk about a superscalar processor.
Chúng ta sẽ bắt đầu phần CMOS, và sẽ quay lại xem điều này có thể được hiện thực như thế nào, đúng không? Chúng ta cũng đã đề cập rằng bạn sẽ học về bộ xử lý superscalar.
We can also actually multiple instructions will need to actually access register file simultaneously. It's going to be very, it will be very expensive to actually keep growing, right?
Khi đó nhiều lệnh sẽ cần truy cập register file cùng lúc. Việc cứ tiếp tục mở rộng sẽ rất tốn kém, đúng không?
So that's actually one of the limitations of superscalar processor. It's very hard to build multi-ported register file to actually support this concurrency, right?
Đó là một trong những hạn chế của bộ xử lý superscalar. Rất khó xây dựng register file nhiều cổng để hỗ trợ tính đồng thời này, đúng không?
So this is a very, well, we can actually put more resources as long as we can afford it, but we cannot afford if the resource actually become very expensive, right?
Vậy nên đây là một vấn đề rất, à, ta có thể thêm tài nguyên miễn là ta đủ khả năng chi trả, nhưng ta không thể nếu tài nguyên trở nên quá đắt đỏ, đúng không?
We still need to scale. So that's a lot of, I guess, in the very beginning of the class, right?
Chúng ta vẫn cần mở rộng quy mô. Đó là điều mà, tôi nghĩ, ngay từ đầu môn học, đúng không?
We talk about a lot of hardware design is actually navigating this big design space, doing trade off, right?
Chúng ta đã nói rằng thiết kế phần cứng phần lớn là việc định hướng trong không gian thiết kế rộng lớn này, và đánh đổi, đúng không?
A lot about how much performance benefit that we can get and whether we can actually afford the cost. But for our discussion, we're basically doing a scalar in-order processor.
Đó là xem ta có thể thu được bao nhiêu lợi ích về hiệu năng và liệu ta có đủ khả năng chi trả chi phí hay không. Nhưng trong phần thảo luận của chúng ta, ta đang làm bộ xử lý scalar thực thi theo thứ tự.
We can actually support concurrent read, two read ports and one write ports, right? And then we can basically support the concurrent accesses from the register file.
Chúng ta có thể hỗ trợ đọc đồng thời, hai cổng đọc và một cổng ghi, đúng không? Và như vậy ta có thể hỗ trợ các truy cập đồng thời vào register file.
So that's the first hazard when we actually need to access the register file concurrently. Another hazard, potential hazard, is to actually access memory concurrently.
Đó là hazard đầu tiên khi ta cần truy cập register file một cách đồng thời. Một rủi ro khác, một rủi ro tiềm ẩn, là truy cập bộ nhớ đồng thời.
In particular, you will actually look at our implementation. Again, you will look things vertically. It's basically at a particular time.
Cụ thể, các em hãy nhìn vào cách triển khai của chúng ta. Một lần nữa, các em nhìn theo chiều dọc. Tức là tại một thời điểm nhất định.
All the resources are actually used by different instructions, but by used concurrently at a particular slot, right?
Tất cả các tài nguyên đều đang được các lệnh khác nhau sử dụng, nhưng được dùng đồng thời tại một khe thời gian nhất định, đúng không?
We look at this, we think about memory, we do see some concurrency here where we are writing to the memory during the memory access stage, data memory.
Khi nhìn vào đây và nghĩ về bộ nhớ, ta thấy có sự đồng thời ở chỗ ta đang ghi vào bộ nhớ trong giai đoạn truy cập bộ nhớ, tức bộ nhớ dữ liệu.
At the same time, we also need to access our instruction memory so that we can actually read instructions from our instruction memory, right?
Cùng lúc đó, ta cũng cần truy cập bộ nhớ lệnh để có thể đọc các lệnh từ bộ nhớ lệnh, đúng không?
So this, You will actually have a shared instruction and data memory, and that could also be a conflict, a structural hazard. This is also pretty easy to resolve.
Vì vậy, nếu các em dùng chung một bộ nhớ cho lệnh và dữ liệu, thì cũng có thể xảy ra xung đột, một rủi ro cấu trúc. Điều này cũng khá dễ giải quyết.
We basically have a dedicated instruction memory and data memory. In today's processors, you also see a dedicated I-cache and D-cache, right?
Ta chỉ cần có bộ nhớ lệnh và bộ nhớ dữ liệu riêng biệt. Trong các bộ xử lý ngày nay, các em cũng thấy có I-cache và D-cache riêng, đúng không?
So this is also trying to avoid these first-stage hazards when it comes to memory accesses. So we have dedicated accesses for memory, for data, and for instructions. So that's another, yeah.
Điều này cũng nhằm tránh các rủi ro ở giai đoạn đầu khi truy cập bộ nhớ. Vậy là ta có các đường truy cập riêng cho bộ nhớ, cho dữ liệu và cho lệnh. Đó là một điểm nữa, vâng.
So as the notes suggest, we are using instruction and data memory concurrently, so we can actually use two separate memories. That's for memory accesses.
Như ghi chú có nói, ta dùng bộ nhớ lệnh và bộ nhớ dữ liệu đồng thời, nên ta có thể dùng hai bộ nhớ riêng biệt. Đó là về truy cập bộ nhớ.
So for structural hazards, we're talking about conflicts over shared resources. In the RISC-V pipeline, we need to read and write data with our load and store instructions.
Với rủi ro cấu trúc, ta đang nói về xung đột trên các tài nguyên dùng chung. Trong đường ống RISC-V, ta cần đọc và ghi dữ liệu bằng các lệnh load và store.
We also need to read instructions from instruction memory, right? So with that, we will have separate instruction and data memory to resolve the memory hazard.
Ta cũng cần đọc lệnh từ bộ nhớ lệnh, đúng không? Vì vậy, ta sẽ có bộ nhớ lệnh và bộ nhớ dữ liệu riêng để giải quyết rủi ro bộ nhớ.
In today's modern processors, we're really talking about a dedicated instruction and data cache, again, to actually support concurrency.
Trong các bộ xử lý hiện đại ngày nay, ta thực sự nói đến cache lệnh và cache dữ liệu riêng, một lần nữa là để hỗ trợ tính đồng thời.
And it will actually, look at the RISC-V, I'd say we're actually not doing any complex operations. For each instruction, we only do one memory access.
Và nếu nhìn vào RISC-V, có thể nói ta không thực hiện thao tác phức tạp nào. Với mỗi lệnh, ta chỉ truy cập bộ nhớ một lần.
I have a question about the structural hazard of the instruction memory and data memory. I understand it makes sense if you have two different caches, like an I-cache and D-cache.
Em có một câu hỏi về rủi ro cấu trúc của bộ nhớ lệnh và bộ nhớ dữ liệu. Em hiểu là hợp lý nếu có hai cache khác nhau, như I-cache và D-cache.
They can be physically separate so that there is no structural hazard. But are you also saying it's possible to use different memory? Yeah, yeah.
Chúng có thể tách biệt về vật lý nên không có rủi ro cấu trúc. Nhưng thầy cũng nói là có thể dùng các bộ nhớ khác nhau? Vâng, đúng vậy.
Like they literally sit at different positions on the floor plan. Right, so here in particular, especially when you come to, in today's modern processors, we're really talking about a cache, right?
Kiểu như chúng nằm ở các vị trí khác nhau trên sơ đồ mặt bằng. Đúng, cụ thể ở đây, nhất là khi nói đến các bộ xử lý hiện đại ngày nay, ta thực sự nói đến cache, đúng không?
So this is actually more of a toy datapath that we use. Again, it's pretty close to real, still a toy datapath that we use for the project.
Còn đây thực ra là một đường dữ liệu đơn giản hóa mà ta dùng. Nó khá gần với thực tế, nhưng vẫn là đường dữ liệu đơn giản hóa mà ta dùng cho đồ án.
So here, when you come to the design, it's more like two separate SRAMs. One SRAM, or BRAM in FPGA. So basically one RAM for instruction memory and one RAM for data memory.
Vậy khi thiết kế, nó giống như hai SRAM riêng biệt. Một SRAM, hoặc BRAM trong FPGA. Tức là một RAM cho bộ nhớ lệnh và một RAM cho bộ nhớ dữ liệu.
So we're basically instantiating two different memories. So for our project, we're basically assuming two memories are separate. Separate, yes.
Về cơ bản, ta đang khởi tạo hai bộ nhớ khác nhau. Vậy trong project của chúng ta, về cơ bản ta giả định hai bộ nhớ là tách biệt. Đúng, tách biệt.
For this class, which can map naturally to today's I-cache and D-cache. But we do simplify a lot. We don't need to actually do a lot of cache handling.
Với lớp này, điều đó có thể ánh xạ một cách tự nhiên sang I-cache và D-cache ngày nay. Nhưng chúng ta đã đơn giản hóa đi rất nhiều. Chúng ta không thực sự cần xử lý cache nhiều.
So we basically say this is a dedicated SRAM for instruction, another SRAM for data.
Nên về cơ bản ta nói đây là một SRAM riêng cho lệnh, và một SRAM khác cho dữ liệu.
So if you have a computer, let's say a computer with 60 gigs of memory, is that 60 gigs partitioned into instruction and data?
Vậy nếu có một máy tính, giả sử máy tính có 60 gigabyte bộ nhớ, thì 60 gigabyte đó được chia thành phần cho lệnh và phần cho dữ liệu à?
Or is it 60 gigs of data, and then 60 gigs of memory, and then there's a lot of memory? Right, that's a good question.
Hay là 60 gigabyte dữ liệu, rồi lại 60 gigabyte bộ nhớ, rồi có rất nhiều bộ nhớ? Vâng, đó là một câu hỏi hay.
So we actually, again, we are talking about, for this class, we're mostly talking about datapaths, but we actually don't touch a lot about memory hierarchy.
Thực ra, một lần nữa, chúng ta đang nói về lớp này, chủ yếu chúng ta nói về datapath, nhưng thực ra chúng ta không đụng nhiều đến phân cấp bộ nhớ.
So when we come actually to modern processors, we have this kind of hierarchical caches, right? L1, L2, and L3. And then finally, we get to actually memory, DRAM, right?
Khi nói đến các bộ xử lý hiện đại, chúng ta có các cache phân cấp như thế này, đúng không? L1, L2 và L3. Và cuối cùng mới đến bộ nhớ, DRAM, đúng không?
So basically the I-cache and the D-cache separation only happens at L1 cache, basically very close to the processor pipeline. We actually have the separation.
Vậy sự tách biệt giữa I-cache và D-cache chỉ xảy ra ở cache L1, tức là rất gần với đường ống của bộ xử lý. Ở đó chúng ta mới có sự tách biệt.
After that, in the cache hierarchy and the memory hierarchy, they are basically address and data. You actually don't differentiate whether this data is actually encoding instructions or whether this data is actually data.
Sau đó, trong phân cấp cache và phân cấp bộ nhớ, chỉ còn địa chỉ và dữ liệu. Thực ra bạn không phân biệt dữ liệu này là mã hóa các lệnh hay dữ liệu này là dữ liệu thật sự.
It doesn't really matter when you come to cache hierarchy, only the interface to the processor. Basically, only L1 has separation of I-cache and D-cache. There are some interesting proposals.
Điều đó không quan trọng khi nói đến phân cấp cache, mà chỉ quan trọng ở giao diện với bộ xử lý. Về cơ bản, chỉ L1 mới tách I-cache và D-cache. Có một số đề xuất thú vị.
I have dedicated L2 cache for instruction to actually make, especially for the large footprint of the instruction. Those are more like proposals.
Có cache L2 riêng cho lệnh để đặc biệt xử lý trường hợp lượng lệnh chiếm bộ nhớ rất lớn. Đó chủ yếu là các đề xuất.
But when it comes to the memory hierarchy, we're basically address and data interface. We don't differentiate instruction and data at that point.
Nhưng khi nói đến phân cấp bộ nhớ, về cơ bản chỉ có giao diện địa chỉ và dữ liệu. Lúc đó chúng ta không phân biệt lệnh và dữ liệu.
Can you clarify, when you're saying cache and memory, what part of this includes cache? Are we drawing the cache onto the path? That's a good question.
Bạn có thể làm rõ không, khi bạn nói cache và bộ nhớ, thì phần nào bao gồm cache? Chúng ta có vẽ cache vào đường dữ liệu không? Đó là câu hỏi hay.
Cache and memory are not part of our datapath in this datapath.
Cache và bộ nhớ không thuộc datapath này.
In this datapath, we do have instruction memory and data memory.
Trong datapath này, chúng ta có bộ nhớ lệnh và bộ nhớ dữ liệu.
We're not doing cache in this datapath, but we do have memory. That's what Rembrandt asked earlier. In reality, this will basically be one SRAM and one SRAM.
Datapath này không có cache, nhưng có bộ nhớ. Đó là điều Rembrandt đã hỏi lúc nãy. Trên thực tế, đây về cơ bản sẽ là một SRAM và một SRAM.
We're not talking about the memory hierarchy that we had discussed before. They will be two separate units in this design? They will instantiate two.
Chúng ta không nói về phân cấp bộ nhớ mà ta đã thảo luận trước đó. Chúng sẽ là hai đơn vị riêng biệt trong thiết kế này? Họ sẽ khởi tạo hai bộ nhớ.
Eventually, when it comes to physical realization, basically address data interface, you will instantiate a separate instruction memory and the data memory for this particular datapath.
Cuối cùng, khi hiện thực hóa về mặt vật lý, về cơ bản là giao diện địa chỉ và dữ liệu, bạn sẽ khởi tạo một bộ nhớ lệnh riêng và một bộ nhớ dữ liệu riêng cho datapath này.
Okay, so these are the only two memories we're going to implement? Yes. Most of the CPU is memory? What do you mean, most of the CPU?
Vậy đây là hai bộ nhớ duy nhất mình sẽ hiện thực à? Đúng. Phần lớn CPU là bộ nhớ sao? Ý em là phần lớn CPU là sao?
I thought you meant area-wise? Yeah. Is that 52 blocks? Right, right, right.
Em tưởng ý thầy là xét theo diện tích? Đúng vậy. Có phải là 52 khối không? Đúng, đúng, đúng.
So again, for this class discussion, we always have ISA as a standard. Different microarchitecture will be different implementations. A particular ISA can be implemented in different ways.
Vậy trong buổi thảo luận của lớp này, ta luôn lấy ISA làm chuẩn. Các vi kiến trúc khác nhau sẽ là các cách hiện thực khác nhau. Một ISA có thể được hiện thực theo nhiều cách khác nhau.
So we show some of the bifocal where SRAM, basic memory, on-chip SRAM is actually a very considerable area.
Nên ta cho thấy một số hình ảnh, trong đó SRAM, bộ nhớ cơ bản, SRAM trên chip thực ra chiếm diện tích rất đáng kể.
Those memories are largely, like what we've discussed earlier, cache hierarchy, level one cache, level two cache, level, like last level cache.
Những bộ nhớ đó phần lớn là, như ta đã bàn trước đó, phân cấp cache, cache cấp một, cache cấp hai, cho đến cache cấp cuối cùng.
You will see a lot of this topic, especially in 152, talking about modern memory hierarchy.
Các bạn sẽ gặp nhiều chủ đề này, đặc biệt là trong 152, nói về phân cấp bộ nhớ hiện đại.
In this particular ISA that we use for class discussion, in particular, microarchitecture we use for class discussion, and you will actually implement a pretty similar one, but a slightly different one.
Với ISA cụ thể mà ta dùng để thảo luận trong lớp, cụ thể là vi kiến trúc mà ta dùng để thảo luận trong lớp, các bạn sẽ hiện thực một vi kiến trúc khá giống, nhưng hơi khác một chút.
In your project, we are not talking about the cache hierarchy. We are actually using the two separate instruction memory and the data memory to represent how we actually store instructions and data.
Trong dự án của các bạn, ta không nói đến phân cấp cache. Ta thực sự dùng hai bộ nhớ riêng, bộ nhớ lệnh và bộ nhớ dữ liệu, để biểu diễn cách ta lưu lệnh và dữ liệu.
And you don't insert the register file memory? Yes, we separate register file in this class.
Và em không đưa tệp thanh ghi vào bộ nhớ à? Đúng, trong lớp này ta tách riêng tệp thanh ghi.
When we actually talk about, so yes, we don't consider register file as part of memory. Those are dedicated to store registers.
Khi ta nói về vậy, đúng, ta không coi tệp thanh ghi là một phần của bộ nhớ. Chúng được dành riêng để lưu các thanh ghi.
So, for instance, when you have your instruction memory data, do you get the same after states, like, for example, the last level, or what happens if you write into the instruction memory?
Ví dụ, khi bạn có dữ liệu trong bộ nhớ lệnh, bạn có nhận được cùng trạng thái sau đó không, ví dụ ở cấp cuối cùng, hoặc điều gì xảy ra nếu bạn ghi vào bộ nhớ lệnh?
So you're basically, oh, yeah, the self modifying code. Well, it depends whether you're touching kernel code, they would actually raise an exception because you're not supposed to touch it.
Ý em là, à đúng rồi, mã tự sửa đổi. Thì còn tùy bạn có đụng đến mã kernel hay không, hệ thống sẽ phát sinh một ngoại lệ vì bạn không được phép đụng vào nó.
Or you are, again, you can actually write to the program that is basically a self modifying program, right?
Hoặc là, một lần nữa, bạn có thể ghi vào chương trình và đó về cơ bản là một chương trình tự sửa đổi, đúng không?
So whether it's actually either expected execution or not expected execution there, that will be actually a programming model that's actually not part of the ISA.
Việc đó là thực thi được mong đợi hay không được mong đợi ở đây, thì đó là mô hình lập trình, và nó không thuộc ISA.
Yeah, that's for how we actually are supposed to program the architecture.
Đúng, đó là về cách ta được cho là lập trình trên kiến trúc này.
Okay, so that's the memory discussion, and yes, for this class we basically assume two separate memories, so that we can actually access instruction and data concurrently.
Được rồi, vậy là xong phần thảo luận về bộ nhớ, và đúng, trong lớp này ta giả định có hai bộ nhớ riêng, để có thể truy cập lệnh và dữ liệu đồng thời.
So that's the structural hazard. Second, as for the first, the other structural hazard we talked about: shared, competing accesses to register files and also competing accesses to memory.
Đó chính là hazard cấu trúc. Thứ hai, như hazard cấu trúc còn lại mà ta đã nói: các truy cập dùng chung, tranh chấp đến tệp thanh ghi và cũng tranh chấp đến bộ nhớ.
To some extent, we basically have separate ports, duplicating, so that we can support concurrency.
Ở một mức độ nào đó, ta có các cổng riêng, nhân đôi lên, để có thể hỗ trợ tính đồng thời.
If we cannot do that, there's still a competition, a shared resource, we still need to stall for the structural hazard.
Nếu không làm được như vậy thì vẫn còn tranh chấp, một tài nguyên dùng chung, và ta vẫn phải làm trễ (stall) đường ống vì hazard cấu trúc.
So that's the first one, and we're going to move to talk about the next one, the data hazard. The data hazard is actually more intrinsic, the data dependencies in the instruction execution.
Đó là loại thứ nhất, và bây giờ ta chuyển sang loại tiếp theo, hazard dữ liệu. Hazard dữ liệu thực ra mang tính bản chất hơn, đó là các phụ thuộc dữ liệu trong quá trình thực thi lệnh.
So, we talked about, for example, we actually come to the register access, right? So we talked about data hazards, like dependency in the execution.
Ví dụ, ta đã nói về việc truy cập thanh ghi, đúng không? Ta đã nói về hazard dữ liệu, tức là sự phụ thuộc trong quá trình thực thi.
A very common example is that when we actually need to read the data that's actually being produced by some previous instruction. So, what do we mean by that?
Một ví dụ rất phổ biến là khi ta cần đọc dữ liệu đang được tạo ra bởi một lệnh trước đó. Vậy điều đó nghĩa là gì?
So, here, like we talked about, for register file access we have separate ports. We can actually support concurrent read, right, because they're actually using different ports.
Ở đây, như ta đã nói, việc truy cập tệp thanh ghi dùng các cổng riêng biệt. Ta có thể hỗ trợ đọc đồng thời, vì chúng dùng các cổng khác nhau.
But we are actually, instead of actually just having different ports, we are actually writing and reading the same value.
Nhưng ở đây, chứ không chỉ đơn thuần là có các cổng khác nhau, ta đang ghi và đọc cùng một giá trị.
So for this example, we're doing an addition instruction where we're adding the results to the T zero register, right? So we're updating the T zero register in this pipeline in the first instruction.
Trong ví dụ này, ta có một lệnh cộng với kết quả được cộng vào thanh ghi T zero, đúng không? Vậy lệnh đầu tiên trong đường ống này đang cập nhật thanh ghi T zero.
When it comes to the store, we're actually reading the value of T zero and storing it to memory. So this is what people call a read after write dependency, right?
Đến lệnh store, ta đọc giá trị của T zero và lưu nó vào bộ nhớ. Đây là cái mà người ta gọi là phụ thuộc đọc sau ghi, đúng không?
We perform a write first, we're writing a particular value, and then we read it afterwards. Right, so this is very intrinsic. This is intrinsic data dependency, part of the program. Right.
Ta ghi trước, tức là ghi một giá trị nào đó, rồi sau đó mới đọc nó. Vì vậy điều này mang tính bản chất. Đây là phụ thuộc dữ liệu bản chất, một phần của chương trình.
What we want to make sure, to make sure of a correct execution, is that we need to actually fetch the correct value.
Để đảm bảo thực thi đúng, điều ta cần là phải lấy đúng giá trị.
In this particular case we need to actually fetch the updated value, because that follows program order, right?
Trong trường hợp này ta cần lấy giá trị đã được cập nhật, vì điều đó tuân theo thứ tự chương trình, đúng không?
You will actually follow the program order: T zero is updated first by this add instruction, and then stored later, so we are supposed to actually grab the new value in the execution to actually follow the read after write dependency.
Ta phải tuân theo thứ tự chương trình: T zero được cập nhật trước bởi lệnh add này, rồi sau đó mới được lưu, nên ta phải lấy giá trị mới khi thực thi để tuân theo phụ thuộc đọc sau ghi.
You will actually think about execution in our current pipeline, right? So both behaviors, both actions, actually happened in this cycle. So again, this is time, right.
Hãy nghĩ về việc thực thi trong đường ống hiện tại của ta. Cả hai hành động đều xảy ra trong chu kỳ này. Một lần nữa, đây là trục thời gian.
So we're writing to the register file, and then we're reading from the register file, right? So then it's actually very hard to determine, right, what value is actually being read.
Ta ghi vào tệp thanh ghi, và đồng thời đọc từ tệp thanh ghi, đúng không? Do đó rất khó xác định giá trị nào đang được đọc.
We may actually read the earlier value, we may actually read the new value. To actually make sure we behave correctly, we actually get the right value, there are different ways to handle this.
Ta có thể đọc giá trị cũ, cũng có thể đọc giá trị mới. Để đảm bảo hoạt động đúng, và lấy được giá trị đúng, có nhiều cách xử lý khác nhau.
For this pipeline, one solution.
Với đường ống này, có một giải pháp.
One solution to it is actually to separate the register access stage, so that we can actually write to the register, basically the first half of the clock cycle, and then read the data, assuming the second half of the clock cycle.
Một giải pháp là tách riêng giai đoạn truy cập thanh ghi, để chúng ta thực sự có thể ghi vào thanh ghi, về cơ bản là trong nửa đầu của chu kỳ xung nhịp, rồi sau đó đọc dữ liệu, giả sử là trong nửa sau của chu kỳ xung nhịp.
So we basically, again, still try to handle this dependency, read after write dependency, but we do have this policy in register file access policy, is where the write actually happens always at the beginning of the execution, and then we're doing combinational read, right?
Vậy về cơ bản, một lần nữa, chúng ta vẫn cố xử lý phụ thuộc này, phụ thuộc đọc sau ghi, nhưng chúng ta có chính sách này trong chính sách truy cập register file, đó là việc ghi luôn xảy ra ngay từ đầu quá trình thực thi, và sau đó chúng ta thực hiện đọc tổ hợp, đúng không?
So read the results being read, we only grab the results at the next rising state, the next clock, right?
Tức là khi đọc kết quả, chúng ta chỉ lấy kết quả ở sườn lên tiếp theo, xung nhịp tiếp theo, đúng không?
So whenever the data is actually updated, assuming the first half of the clock cycle, we can actually read the new value. So that actually enforces the read after write dependency.
Vậy bất cứ khi nào dữ liệu được cập nhật, giả sử là trong nửa đầu của chu kỳ xung nhịp, chúng ta có thể đọc được giá trị mới. Như vậy điều đó đảm bảo được phụ thuộc đọc sau ghi.
So write happens first, it basically separated in the sense that write happens first, and then read happens afterwards, right? Again, this is an assumption that we use for this particular datapath, right?
Vậy việc ghi xảy ra trước, về cơ bản được tách ra theo nghĩa là ghi xảy ra trước, rồi sau đó đọc mới xảy ra, đúng không? Một lần nữa, đây là một giả định mà chúng ta dùng cho datapath cụ thể này, đúng không?
We're assuming combinational, we're assuming asynchronous read is a combinational read, read happens immediately whenever data is available. Write actually happens synchronously at the rising edge of clock.
Chúng ta giả sử việc đọc là tổ hợp, chúng ta giả sử đọc bất đồng bộ là đọc tổ hợp, việc đọc xảy ra ngay lập tức khi dữ liệu sẵn sàng. Việc ghi thì xảy ra đồng bộ tại sườn lên của xung nhịp.
So write happens right after clock is triggered, so at the first half of the clock cycle, and then read happens combinationally, so we actually grab the data, and we will actually be able to read the new data.
Vậy việc ghi xảy ra ngay sau khi xung nhịp được kích hoạt, tức là ở nửa đầu của chu kỳ xung nhịp, và sau đó việc đọc xảy ra theo kiểu tổ hợp, nên chúng ta lấy dữ liệu, và chúng ta sẽ có thể đọc được dữ liệu mới.
So that's a way, again, in this particular datapath, how we actually handle this read after write dependencies, if they are actually accessing the register file in the same cycle.
Vậy đó là một cách, một lần nữa, trong datapath cụ thể này, để chúng ta xử lý các phụ thuộc đọc sau ghi này, nếu chúng cùng truy cập register file trong cùng một chu kỳ.
We look at this particular example a little bit more. So again, the same instructions, we assume after the data is actually written to the register file, we'll actually get the updated value.
Chúng ta xem ví dụ này kỹ hơn một chút. Vậy một lần nữa, với cùng các lệnh đó, chúng ta giả sử sau khi dữ liệu được ghi vào register file, chúng ta sẽ nhận được giá trị đã cập nhật.
So for the instructions later, we can actually get the updated value. For the earlier instructions, they actually cannot get the update.
Vậy với các lệnh đến sau, chúng ta có thể nhận được giá trị đã cập nhật. Còn với các lệnh trước đó, chúng không thể nhận được giá trị cập nhật.
We'll talk about how we can handle that later, but at least for the later instructions, they will actually get the updated value directly. Make sense? Questions?
Chúng ta sẽ nói về cách xử lý điều đó sau, nhưng ít nhất với các lệnh đến sau, chúng sẽ nhận trực tiếp giá trị đã cập nhật. Có hiểu không? Có câu hỏi nào không?
This kind of register, separating the register read and write into the early and the later part of the stage. So you're saying like we're going to... On the right. So, is this...
Kiểu thanh ghi này, tách việc đọc thanh ghi và ghi thanh ghi thành phần đầu và phần sau của giai đoạn. Vậy bạn đang nói là chúng ta sẽ... Ở bên phải. Vậy, cái này...
Like, oh, how do I know what if I wanted to read the previous...
Kiểu như, ồ, làm sao tôi biết nếu tôi muốn đọc giá trị trước đó...
So there are two questions here.
Vậy ở đây có hai câu hỏi.
So if you do want to read the old value, so that's instruction, you need to actually set up the sequence in the right program order.
Nếu bạn muốn đọc giá trị cũ, thì đó là lệnh, bạn cần sắp xếp chuỗi lệnh đúng theo thứ tự chương trình.
You need to have your instructions before this addition, let's say the store instruction as zero.
Bạn cần đặt các lệnh của mình trước phép cộng này, ví dụ lệnh store là lệnh số không.
So this is a program order we respect. Right. So this is a ground truth, we will assume the program is executed in order.
Vậy đây là thứ tự chương trình mà chúng ta tuân theo. Đúng không. Đây là chuẩn tham chiếu, chúng ta sẽ giả định chương trình được thực thi theo đúng thứ tự.
If you want to read the old value, you do that before this instruction. Right. So this is something we'll assume when programmers or compilers generate the sequence of instructions.
Nếu muốn đọc giá trị cũ, bạn phải làm việc đó trước lệnh này. Đúng không. Đây là điều chúng ta sẽ giả định khi lập trình viên hoặc trình biên dịch tạo ra chuỗi lệnh.
This is the order that we want to follow. From the hardware perspective, if you want to read the earlier value, put your instruction earlier.
Đây là thứ tự mà chúng ta muốn tuân theo. Từ góc nhìn phần cứng, nếu muốn đọc giá trị trước đó, hãy đặt lệnh của bạn sớm hơn.
If you want to read the later value, so that's what it has to be, the new value, to get a correct execution. Yeah. Makes sense.
Còn nếu muốn đọc giá trị sau, thì đó phải là giá trị mới, để thực thi đúng. Vâng. Hợp lý.
Okay, so that's basically the first half of the data hazard. Right.
Được rồi, vậy đó là nửa đầu của data hazard. Đúng không.
We talked about how those two instructions, by actually having synchronous write, asynchronous read, we can basically guarantee correct execution for those two instructions.
Chúng ta đã nói về việc hai lệnh đó, nhờ có ghi đồng bộ và đọc không đồng bộ, về cơ bản có thể đảm bảo thực thi đúng cho hai lệnh đó.
But the other two instructions, those two actually immediately follow after the first instruction, immediately follow the write instruction. They, there is still a read-after-write dependency.
Nhưng hai lệnh còn lại, hai lệnh đó nằm ngay sau lệnh đầu tiên, ngay sau lệnh ghi. Chúng vẫn có phụ thuộc đọc sau ghi.
And as the arrow showed here, for those two instructions, we're actually getting the wrong values, right? Because, again, we always follow the program order, the program execution.
Và như mũi tên ở đây cho thấy, với hai lệnh đó, chúng ta thực sự nhận được giá trị sai, đúng không? Vì, một lần nữa, chúng ta luôn tuân theo thứ tự chương trình, tức quá trình thực thi chương trình.
Those sub and or instructions are after the addition, which means that they are supposed to actually get the new value, the updated value, right?
Các lệnh sub và or nằm sau lệnh cộng, nghĩa là chúng phải nhận được giá trị mới, giá trị đã cập nhật, đúng không?
But if we just allow the pipeline to proceed this way, we're actually getting the old values. So that's basically the true data hazard. Right. So how do we actually resolve it?
Nhưng nếu cứ để đường ống chạy theo cách này, thì chúng ta lại nhận được giá trị cũ. Đó chính là data hazard thực sự. Đúng không. Vậy chúng ta giải quyết nó như thế nào?
How we can actually, again, before we do any performance optimization, we always need to make sure correct execution, correctness, is the most important metric when we actually come to hardware execution.
Làm sao, một lần nữa, trước khi tối ưu hiệu năng gì, chúng ta luôn phải bảo đảm thực thi đúng, tính đúng đắn là thước đo quan trọng nhất khi nói đến việc thực thi trên phần cứng.
Right. So to guarantee correct execution for those two scenarios where the read happens immediately after write, right, we cannot use a register file access policy to actually guarantee the right results.
Đúng không. Vậy để bảo đảm thực thi đúng cho hai trường hợp này, khi việc đọc xảy ra ngay sau việc ghi, đúng không, chúng ta không thể dùng chính sách truy cập register file để đảm bảo kết quả đúng.
In this case, we have to stall, stall. Right.
Trong trường hợp này, chúng ta phải stall, tức là làm trễ. Đúng không.
So, again, we see stall again, that's basically one of the most important ways that always works, in the sense that once we stall, we give our pipeline a little bit more time, we can actually guarantee correctness.
Như vậy, chúng ta lại thấy stall, về cơ bản đó là một trong những cách quan trọng nhất luôn hiệu quả, theo nghĩa là khi stall, chúng ta cho đường ống thêm một chút thời gian, thì có thể bảo đảm tính đúng đắn.
Right. So in this case, where we have an instruction, a read after write dependency for the instruction right after the read instructions, we basically add stalls or bubbles.
Đúng không. Vậy trong trường hợp này, khi có một lệnh phụ thuộc đọc sau ghi với lệnh nằm ngay sau các lệnh ghi, chúng ta thêm các stall hay bubble.
Instead of actually fetching new instructions, we just don't do anything, or basically, we'll talk later, it's basically a no-op, right, we do nothing.
Thay vì nạp lệnh mới, chúng ta không làm gì cả, hay nói cách khác, lát nữa chúng ta sẽ nói, về cơ bản đó là no-op, đúng không, chúng ta không làm gì.
So we just let the pipeline actually propagate later until we get to the write back, the register access, where we can actually, again, this is the same pattern that we have seen before, we can do the write immediately after the clock, and then the read is combinational, right, so we can actually grab the data eventually.
Vì vậy, chúng ta cứ để đường ống tiếp tục lan truyền cho đến khi tới giai đoạn ghi lại, tức là truy cập thanh ghi, nơi mà chúng ta có thể, một lần nữa, đây là cùng một mẫu mà chúng ta đã thấy trước đây, ghi ngay sau xung nhịp, và sau đó việc đọc là tổ hợp, đúng không, nên cuối cùng chúng ta có thể lấy được dữ liệu.
Right. So we need to basically add no-ops to actually stall the execution to actually guarantee correctness.
Đúng không. Vậy nên về cơ bản chúng ta cần thêm các no-op để làm trì hoãn quá trình thực thi nhằm đảm bảo tính đúng đắn.
So stall, whenever we stall, it actually hurts performance, right, because our pipeline is not fully utilized, but it's very important because we actually need to get correct results here.
Vậy stall, mỗi khi chúng ta stall thì hiệu năng bị ảnh hưởng, đúng không, vì đường ống không được tận dụng hết, nhưng điều này rất quan trọng vì chúng ta cần có kết quả đúng ở đây.
Sometimes you may be wondering, like, the compiler could also potentially rearrange code or add no-ops to actually get rid of these read after write dependencies, and that is true, like, the compiler can add some instructions, But again, this is actually not...
Có thể đôi khi các bạn sẽ thắc mắc, trình biên dịch cũng có thể sắp xếp lại mã hoặc thêm các no-op để loại bỏ những phụ thuộc đọc sau ghi này, và điều đó đúng, trình biên dịch có thể thêm một số lệnh, Nhưng một lần nữa, điều này thực ra không...
So we're not at the ISA level, right? This is actually a microarchitecture. So the microarchitecture is not available, generally not available, actually, to compilers, right?
Chúng ta không ở mức ISA, đúng không? Đây là vi kiến trúc. Vi kiến trúc thì không sẵn có, nói chung là không sẵn có đối với trình biên dịch, đúng không?
So it's not at the ISA level; this particular way of doing pipelining, the particular way of actually stalling, or this way of execution, is not exposed at the ISA level.
Vì vậy nó không ở mức ISA; cách thực hiện đường ống này, cách thực hiện stall này, hay cách thực thi này, không được phơi bày ở mức ISA.
We talked about ISA, right, all the different instructions that are actually being exposed to the programmer, right?
Chúng ta đã nói về ISA, đúng không, tất cả các lệnh khác nhau được phơi bày cho lập trình viên, đúng không?
So the microarchitecture is actually not visible to the compiler, so there's very limited things that the compiler can do. But hardware actually does have the full visibility, right?
Vậy vi kiến trúc không hiển thị đối với trình biên dịch, nên trình biên dịch làm được rất ít việc. Nhưng phần cứng thì có tầm nhìn đầy đủ, đúng không?
Hardware actually sees all the different instructions that are actually going on in this pipeline, which means that hardware can potentially actually catch scenarios where we can forward data from different stages of the pipeline to actually resolve this data hazard.
Phần cứng nhìn thấy tất cả các lệnh khác nhau đang diễn ra trong đường ống này, nghĩa là phần cứng có thể phát hiện các tình huống mà ta có thể chuyển tiếp dữ liệu từ các giai đoạn khác nhau của đường ống để giải quyết data hazard này.
So, some things that hardware can do, that's what we call data forwarding. So this is, again, a purely hardware solution.
Vậy, một việc phần cứng có thể làm là cái mà chúng ta gọi là data forwarding. Một lần nữa, đây là giải pháp thuần túy bằng phần cứng.
The goal is to actually handle data dependencies in our pipelined execution.
Mục tiêu là xử lý các phụ thuộc dữ liệu trong quá trình thực thi theo đường ống của chúng ta.
What we are trying to do here is that when we actually, again, this sequence, right, again we still have this read after write dependency.
Điều chúng ta đang cố làm ở đây là khi chúng ta, một lần nữa, chuỗi lệnh này, đúng không, chúng ta vẫn có phụ thuộc đọc sau ghi này.
What we recognize from the hardware perspective, where we have the full visibility of the execution, is that although from the ISA point of view the value is actually passed through a register, right, when it actually comes to the microarchitecture, when it comes to the design, there are all the different wires actually floating around.
Điều chúng ta nhận ra từ góc nhìn phần cứng, nơi chúng ta có tầm nhìn đầy đủ về quá trình thực thi, là mặc dù từ góc độ ISA giá trị được truyền qua một thanh ghi, nhưng khi nói đến vi kiến trúc, khi nói đến thiết kế, có rất nhiều dây dẫn khác nhau đang tồn tại.
And the computed result, or the data, is actually available, from the hardware perspective, after the execution, right? The result of the ALU is available after the execution unit.
Và kết quả đã tính toán, hay dữ liệu, thực ra đã có sẵn, từ góc nhìn phần cứng, sau giai đoạn thực thi, đúng không? Kết quả của ALU đã có sau khối thực thi.
So the idea is that instead of waiting for the data to be stored in the register, why can't we actually have actual paths?
Vậy ý tưởng là, thay vì chờ dữ liệu được lưu vào thanh ghi, tại sao chúng ta không làm các đường dẫn thực sự?
Because we have the full visibility of our datapaths, we have, I see, we're aware of all the different wires that are actually going on in our design, right?
Vì ta có toàn quyền quan sát các datapath của mình, ta có, tôi thấy, ta biết tất cả các dây khác nhau đang hoạt động trong thiết kế của mình, đúng không?
Can we actually add some actual logic, So that instead of waiting for data to be actually propagated to registers, which actually takes two more cycles, can we add this kind of custom connections, custom channel or wiring, so that data can be actually forwarded earlier?
Liệu ta có thể thêm một ít logic thực sự, để thay vì chờ dữ liệu được truyền đến các thanh ghi, vốn tốn thêm hai chu kỳ nữa, ta có thể thêm các kết nối tùy biến, kênh hay đường dây tùy biến này, để dữ liệu có thể được chuyển tiếp sớm hơn không?
Right. In a lot of scenarios, basically the result of the execution can be forwarded to the input of the unit, which is basically what the next instruction is trying to do.
Đúng vậy. Trong nhiều trường hợp, về cơ bản kết quả của khâu thực thi có thể được chuyển tiếp tới đầu vào của khối, đó chính là thứ mà lệnh kế tiếp đang cần.
So, instead of add, you have a load word, and you're loading something from memory into S0. You could forward the...
Vậy, thay vì add, bạn có một load word, và bạn đang nạp một giá trị từ bộ nhớ vào S0. Bạn có thể chuyển tiếp...
which you have to do a NOP, so that way the next instruction has shifted over by one, and the memory is like that. Right. Yeah, that's a good question.
mà bạn phải chèn một NOP, như vậy lệnh kế tiếp bị dịch đi một chu kỳ, và bộ nhớ thì như thế. Đúng. Vâng, đó là một câu hỏi hay.
I think it's an example that I like, that can actually demonstrate my idea of actually doing this forwarding. Right.
Tôi nghĩ đó là một ví dụ mà tôi thích, có thể minh họa ý tưởng chuyển tiếp này của tôi. Đúng.
But what if the value is actually not available after the execution stage, it's only available after the memory access stage? Right. With that, we cannot actually forward for this one.
Nhưng nếu giá trị thực ra chưa có sau giai đoạn thực thi, mà chỉ có sau giai đoạn truy cập bộ nhớ thì sao? Đúng. Khi đó ta không thể chuyển tiếp cho trường hợp này.
So this path actually doesn't exist. Right. So with that, forwarding actually doesn't solve all the problem itself. It's a subset of the problem where values can be forwarded, where data does exist.
Tức là đường này không tồn tại. Đúng. Vì vậy, chuyển tiếp tự nó không giải quyết được mọi vấn đề. Nó chỉ là một phần của vấn đề, nơi các giá trị có thể được chuyển tiếp, nơi dữ liệu có sẵn.
Again, it's very data path dependent. We're talking about our five stage pipeline. Right. So it doesn't solve all the problem itself, a subset of the problem where data can be forwarded.
Một lần nữa, nó phụ thuộc rất nhiều vào datapath. Chúng ta đang nói về đường ống năm giai đoạn. Đúng. Vì vậy nó tự nó không giải quyết được mọi vấn đề, mà chỉ một phần vấn đề nơi dữ liệu có thể được chuyển tiếp.
But when there are hard data dependencies that cannot be resolved by forwarding, in the case of data just purely not available when we actually need to grab the data, we still, yes, we still need to stall.
Nhưng khi có những phụ thuộc dữ liệu cứng không thể giải quyết bằng chuyển tiếp, trong trường hợp dữ liệu đơn giản là chưa có vào lúc ta thực sự cần lấy dữ liệu, thì vẫn vậy, ta vẫn cần phải stall.
So stall is always an option when we cannot do that. This is an example, this works, but there are also other scenarios where it won't work. Yeah. So it doesn't solve all the problem.
Vì vậy stall luôn là một lựa chọn khi ta không thể làm cách đó. Đây là một ví dụ, trường hợp này hiệu quả, nhưng cũng có những tình huống khác mà nó không hiệu quả. Vâng. Vậy nên nó không giải quyết được mọi vấn đề.
We're talking about step by step optimization here.
Ở đây ta đang nói về tối ưu hóa từng bước.
So, as for forwarding, I guess we already talked about this when I mentioned earlier, Those two can actually be handled by the register file access policy, right?
Còn về chuyển tiếp, tôi đoán ta đã nói về điều này khi tôi đề cập trước đó, Hai trường hợp đó có thể được xử lý bằng chính sách truy cập register file, đúng không?
So we basically always do the synchronous write, asynchronous read. Those two can be handled. Now, for those two, before, we said they are actually getting the wrong results.
Về cơ bản ta luôn ghi đồng bộ, đọc không đồng bộ. Hai trường hợp đó xử lý được. Còn với hai trường hợp này, trước đó ta đã nói chúng nhận được kết quả sai.
But here, what we can do is actually by forwarding, what we talked about earlier: the result is actually available at the end of the execution stage, right?
Nhưng ở đây, điều chúng ta có thể làm là dùng forwarding, như đã nói lúc trước: kết quả thực ra đã có sẵn ở cuối giai đoạn thực thi, đúng không?
We can actually forward the data to the input of the ALU, or for the data, we actually do the write, write back to the next instruction.
Chúng ta có thể chuyển tiếp dữ liệu đó tới đầu vào của ALU, hoặc với dữ liệu đó, ta thực hiện ghi, ghi ngược lại cho lệnh kế tiếp.
Right, so here, because we look at the execution, that data is indeed available, you just, now, hasn't got to the register file yet.
Đúng rồi, vì ở đây ta xét giai đoạn thực thi, dữ liệu đó thực sự đã có, chỉ là bây giờ nó chưa tới được register file.
Right, but we can actually grab data from the register wiring to actually get the data populated into our ALU, but it doesn't solve all the problem itself, this particular problem.
Nhưng ta có thể lấy dữ liệu từ đường dây của thanh ghi để đưa dữ liệu vào ALU của chúng ta, tuy nhiên bản thân cách này không giải quyết được mọi vấn đề, cụ thể là vấn đề này.
So we can grab forwarding early from the pipeline stages, instead of waiting until the end, register file write back. Right. Yeah. So, like, how many times can you... How many things...
Vậy ta có thể lấy forwarding sớm từ các giai đoạn của đường ống, thay vì đợi đến cuối, tức bước ghi ngược vào register file. Đúng. Vâng. Vậy, em muốn hỏi bao nhiêu lần có thể... Bao nhiêu thứ...
Oh, for this five, I say how big is our register file? Yes. Yes.
À, với số năm này, em hỏi register file của chúng ta lớn cỡ nào? Vâng. Vâng.
Good question. Yes. Well, so for this discussion, for most, are for this discussion this semester, it's always 32 register file. You're taking, you're interested in 132 next semester, or you have actually taken 132.
Câu hỏi hay. Vâng. Với phần thảo luận này, hầu hết các phần thảo luận trong học kỳ này, register file luôn có 32 thanh ghi. Nếu em quan tâm đến môn 132 vào học kỳ sau, hoặc em đã học 132 rồi.
Register, there is also differences in terms of architectural register, whatever is actually visible, from ISA it's always 32, and a physical register, right?
Còn có sự khác biệt giữa thanh ghi kiến trúc, tức là phần nhìn thấy được từ ISA, luôn là 32, và thanh ghi vật lý, đúng không?
There are, there are optimizations where we can have actually more bigger physical register that serve as buffers. We'll look at into that in this semester, but yeah, it's always 32.
Có những kỹ thuật tối ưu hóa cho phép có nhiều thanh ghi vật lý hơn, dùng làm bộ đệm. Chúng ta sẽ không đi sâu vào phần đó trong học kỳ này, nhưng vâng, luôn là 32.
So who determines which register that we're writing to, is that hardware or the program? Yes.
Vậy ai quyết định thanh ghi nào được ghi vào, là phần cứng hay chương trình? Vâng.
Yeah, so this is when it comes to the hardware, everything like that has been handled. Yeah. Good question. Okay, so that's forwarding, right?
Vâng, khi nói đến phần cứng thì mọi thứ như vậy đều đã được xử lý rồi. Vâng. Câu hỏi hay. Được rồi, đó là forwarding, đúng không?
So when it comes to actual implementation, right, we need to detect opportunities that can actually be forwarded, right? So we actually do a detection.
Vậy khi đi vào cài đặt thực tế, chúng ta cần phát hiện những trường hợp có thể chuyển tiếp dữ liệu, đúng không? Vậy ta thực hiện một bước phát hiện.
We basically compare the destinations of older instructions, for physical, we're forwarding the destination of earlier instructions to the sources of the newer instruction, right?
Về cơ bản, ta so sánh đích của các lệnh cũ hơn, về mặt vật lý, ta chuyển tiếp đích của các lệnh trước đó tới các nguồn của lệnh mới hơn, đúng không?
So we basically check whether they have these corresponding dependencies, where they are basically writing and reading from, writing to and reading from the same register. If we do, we actually forward the data directly.
Tức là ta kiểm tra xem chúng có các phụ thuộc tương ứng hay không, tức là chúng đang ghi vào và đọc từ cùng một thanh ghi. Nếu có, ta chuyển tiếp dữ liệu trực tiếp.
So we do a lot of comparison, making sure we're writing and reading from the same instruction, same register file.
Vậy ta thực hiện rất nhiều phép so sánh, để đảm bảo rằng ta ghi và đọc cùng một thanh ghi trong cùng register file.
So with that, we actually take a look at our datapath, right? So we can actually add forwarding logic.
Với điều đó, chúng ta hãy xem lại datapath nhé. Chúng ta có thể thêm logic forwarding.
We mentioned earlier, we need to actually detect the instruction going on, involves decoding and execution stage, to see whether we are actually needing the data, actually from earlier, from the early instruction.
Như đã nói lúc trước, ta cần phát hiện lệnh đang diễn ra, liên quan đến các giai đoạn giải mã và thực thi, để xem ta có thực sự cần dữ liệu từ lệnh trước đó hay không.
And then, whenever we do that, remember the muxes, right? We use muxes a lot, right? Whenever there are multiple different scenarios we introduce muxes so that we can handle those scenarios.
Và rồi, mỗi khi làm vậy, hãy nhớ các mux nhé. Chúng ta dùng mux rất nhiều, đúng không? Bất cứ khi nào có nhiều tình huống khác nhau, chúng ta đưa vào các mux để có thể xử lý những tình huống đó.
So in this particular case, well, this is a source of ALU. We already talked about earlier, it either comes from the register file or from the program counter, right?
Vậy trong trường hợp cụ thể này, đây là một nguồn của ALU. Chúng ta đã nói trước đó, nó đến từ register file hoặc từ program counter, đúng không?
That's purely based on the ISA requirement. You will think about forwarding, right?
Điều đó hoàn toàn dựa trên yêu cầu của ISA. Các em sẽ nghĩ đến forwarding, đúng không?
The data can actually come back from the computed, at the end of the computed result from the previous instruction, or the instructions.
Dữ liệu thực ra có thể quay trở lại từ kết quả đã tính xong ở cuối của lệnh trước, hoặc các lệnh trước.
The value is actually at the write-back stage before it actually writes to the register, right? So we talked about the two forwardings here.
Giá trị đó thực ra đang ở giai đoạn write-back trước khi nó thực sự được ghi vào thanh ghi, đúng không? Vậy chúng ta đã nói về hai forwarding ở đây.
We can either forward from the ALU, the computing results, to the source of the ALU. We can also forward right before we actually write to the register, instead of waiting, right?
Chúng ta có thể forward từ ALU, tức kết quả tính toán, đến nguồn của ALU. Chúng ta cũng có thể forward ngay trước khi thực sự ghi vào thanh ghi, thay vì phải chờ, đúng không?
So to support those two forwardings, you think about our datapath, we basically add it. Those two other options in this mux, so we can support all the different scenarios.
Vậy để hỗ trợ hai forwarding này, hãy nghĩ đến datapath của chúng ta, về cơ bản là ta thêm vào hai lựa chọn khác trong mux này, để có thể hỗ trợ tất cả các tình huống khác nhau.
Make sense? Questions? Okay. Okay, good. So we talked about two hazards: structure hazards and control and the data hazard, right?
Hiểu chưa? Có câu hỏi nào không? Được rồi. Tốt. Vậy chúng ta đã nói về hai loại hazard: structural hazard, control hazard và data hazard, đúng không?
Structure hazard, they are competing for shared resources. Data hazard, they're, they're true data dependencies. Always remember, stall, where there's like no more optimization we can do, we basically stall.
Structural hazard là khi các lệnh tranh nhau tài nguyên dùng chung. Data hazard là khi có sự phụ thuộc dữ liệu thực sự. Luôn nhớ là stall, khi không còn tối ưu nào khác có thể làm, về cơ bản chúng ta stall.
Correctness is always very important.
Tính đúng đắn luôn rất quan trọng.
We can try to address some of the scenarios if it's actually physically possible, meaning the data is actually ready, that can be grabbed in the execution, or we can afford the extra logic that we are putting into the hardware to support the execution.
Chúng ta có thể cố xử lý một số tình huống nếu về mặt vật lý điều đó khả thi, nghĩa là dữ liệu đã sẵn sàng, để có thể lấy được ở giai đoạn thực thi, hoặc chúng ta chấp nhận được phần logic bổ sung mà ta đưa vào phần cứng để hỗ trợ việc thực thi.
We cannot do that either from the cost perspective, or just purely the data, a true data dependency perspective. We always respect the program order. We cannot reorder the program order.
Chúng ta không thể làm vậy, hoặc vì chi phí, hoặc thuần túy vì dữ liệu, tức vì sự phụ thuộc dữ liệu thực sự. Chúng ta luôn tôn trọng thứ tự của chương trình. Chúng ta không thể sắp xếp lại thứ tự chương trình.
It's already almost all our, I don't want to rush the control hazard, which is also very important. So we'll just stop now and we'll pick up control hazard in the next lecture.
Gần hết giờ rồi, tôi không muốn vội vàng với control hazard, vì nó cũng rất quan trọng. Vậy chúng ta dừng ở đây và sẽ tiếp tục với control hazard ở bài giảng sau.
Good to see you. I'll see you this Thursday.
Rất vui được gặp các em. Hẹn gặp lại vào thứ Năm này.
Đăng nhập để đánh giá học liệu này.
Đăng nhập để bình luận — chưa ai bình luận về học liệu này.
Không có khóa học liên quan.