Video
Đăng bởi Ban biên tập OpenER ·
Tác giả giữ toàn bộ bản quyền (All Rights Reserved) — không phải giấy phép mở. Bạn vẫn xem và học miễn phí trên OpenER; muốn tái sử dụng cần xin phép tác giả.
Okay, well, good morning, everyone. Welcome to EECS 151/251A, Introduction to Digital Design and Integrated Circuits. We are going to have our 11th lecture of the semester, almost halfway there.
Được rồi, chào buổi sáng 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 sắp có bài giảng thứ 11 của học kỳ, gần như đã đi được nửa chặng đường.
We have covered a lot of material, starting from the basic semiconductor industry, different trade-offs, design abstractions.
Chúng ta đã học rất nhiều nội dung, bắt đầu từ ngành công nghiệp bán dẫn cơ bản, các đánh đổi khác nhau, và các mức trừu tượng trong thiết kế.
We spent a lot of time on Verilog, but we will spend even more time on Verilog throughout this semester. It's a really fun language. And then we start our RISC-V module.
Chúng ta đã dành nhiều thời gian cho Verilog, nhưng chúng ta sẽ còn dành nhiều thời gian hơn nữa cho Verilog trong suốt học kỳ này. Đó là một ngôn ngữ thực sự thú vị. Sau đó chúng ta bắt đầu học phần RISC-V.
We're going to wrap up our RISC-V module today. We got to most of the hazards, but we haven't got a chance to talk about control hazards.
Hôm nay chúng ta sẽ kết thúc phần RISC-V. Chúng ta đã nói đến hầu hết các hazard, nhưng chưa có dịp nói về control hazard.
We'll talk about control hazards today, and we're going to start our CMOS and FPGA module. We'll start with a very brief discussion on FPGA.
Hôm nay chúng ta sẽ nói về control hazard, và chúng ta sẽ bắt đầu phần CMOS và FPGA. Chúng ta sẽ bắt đầu bằng một thảo luận rất ngắn về FPGA.
Many of the folks in the FPGA lab actually have seen different components of the contents, but we're actually going to present them in a more organized fashion.
Nhiều bạn trong phòng thí nghiệm FPGA thực ra đã thấy các thành phần khác nhau của nội dung này, nhưng chúng ta sẽ trình bày chúng một cách có tổ chức hơn.
And for folks in the ASIC lab, maybe you haven't seen this before, it's also good to see what are the strengths, why people are interested in considering FPGA.
Còn với các bạn trong phòng thí nghiệm ASIC, có thể bạn chưa thấy điều này bao giờ, thì cũng nên xem những điểm mạnh là gì, và vì sao người ta quan tâm đến việc cân nhắc dùng FPGA.
I mentioned earlier, we'll have another guest lecture next Tuesday. I'm very excited about the guest lecture. We'll hear more about how FPGA is being used in the industry.
Tôi đã nhắc trước đó, chúng ta sẽ có một bài giảng khách mời nữa vào thứ Ba tuần sau. Tôi rất háo hức với bài giảng khách mời này. Chúng ta sẽ nghe thêm về cách FPGA đang được sử dụng trong ngành công nghiệp.
After that, next Thursday, we'll start our CMOS module.
Sau đó, vào thứ Năm tuần sau, chúng ta sẽ bắt đầu phần CMOS.
So before we get there, every time I teach this class, it's always fun to present different news, related stories about FPGA.
Trước khi đến đó, mỗi lần tôi dạy lớp này, tôi luôn thấy vui khi giới thiệu các tin tức khác nhau, những câu chuyện liên quan đến FPGA.
So over the years, I've been gradually updating my slide deck. I started with Intel's acquisition of Altera. Altera is one of the major, well, there were really only two FPGA vendors.
Qua nhiều năm, tôi đã dần cập nhật bộ slide của mình. Tôi bắt đầu với việc Intel mua lại Altera. Altera là một trong những hãng lớn, à, thực ra chỉ có hai nhà cung cấp FPGA.
So Altera is one of the major ones. Intel acquired Altera in 2015. It was huge news. I remember that before I actually graduated, so I graduated from my PhD.
Altera là một trong hai hãng lớn đó. Intel mua lại Altera vào năm 2015. Đó là một tin cực lớn. Tôi nhớ là trước khi tôi tốt nghiệp, tức là tốt nghiệp tiến sĩ.
So we were, I guess, half surprised that Intel made the move, but also kind of expected because those two companies have been actually working together for a while.
Chúng tôi vừa khá bất ngờ trước động thái của Intel, nhưng cũng phần nào đoán trước được vì hai công ty đó đã hợp tác với nhau từ khá lâu.
And then in the last couple of years, people basically just have been actually, there are a lot of rumors about when AMD will actually acquire Xilinx.
Rồi trong vài năm gần đây, mọi người về cơ bản chỉ, có rất nhiều tin đồn về việc khi nào AMD sẽ mua lại Xilinx.
So this spring, this past spring, the acquisition happened.
Và vào mùa xuân này, mùa xuân vừa rồi, thương vụ đã diễn ra.
So AMD, the other major x86 CPU vendor, acquired the other major FPGA vendor, Xilinx. It's pretty interesting.
Vậy là AMD, nhà cung cấp CPU x86 lớn còn lại, đã mua lại nhà cung cấp FPGA lớn còn lại, Xilinx. Điều này khá thú vị.
We have two x86 CPU vendors, Intel and AMD, and two major FPGA vendors, Altera and Xilinx. The board that we're using in our lab is basically from Xilinx.
Chúng ta có hai nhà cung cấp CPU x86 là Intel và AMD, và hai nhà cung cấp FPGA lớn là Altera và Xilinx. Bo mạch mà chúng ta dùng trong phòng thí nghiệm về cơ bản là của Xilinx.
Over the past, I guess, decade, so we started with Intel's acquisition seven, eight years ago in 2015, and Altera, AMD's acquisition, it finished this year.
Trong khoảng một thập kỷ qua, chúng ta bắt đầu với việc Intel mua lại Altera cách đây bảy, tám năm vào năm 2015, và thương vụ AMD mua lại Xilinx thì hoàn tất trong năm nay.
But the discussion has already started at least two years ago, during or right before the pandemic. So there were already a lot of discussion about the AMD Xilinx acquisition.
Nhưng các cuộc thảo luận đã bắt đầu ít nhất hai năm trước, trong hoặc ngay trước thời điểm đại dịch. Vì vậy đã có rất nhiều bàn luận về thương vụ AMD mua Xilinx.
It's very interesting to see this kind of consolidation of IPs. We talk about NVIDIA was interested in acquiring ARM. That's also another form of consolidation of IPs.
Thật thú vị khi thấy sự hợp nhất các IP như thế này. Chúng ta đã nói về việc NVIDIA từng muốn mua ARM. Đó cũng là một dạng hợp nhất IP khác.
Then we also see CPU vendors are actually very interested in the FPGA fabric and also interested in adding that fabric into their portfolio.
Rồi chúng ta cũng thấy các hãng CPU rất quan tâm đến FPGA fabric và cũng muốn đưa fabric đó vào danh mục sản phẩm của họ.
So we see seven, eight years ago, Intel acquired Altera, roughly a value of $16 billion, $16 billion, seven, eight years ago.
Cách đây bảy, tám năm, Intel đã mua Altera, với giá trị khoảng 16 tỉ đô la, 16 tỉ đô la, bảy, tám năm trước.
Any guesses how much money AMD spent to acquire Xilinx? Omar? It was about, yeah, that's, well, you remember that well, it's roughly $49 billion in the end.
Các bạn đoán AMD đã chi bao nhiêu tiền để mua Xilinx? Omar? Khoảng, đúng rồi, thì, bạn nhớ rõ đấy, cuối cùng là khoảng 49 tỉ đô la.
So $16 billion, eight years ago, and then we get to $49 billion with the AMD Xilinx acquisition. Pretty, pretty expensive.
Vậy là 16 tỉ đô la, tám năm trước, và rồi lên đến 49 tỉ đô la với thương vụ AMD mua Xilinx. Khá là đắt.
I think that's basically one of the biggest semiconductor acquisitions in the past few years. There are a couple of reasons, like the AMD acquisition is a lot more expensive.
Tôi nghĩ đó về cơ bản là một trong những thương vụ mua bán bán dẫn lớn nhất trong vài năm qua. Có một vài lý do, ví dụ thương vụ của AMD đắt hơn nhiều.
Xilinx is a bigger FPGA vendor compared to Altera.
Xilinx là hãng FPGA lớn hơn so với Altera.
So that's definitely, Xilinx has a lot more designs, a lot bigger market, a lot of different components available, but also there's also a big gap, right?
Chắc chắn là Xilinx có nhiều thiết kế hơn hẳn, thị trường lớn hơn nhiều, nhiều loại linh kiện khác nhau, nhưng cũng có một khoảng cách lớn, đúng không?
This eight years, for folks who are actually following the stock market, right?
Tám năm này, với những bạn có theo dõi thị trường chứng khoán, đúng không?
Especially, I guess, tech industry in general, but also including the semiconductor industry the past couple of years, the stock market is basically pretty crazy. That also contributed to the valuation.
Đặc biệt là ngành công nghệ nói chung, và cả ngành bán dẫn trong vài năm qua, thị trường chứng khoán khá là điên rồ. Điều đó cũng góp phần vào định giá.
So a lot of interesting things going on. We see this consolidation happening in the semiconductor industry.
Vậy là có rất nhiều điều thú vị đang diễn ra. Chúng ta thấy sự hợp nhất này đang diễn ra trong ngành bán dẫn.
It's going to be very interesting to see how they, or what style of system they will be assembling, right?
Sẽ rất thú vị khi xem họ sẽ, hay loại hệ thống nào họ sẽ lắp ghép, đúng không?
So now when we say actually a CPU vendor, they're not really just a CPU vendor. They have a lot of different IP. We'll talk a little bit more.
Giờ đây khi nói một hãng CPU, họ không còn chỉ là hãng CPU nữa. Họ có rất nhiều IP khác nhau. Chúng ta sẽ nói thêm một chút.
Intel, especially in the past couple of years, have been making a lot of acquisitions. So the Altera one is really the beginning. They also acquire several different AI hardware startups, right?
Intel, đặc biệt trong vài năm qua, đã thực hiện rất nhiều thương vụ mua lại. Thương vụ Altera thực sự chỉ là khởi đầu. Họ cũng mua lại nhiều startup phần cứng AI khác nhau, đúng không?
So we see this kind of consolidation of IPs happening in the semiconductor industry that also have very interesting implications in the type of hardware that will be building, the system that we'll be seeing, and also the competition that we'll be observing in this industry.
Như vậy chúng ta thấy sự hợp nhất các IP này đang diễn ra trong ngành bán dẫn, và nó cũng có những hệ quả rất thú vị đối với loại phần cứng sẽ được xây dựng, hệ thống mà chúng ta sẽ thấy, và cả sự cạnh tranh mà chúng ta sẽ chứng kiến trong ngành này.
So something interesting to keep an eye on with all the different acquisitions. With that, let's transition to the topic of today. So we'll wrap up our discussion on pipelining.
Vì vậy đây là điều thú vị cần theo dõi cùng với tất cả các thương vụ mua lại. Với điều đó, chúng ta chuyển sang chủ đề hôm nay. Chúng ta sẽ kết thúc phần thảo luận về pipelining.
We'll talk about how we decompose a single cycle pipeline, for the baseline pipeline design that we have been discussing, into the five stage pipeline.
Chúng ta sẽ nói về cách phân rã một đường ống một chu kỳ, cho thiết kế đường ống cơ sở mà chúng ta đã thảo luận, thành đường ống năm tầng.
We'll talk about, in order to actually, the idea of the pipeline is to achieve high utilization, but at the same time, there are some fundamental constraints that stop us from doing that.
Chúng ta sẽ nói về việc, để có thể, ý tưởng của đường ống là đạt được mức sử dụng cao, nhưng đồng thời, có một số ràng buộc cơ bản ngăn chúng ta làm được điều đó.
That's basically what we mean by pipeline hazard, right?
Về cơ bản đó chính là điều chúng ta gọi là hazard của đường ống, đúng không?
That includes structural hazard that actually be introduced because of the limited resources that we have in our system, but also data hazards where we have true data dependencies that we need to actually wait until data is resolved, data is produced, before we can move forward.
Điều đó bao gồm structural hazard, được đưa vào do tài nguyên trong hệ thống của chúng ta có hạn, nhưng cũng có data hazard, khi chúng ta có các phụ thuộc dữ liệu thực sự mà chúng ta phải chờ cho đến khi dữ liệu được xác định, dữ liệu được tạo ra, rồi mới có thể tiếp tục.
Today we're going to talk about control hazard. That's related to the control flow, which stops the program from executing until we know where we want to go.
Hôm nay chúng ta sẽ nói về control hazard. Nó liên quan đến luồng điều khiển, làm chương trình không thể thực thi tiếp cho đến khi chúng ta biết cần đi đâu.
So we look at the data paths that we have so far, right? We start with the data paths, then we added all the pipeline registers, all the green boxes here, pipeline registers.
Vậy ta xem các data path mà chúng ta có cho đến giờ, đúng không? Chúng ta bắt đầu với các data path, sau đó thêm tất cả các thanh ghi đường ống, tất cả các ô màu xanh lá ở đây, là các thanh ghi đường ống.
We talk about data hazards, which means that we need forwarding logic so that we can actually forward the values from different wires of the execution stage to the next instruction so that we can actually continue this execution before the value is actually finally written either to memory or to register.
Chúng ta đã nói về data hazard, nghĩa là chúng ta cần logic chuyển tiếp (forwarding) để có thể chuyển tiếp các giá trị từ các dây khác nhau của tầng thực thi sang lệnh kế tiếp để chúng ta có thể tiếp tục việc thực thi này trước khi giá trị cuối cùng được ghi vào bộ nhớ hoặc vào thanh ghi.
At the same time, since we're talking about control flow, right, it's important to observe when we actually can determine where we want to go, or when we actually know the target PC, right?
Đồng thời, vì chúng ta đang nói về luồng điều khiển, nên điều quan trọng là quan sát xem khi nào chúng ta có thể xác định được mình muốn đi đâu, hay khi nào chúng ta biết được PC đích, đúng không?
So what are the different sources of the target PC? We talk about, we look at the mux flow whenever we have different options, right?
Vậy các nguồn khác nhau của PC đích là gì? Chúng ta xem luồng mux mỗi khi có các lựa chọn khác nhau, đúng không?
We add a mux. We'll see a lot more muxes actually in FPGA design. So we look at different muxes, right? So the first one is easy, PC plus four, right?
Chúng ta thêm một mux. Thực ra chúng ta sẽ gặp nhiều mux hơn nữa trong thiết kế FPGA. Vậy ta xem các mux khác nhau, đúng không? Cái đầu tiên thì dễ, PC cộng bốn, đúng không?
We are not changing the control flow. We just increment to the next instruction, right? That can be resolved actually right after we load the new PC, right?
Chúng ta không thay đổi luồng điều khiển. Chúng ta chỉ tăng lên để sang lệnh kế tiếp, đúng không? Cái đó có thể được xác định ngay sau khi chúng ta nạp PC mới, đúng không?
So we can actually get the PC plus four, the new PC. Another source is from the ALU, right?
Vậy chúng ta có thể lấy được PC cộng bốn, tức PC mới. Một nguồn khác là từ ALU, đúng không?
So those are basically branch instructions that actually change the execution path of our design that we actually need to figure out where we want to go, right?
Về cơ bản đó là các lệnh rẽ nhánh làm thay đổi đường thực thi của thiết kế chúng ta, nên chúng ta cần tìm ra mình muốn đi đâu, đúng không?
So this is actually from the result of the ALU, right? We trace this wire all the way here.
Vậy cái này đến từ kết quả của ALU, đúng không? Chúng ta lần theo sợi dây này đến tận đây.
We actually won't get the value of the new PC until we get to, what's this stage? The mem stage, right?
Chúng ta sẽ không có giá trị PC mới cho đến khi tới, đây là tầng nào nhỉ? Tầng mem, đúng không?
Where we have the ALU produced and then clock triggered, then we get, we can read this value from this pipeline register, right?
Nơi ALU tạo ra kết quả và sau đó xung nhịp kích hoạt, rồi chúng ta có thể đọc giá trị này từ thanh ghi đường ống này, đúng không?
So this is the alternative path that will actually get the updated PC. The challenge with control hazard is that in a lot of scenarios, we cannot get this.
Vậy đây là đường thay thế sẽ cho chúng ta PC đã được cập nhật. Thách thức của control hazard là trong nhiều tình huống, chúng ta không thể có được giá trị này.
The PC plus four is an easy one. We're not worried about that.
PC cộng bốn là trường hợp dễ. Chúng ta không lo về nó.
But this is more concerning ones, that it takes time, takes cycles to resolve this calculated PC that stops us from fully utilizing the pipeline.
Nhưng đây là những trường hợp đáng lo hơn, vì cần thời gian, cần nhiều chu kỳ để xác định PC được tính toán này, và điều đó ngăn chúng ta sử dụng đầy đủ đường ống.
What do I mean by that? Let's take an example, take a look at an example. So here is an instruction sequence. We start with the first instruction, which is a branch instruction, right?
Tôi muốn nói gì? Hãy lấy một ví dụ, cùng xem một ví dụ. Đây là một chuỗi lệnh. Ta bắt đầu với lệnh đầu tiên, là một lệnh rẽ nhánh, đúng không?
Conditional branch, right? We do the comparison to see whether the two registers are equal, and that decides whether we actually want to continue the execution or jump to the label, right?
Rẽ nhánh có điều kiện, đúng không? Ta thực hiện phép so sánh xem hai thanh ghi có bằng nhau không, và điều đó quyết định liệu ta thực sự muốn tiếp tục thực thi hay nhảy đến nhãn, đúng không?
So the first cycle, we read the instruction from the IMEM, right?
Vậy ở chu kỳ đầu tiên, ta đọc lệnh từ IMEM, đúng không?
And then, well, at the first cycle, we don't know actually whether the branch is taken or not, because the branch, we can only know whether the branch is taken and the target PC is only resolved at the memory stage, right?
Và rồi, ở chu kỳ đầu tiên, thực ra ta chưa biết nhánh có được thực hiện hay không, vì ta chỉ có thể biết nhánh có được thực hiện hay không và PC đích chỉ được xác định ở giai đoạn bộ nhớ, đúng không?
So let's assume we just keep executing, right? We don't care about the resolution of the branch. We don't care about the target. We want to keep our execution in full throughput, right?
Vậy ta giả sử cứ tiếp tục thực thi, đúng không? Ta không quan tâm đến kết quả của nhánh. Ta không quan tâm đến đích. Ta muốn giữ việc thực thi ở thông lượng tối đa, đúng không?
Let's just keep executing while we are actually getting more visibility of the branch, right? We keep executing. We get to the next instruction.
Cứ tiếp tục thực thi trong khi ta dần có thêm thông tin về nhánh, đúng không? Ta tiếp tục thực thi. Ta đến lệnh tiếp theo.
Again, we haven't got to the memory stage, so we are not actually resolved. And then we get to the third instruction.
Một lần nữa, ta chưa đến giai đoạn bộ nhớ, nên vẫn chưa xác định được. Rồi ta đến lệnh thứ ba.
Here, when we fetch, well, so we mentioned like the branch target is only calculated in the memory stage, right? In our datapath that we have seen so far. Let's go to this.
Ở đây, khi ta nạp lệnh, như đã nói, đích của nhánh chỉ được tính ở giai đoạn bộ nhớ, đúng không? Trong đường dữ liệu mà ta đã thấy cho đến giờ. Ta xem cái này.
In this datapath, right? It's only resolved in the memory stage, and then we need basically another clock tick to actually load the PC out to actually reach the value, right?
Trong đường dữ liệu này, đúng không? Nó chỉ được xác định ở giai đoạn bộ nhớ, và sau đó về cơ bản ta cần thêm một xung nhịp nữa để nạp PC ra, để thực sự có được giá trị, đúng không?
So in this case, in this example, Although it's actually resolved, we need to actually wait until the next cycle where we can actually trigger the clock, load the PC, and then figure out, oh, this is the label.
Vậy trong trường hợp này, trong ví dụ này, tuy nó đã được xác định, ta vẫn phải đợi đến chu kỳ tiếp theo mới có thể kích xung nhịp, nạp PC, và rồi mới biết, à, đây là nhãn.
This is where we want to go. This is the target that I actually want to start execution. What does this mean? It means that all the instructions are now supposed to be executed.
Đây là nơi ta muốn đi đến. Đây là đích mà ta thực sự muốn bắt đầu thực thi. Điều này nghĩa là gì? Nghĩa là tất cả các lệnh lúc này lẽ ra phải được thực thi.
The branch is taken.
Nhánh được thực hiện.
We need to actually jump to the label immediately after that instruction, while all the other instructions in between, we're assuming the branch was not taken, were not, were illegal and not supposed to happen.
Ta cần nhảy ngay đến nhãn sau lệnh đó, trong khi tất cả các lệnh khác ở giữa, mà ta đã giả sử là nhánh không được thực hiện, là không hợp lệ và lẽ ra không được xảy ra.
So this is basically what we mean by control hazard.
Về cơ bản, đây là điều ta gọi là control hazard.
We cannot know the branch target until we can calculate the PC, but that which takes cycles, and then either we can always stall, which means like low utilization, or this leads to actually undesired outputs because we are actually executing the instructions that are not supposed to be executed.
Ta không thể biết đích của nhánh cho đến khi tính được PC, nhưng việc đó tốn chu kỳ, và khi đó hoặc ta luôn có thể tạm dừng, nghĩa là mức sử dụng thấp, hoặc điều này dẫn đến kết quả không mong muốn vì ta đang thực thi những lệnh lẽ ra không được thực thi.
So, the question?
Vậy, bạn có câu hỏi?
Yeah, that's a good question. So we talk about control hazard, right? So then how do we actually work around it?
Vâng, đó là một câu hỏi hay. Vậy ta đã nói về control hazard, đúng không? Vậy thì làm thế nào để thực sự khắc phục nó?
We'll get to that in a minute, what are the ways to actually work around it. So just a little bit more about the control hazard observation.
Chúng ta sẽ nói tới điều đó ngay, tức là các cách để thực sự giải quyết vấn đề này. Trước hết nói thêm một chút về nhận xét liên quan đến control hazard.
So if the branch is not taken, then we basically, our earlier execution is correct, right? We just keep executing because those instructions will be actually executed eventually.
Nếu lệnh rẽ nhánh không được thực hiện (not taken), thì phần thực thi trước đó của chúng ta là đúng, phải không? Ta cứ tiếp tục thực thi vì những lệnh đó cuối cùng cũng sẽ được thực thi.
But if the branch is actually taken, we actually need to flush the instructions because they are not supposed to be executed, right?
Nhưng nếu lệnh rẽ nhánh thực sự được thực hiện (taken), thì ta cần phải flush các lệnh đó vì chúng không được phép thực thi, đúng không?
We need to actually convert them to no ops, so then they are not modifying our pipeline stages, and then we do the correct execution.
Ta cần chuyển chúng thành no-op, để chúng không làm thay đổi các tầng của đường ống của chúng ta, rồi sau đó ta thực thi đúng.
So what do we mean by that? We go back to our instruction sequence, right? So this is the instruction sequence that we know we have seen before, right?
Vậy ý đó là gì? Ta quay lại chuỗi lệnh của mình nhé. Đây là chuỗi lệnh mà chúng ta đã thấy trước đó, đúng không?
So eventually we know actually the branch is taken, and this is a label we're supposed to execute.
Cuối cùng ta biết rằng lệnh rẽ nhánh được thực hiện, và đây là nhãn mà ta cần thực thi.
All of the instructions in the middle are converted to no-ops, which means that they are not modifying any of the pipeline stages, right?
Tất cả các lệnh ở giữa đều bị chuyển thành no-op, nghĩa là chúng không làm thay đổi bất kỳ tầng nào của đường ống, đúng không?
The pipelines, any of the architectural stages, they are not modifying the registers, they are not modifying the memory, so they are not changing our architectural state, but eventually PC will actually get to the right location to actually execute it.
Của đường ống, hay bất kỳ trạng thái kiến trúc nào, chúng không sửa các thanh ghi, không sửa bộ nhớ, nên chúng không thay đổi trạng thái kiến trúc của ta, nhưng cuối cùng PC sẽ tới đúng vị trí để thực thi.
So this is basically making a bet in some sense, right? We're betting that's very likely, so if actually the branch is not taken in the end, right?
Như vậy về bản chất là ta đang đặt cược, đúng không? Ta cược rằng rất có khả năng là rốt cuộc lệnh rẽ nhánh không được thực hiện, đúng không?
So we actually get to execute a couple more instructions instead of actually keeping our instruction, keeping our pipeline idling, right?
Khi đó ta được thực thi thêm vài lệnh thay vì để cho chuỗi lệnh, để cho đường ống của ta ở trạng thái nhàn rỗi, đúng không?
But that has a penalty if the branch is actually taken in the end, we actually need to convert those into no-ops. So to reduce the branch penalty, basically the control hazard, right?
Nhưng sẽ phải chịu một mức phạt nếu cuối cùng lệnh rẽ nhánh được thực hiện, vì ta cần chuyển những lệnh đó thành no-op. Vậy để giảm branch penalty, tức là control hazard, đúng không?
So again, when we talk about control hazard, actually all the different hazards that you'll be actually observing during class, you know, homework, even your future interview, it's very architecture specific, always look at your microarchitectural diagram, right?
Một lần nữa, khi nói về control hazard, thực ra là tất cả các loại hazard mà các bạn sẽ gặp trong lớp, trong bài tập về nhà, thậm chí trong các buổi phỏng vấn sau này, chúng phụ thuộc rất nhiều vào kiến trúc, nên luôn nhìn vào sơ đồ vi kiến trúc của bạn, nhé.
So this, we're talking about this particular control hazard that will cause three dead cycles for our datapaths, for the datapath that I showed earlier, right?
Vậy nên, ở đây ta đang nói về control hazard cụ thể này, nó sẽ gây ra ba chu kỳ chết cho datapath của chúng ta, tức datapath mà tôi đã trình bày trước đó.
So different datapaths will have different consequences, different datapaths behave differently, right? So always take a look at the specific microarchitecture that you're looking at or you're designing.
Các datapath khác nhau sẽ có hệ quả khác nhau, các datapath khác nhau hoạt động khác nhau, đúng không? Vì vậy hãy luôn xem xét vi kiến trúc cụ thể mà bạn đang xem hoặc đang thiết kế.
So again, the penalty for our datapath is three dead cycles if we actually mispredict, right? So John, you already mentioned earlier, right?
Một lần nữa, mức phạt cho datapath của chúng ta là ba chu kỳ chết nếu dự đoán sai, đúng không? John, bạn đã nhắc tới điều này trước đó rồi, đúng không?
This seems to be basically we want to bet to see whether the branch is taken or not, right? Well, even if it's random, right?
Về cơ bản là ta muốn đặt cược xem lệnh rẽ nhánh có được thực hiện hay không, đúng không? Thế nhưng, ngay cả khi chọn ngẫu nhiên, đúng không?
Half the time we get it right, we can actually still get pretty good performance of our pipeline. It's not idling, right?
Thì một nửa số lần ta vẫn đoán đúng, thì chúng ta vẫn có thể đạt hiệu năng khá tốt cho đường ống của mình. Nó không bị nhàn rỗi, đúng không?
So a very common mechanism these days in almost all the architectures is to do basically branch prediction.
Vì vậy, một cơ chế rất phổ biến ngày nay trong hầu hết các kiến trúc là thực hiện dự đoán rẽ nhánh (branch prediction).
Branch prediction logic is actually getting very complex and the pipeline is actually pretty deep to actually do a very good branch prediction.
Logic dự đoán rẽ nhánh thực tế đang trở nên rất phức tạp và đường ống cũng khá sâu để có thể dự đoán rẽ nhánh rất tốt.
We'll talk a little bit about that, you will have time later in the semester, but branch prediction is basically which way the branch is taken so that we can actually keep our pipeline busy instead of being stalled.
Chúng ta sẽ nói qua một chút về điều đó, các bạn sẽ có thời gian tìm hiểu sau trong học kỳ, nhưng dự đoán rẽ nhánh về cơ bản là dự đoán nhánh sẽ đi theo hướng nào để chúng ta có thể giữ cho đường ống luôn hoạt động thay vì bị đình trệ.
And then we flush the pipeline if the branch prediction was incorrect. So we talked about the pipeline depths, right?
Và sau đó ta xả (flush) đường ống nếu dự đoán rẽ nhánh sai. Chúng ta đã nói về độ sâu của đường ống rồi, đúng không?
Last lecture, I think one of the students were asking whether it's actually the deeper the better.
Ở bài giảng trước, tôi nhớ có một bạn sinh viên đã hỏi liệu đường ống càng sâu có phải càng tốt không.
One of the reasons that stopped the designers from building super deep pipelines is basically the penalty of the branch prediction.
Một trong những lý do khiến các nhà thiết kế không xây dựng những đường ống siêu sâu là cái giá phải trả (penalty) khi dự đoán rẽ nhánh sai.
If the pipeline is very deep, we're making a lot of predicted executions and then eventually you actually make a wrong prediction.
Nếu đường ống rất sâu, ta thực hiện suy đoán rất nhiều lệnh và rồi cuối cùng ta dự đoán sai.
Then we need to flush all the components, all the instructions in our pipeline, right? So deeper the pipeline, we actually need to flush more instructions.
Khi đó ta cần xả tất cả các thành phần, tất cả các lệnh trong đường ống, đúng không? Vậy đường ống càng sâu thì ta càng phải xả nhiều lệnh hơn.
So even just from a pure performance point of view, the pipeline depth is not the deeper the better. Branch prediction has a penalty. Some of the branches are very hard to predict.
Vì thế, chỉ xét thuần túy từ góc độ hiệu năng, độ sâu đường ống không phải càng sâu càng tốt. Dự đoán rẽ nhánh có cái giá phải trả. Một số nhánh rất khó dự đoán.
A lot of branches are very easy to predict, but a lot of branches are very hard, right? So this, we also need to flush the pipeline if we're not, we're making an incorrect prediction.
Nhiều nhánh rất dễ dự đoán, nhưng cũng nhiều nhánh rất khó, đúng không? Vì vậy, ta cũng cần xả đường ống nếu ta dự đoán sai.
What is the example of the branch? That's a very good question.
Ví dụ về nhánh là gì? Đó là một câu hỏi rất hay.
Actually, one of the most popular one that's actually used in a lot of production example is what they call neural prediction.
Thực ra, một trong những phương pháp phổ biến nhất được dùng trong nhiều sản phẩm thực tế là cái mà người ta gọi là neural prediction.
This is actually before deep learning takes over everything, as like 20, 30 years ago.
Điều này có từ trước khi học sâu thống trị mọi thứ, khoảng 20, 30 năm trước.
It's basically a very simple linear regression, or I guess you can call it a fully connected layer, linear regression algorithms. They're basically looking at the history.
Về cơ bản nó là một hồi quy tuyến tính rất đơn giản, hoặc có thể gọi là một lớp kết nối đầy đủ, các thuật toán hồi quy tuyến tính. Chúng về cơ bản xem xét lịch sử.
Like whenever we see a branch instruction, we can actually see the history of whether it's taken or not. Like for example, you have a loop, right? You're doing matrix multiply.
Chẳng hạn, mỗi khi gặp một lệnh rẽ nhánh, ta có thể xem lịch sử xem nhánh đó có được thực hiện hay không. Ví dụ, bạn có một vòng lặp, đúng không? Bạn đang nhân ma trận.
If the most of the prior iteration this branch is taken, then it's very likely this branch is taken, right?
Nếu ở hầu hết các vòng lặp trước nhánh này được thực hiện, thì rất có khả năng nhánh này cũng sẽ được thực hiện, đúng không?
So this kind of what they call neural prediction in today's world is basically machine learning or deep learning based prediction.
Vậy cái mà người ta gọi là neural prediction, trong thế giới ngày nay về cơ bản là dự đoán dựa trên học máy hoặc học sâu.
It's basically a linear regression model, and then you actually track the history of the branch is taken or not.
Về cơ bản nó là một mô hình hồi quy tuyến tính, và sau đó bạn theo dõi lịch sử xem nhánh có được thực hiện hay không.
That actually predicts for the current branch, for the current instruction, whether it will be taken or not.
Nó dự đoán cho nhánh hiện tại, cho lệnh hiện tại, xem nhánh đó có được thực hiện (taken) hay không.
So that's actually one of the, I guess one of the only marriage that I'm aware of between architecture and deep learning before we start designing deep learning hardware.
Theo tôi biết thì đó là một trong số ít sự kết hợp giữa kiến trúc máy tính và học sâu, từ trước khi chúng ta bắt đầu thiết kế phần cứng cho học sâu.
But yeah, a lot of the branch prediction, they're basically using some learning based mechanism.
Nhưng đúng vậy, rất nhiều bộ dự đoán nhánh về cơ bản đều dùng một cơ chế dựa trên học máy nào đó.
Mostly the branch predictor design tracks the history of the past branch and then by using different models to predict whether the current branch will take it or not.
Phần lớn thiết kế bộ dự đoán nhánh theo dõi lịch sử của các nhánh trước đó rồi dùng các mô hình khác nhau để dự đoán xem nhánh hiện tại có được thực hiện hay không.
So history, generally they have different people, they have different names for the table. They also track global versus local, like whether we track the history of all the branches or we separate different branches.
Về lịch sử, thường mỗi người lại có những tên gọi khác nhau cho cái bảng này. Người ta cũng phân biệt lịch sử toàn cục và cục bộ, tức là theo dõi lịch sử của tất cả các nhánh chung hay tách riêng từng nhánh.
We only have separate history for different branches, right? So they track different histories and use that history to make the prediction. Yeah, good question.
Tức là chỉ giữ lịch sử riêng cho từng nhánh, đúng không? Vậy là họ theo dõi các lịch sử khác nhau và dùng chúng để đưa ra dự đoán. Ừ, câu hỏi hay.
I think you asked about the pipeline depth question last time, right? Yeah, so that's basically a branch prediction.
Tôi nhớ lần trước bạn có hỏi về độ sâu của đường ống, đúng không? Vâng, đó chính là dự đoán nhánh.
That's actually a very useful mechanism that exists in almost every processor this day, especially a more out of order processor. I think we also make this as a extra credit for your final project.
Đây là một cơ chế rất hữu ích có mặt trong hầu hết các bộ xử lý ngày nay, đặc biệt là các bộ xử lý thực thi không theo thứ tự. Chúng tôi cũng để phần này làm điểm cộng cho đồ án cuối kỳ của các bạn.
The baseline pipeline don't need to have a branch prediction, but you can design any other branch predictor that you like and see, especially for the matrix multiply example we have, you will get a lot of performance improvement.
Đường ống cơ sở không cần có dự đoán nhánh, nhưng bạn có thể thiết kế bất kỳ bộ dự đoán nhánh nào bạn thích và xem thử, đặc biệt với ví dụ nhân ma trận mà chúng ta có, bạn sẽ cải thiện hiệu năng rất nhiều.
So that's branch prediction. How does it work? At a very high level, right?
Vậy đó là dự đoán nhánh. Nó hoạt động thế nào? Ở mức rất tổng quát thôi nhé.
So again, When we actually see a branch, again, based on your branch predictor mechanism, right, either tracking local history or global history, you make a hardware, make a prediction, say, "Okay, for this instruction, it's based on its past history and the past history of all the other branches.
Nên, một lần nữa, khi gặp một lệnh nhánh, tùy theo cơ chế dự đoán nhánh của bạn, dù là theo dõi lịch sử cục bộ hay toàn cục, phần cứng sẽ đưa ra dự đoán, kiểu như: "Được rồi, với lệnh này, dựa trên lịch sử trước đó của nó và lịch sử của tất cả các nhánh khác, rất có thể nhánh này được thực hiện."
It's very likely this branch is taken." With that, we basically get the next PC directly, and then we start executing. And then if the guess is correct, we just keep our execution.
Từ đó, ta lấy được ngay PC kế tiếp, rồi bắt đầu thực thi. Nếu dự đoán đúng, ta cứ tiếp tục thực thi.
If the guess is incorrect, again, we flush the pipeline. We have all the actual instruction that we have, right? We flush the pipeline, and then restart our execution. So, Ben?
Nếu dự đoán sai, ta lại xả đường ống (flush). Ta có đầy đủ các lệnh thực tế, đúng không? Ta xả đường ống rồi thực thi lại từ đầu. Ben, bạn muốn hỏi gì?
And this guess that you speak out EA still cycles on the portals with it? Yeah, that's a good question. So how do we actually guess the correct PC, right?
Và dự đoán mà bạn nói đó vẫn tốn chu kỳ để tính ra à? Ừ, câu hỏi hay. Vậy làm sao để đoán đúng PC? Đúng không?
So you will look at the branch procedure. We still need to do the immediate generation. We need to add the PC or add the immediate to the PC, right?
Bạn sẽ xem quy trình xử lý lệnh nhánh. Ta vẫn cần tạo giá trị immediate. Ta cần cộng PC với immediate, đúng không?
Again, it depends on your implementation, how things happen, when you see the immediate, and how fast you can do, and which ALU you are using, whether you're actually putting a dedicated ALU to do branch prediction, or you want to reuse the same ALU, right?
Một lần nữa, điều này tùy vào cách bạn triển khai, mọi thứ diễn ra ra sao, khi nào bạn có được immediate và bạn làm nhanh đến đâu, và bạn dùng ALU nào, liệu bạn có dùng một ALU riêng để thực hiện dự đoán nhánh hay không, hay bạn muốn dùng lại cùng một ALU, đúng không?
So then it's become a hardware design, right? If you have more resources, you can put a dedicated ALU, you grab the immediate, and then you put there, that can happen immediately.
Vậy thì nó trở thành một vấn đề thiết kế phần cứng, đúng không? Nếu có nhiều tài nguyên hơn, bạn có thể đặt một ALU riêng, lấy giá trị immediate, rồi đưa vào đó, và việc này có thể diễn ra ngay lập tức.
Johnny?
Johnny?
Oh, you basically have parallel execution. That's actually a very good idea.
À, về cơ bản là bạn có thực thi song song. Đó thực sự là một ý tưởng rất hay.
I think there's some prior proposal do that, to the extent they even actually duplicate the register file, because they're eventually asking to do the register file access.
Tôi nghĩ đã có một số đề xuất trước đây làm như vậy, thậm chí đến mức họ còn nhân đôi cả register file, vì cuối cùng họ cần thực hiện việc truy cập register file.
Again, whenever you have parallel paths, you need to synchronize, right?
Một lần nữa, hễ có các đường song song thì bạn cần đồng bộ hóa, đúng không?
When you actually overwrite, how things are overwrite, which register file actually have the right result, of course you can, but you need to Guarantee correctness, right?
Khi ghi đè, việc ghi đè diễn ra như thế nào, register file nào thực sự có kết quả đúng, tất nhiên là bạn làm được, nhưng bạn phải đảm bảo tính đúng đắn, đúng không?
You get the performance benefit, but to guarantee correctness, you need to do a lot of synchronization between the paths. So we won't, like again, in 152, you will actually see more.
Bạn được lợi về hiệu năng, nhưng để đảm bảo tính đúng đắn, bạn cần đồng bộ hóa rất nhiều giữa các đường. Nên chúng ta sẽ không đi sâu, trong môn 152 các bạn sẽ được học nhiều hơn.
There are actually also predicated execution. We're actually talking about how we actually support multiple parallel execution concurrently.
Còn có cả predicated execution nữa. Chúng ta đang nói về cách hỗ trợ nhiều thực thi song song đồng thời.
But again, whenever we make prediction and predicated execution, we need to make sure we can roll back, we can synchronize, so that everything is still correct in the end.
Nhưng một lần nữa, hễ khi chúng ta dự đoán và dùng predicated execution, chúng ta cần đảm bảo có thể quay lui và đồng bộ hóa, để cuối cùng mọi thứ vẫn đúng.
Good question.
Câu hỏi hay.
Oh, you will actually predict here, and then it's incorrect.
À, bạn sẽ dự đoán ở đây, rồi nó bị sai.
Oh, we basically flush all the instructions, and then...
À, về cơ bản chúng ta xả (flush) hết các lệnh, rồi...
So here, so you're asking if we actually predict the branch is taken, we start executing, how do we go back to the... So here, that's basically the scenario, right?
Vậy ở đây, bạn đang hỏi nếu ta dự đoán nhánh được thực hiện, rồi bắt đầu thực thi, thì làm sao quay lại... Vậy ở đây, đó chính là tình huống ấy, đúng không?
We predict, it will happen, we actually go to the label directly, we skip a bunch of instructions that follow this instruction.
Ta dự đoán nó sẽ xảy ra, ta nhảy thẳng đến nhãn, bỏ qua một loạt lệnh nằm sau lệnh này.
Remember, we basically always do either the new label that calculated, or PC plus four, right?
Hãy nhớ, về cơ bản ta luôn chọn hoặc nhãn mới đã tính, hoặc PC cộng bốn, đúng không?
So that's how we pick the new PC in the end, right?
Đó là cách cuối cùng ta chọn PC mới, đúng không?
So if the label is incorrect, we basically revert back to the PC plus four, so we restart the execution that actually follows the instruction. Yeah.
Nên nếu nhãn bị sai, ta quay lại PC cộng bốn, và bắt đầu lại việc thực thi từ lệnh nằm ngay sau đó. Vâng.
We still need to hold... Yeah, we still need... Because before the branch result, we actually...
Ta vẫn cần giữ... Vâng, ta vẫn cần... Vì trước khi có kết quả của nhánh, ta...
Yeah, we cannot throw that away, because we're making prediction, but then we still need to know where we actually revert back to.
Vâng, ta không thể bỏ nó đi, vì ta đang dự đoán, nhưng ta vẫn cần biết sẽ quay lại đâu.
Oh, you have another... The register file is only for data, right? You have another register to remember the old PC that you can actually revert back to. Yeah, so whenever we actually...
À, bạn có một... Register file chỉ dành cho dữ liệu, đúng không? Bạn có thêm một thanh ghi khác để nhớ PC cũ để có thể quay lại đó. Vâng, nên mỗi khi ta...
So now it's actually making prediction, right?
Vậy bây giờ là đang dự đoán, đúng không?
So this is not deterministic, and no matter whether we're actually doing Python or not Python, we always need to actually have a copy of where we're supposed to be.
Nên nó không mang tính tất định, và bất kể chúng ta đang dùng Python hay không dùng Python, chúng ta luôn cần có một bản sao của vị trí mà lẽ ra chúng ta phải đang ở.
Okay, so branch, very interesting. It's another hazard we have.
Được rồi, vậy rẽ nhánh, rất thú vị. Đó là một loại hazard khác.
So far, we've talked about single cycle, multi-cycle, and pipeline execution, and the trade-off when it comes to pipeline execution, where there's either structural resource limitations or intrinsic data and the control dependencies that stop us from fully utilizing pipeline, right?
Cho đến giờ, chúng ta đã nói về thực thi đơn chu kỳ, đa chu kỳ và thực thi theo đường ống, và sự đánh đổi khi thực thi theo đường ống, trong đó có các giới hạn về tài nguyên cấu trúc hoặc các phụ thuộc dữ liệu bên trong và phụ thuộc điều khiển khiến chúng ta không thể tận dụng hết đường ống, đúng không?
So we need to understand how to handle them correctly and appropriately. More resources generally are useful to handle a structural hazard, but there is also a limit.
Vì vậy chúng ta cần hiểu cách xử lý chúng một cách đúng đắn và phù hợp. Thêm tài nguyên nói chung hữu ích để xử lý structural hazard, nhưng cũng có giới hạn.
Data forwarding is useful to handle some of the data hazards, and then the worst case, we always start to make sure that we have a correct execution.
Data forwarding hữu ích để xử lý một số data hazard, còn trong trường hợp xấu nhất, chúng ta luôn phải bắt đầu bằng việc đảm bảo thực thi đúng.
So the situation where we have a jump, where we don't need to do any prediction, where we're going, what is the best way to sort of, like, prevent...
Vậy trong trường hợp có lệnh nhảy, khi ta không cần dự đoán gì cả, khi biết mình sẽ đi đâu, cách tốt nhất để ngăn chặn...
How would that be forwarded? Yeah, you want to basically calculate the PC, the target PC, as soon as possible, right?
Điều đó sẽ được forward như thế nào? Đúng, về cơ bản bạn muốn tính PC đích càng sớm càng tốt, đúng không?
So even with our current execution, we still need to, well, it depends on which jump, but you still need to do register file access, you need to do the immediate generation, and then you do actually the ALU.
Vì vậy, ngay cả với cách thực thi hiện tại, thì còn tùy loại lệnh nhảy nào, nhưng bạn vẫn cần truy cập register file, cần tạo giá trị tức thời (immediate), rồi sau đó thực hiện ALU.
So with the current PC, you still need to, or the current datapath, it's basically still need to go through the decoding and execution stage to get the PC resolved.
Vậy với PC hiện tại, hay đúng hơn là datapath hiện tại, về cơ bản vẫn phải đi qua giai đoạn giải mã và thực thi để xác định được PC.
So it's basically how you can get the target PC as fast as possible, yeah. Yeah, but you still need to do... There's something you cannot completely skip, right?
Vậy về cơ bản là làm sao có được PC đích nhanh nhất có thể. Đúng, nhưng bạn vẫn cần phải... Có những thứ bạn không thể bỏ qua hoàn toàn, đúng không?
Immediate generation, you still need to do that, register file accesses, if you're actually reading from register file... So those are fundamental to actually get the PC resolved.
Tạo immediate thì vẫn phải làm, truy cập register file cũng vậy, nếu bạn thực sự đọc từ register file... Đó là những bước cơ bản để xác định được PC.
Yeah, but, well, that's for the jump, right? Because you know it actually will get to that. There is also, it depends on the depth of the pipeline, their jump is easier.
Nhưng đó là với lệnh nhảy thôi, đúng không? Vì bạn biết chắc là nó sẽ đi đến đó. Ngoài ra, còn tùy vào độ sâu của đường ống, lệnh nhảy thì dễ hơn.
Unconditional jump is easier than conditional branch in the sense that if you know it's a jump, You don't need to make a prediction, you can just stop, right?
Lệnh nhảy không điều kiện dễ hơn rẽ nhánh có điều kiện theo nghĩa là nếu bạn biết đó là lệnh nhảy, bạn không cần dự đoán, bạn có thể dừng lại, đúng không?
Instead of actually wasting power to actually do all those toggling, to do all those executions. So there is also that benefit, which is more deterministic than unconditional branch, yeah.
Thay vì lãng phí điện năng cho tất cả các lần chuyển mức và các thao tác thực thi đó. Vậy cũng có lợi ích đó, mang tính xác định hơn so với rẽ nhánh có điều kiện, vâng.
But either way, you need to make sure your target PC is resolved, which takes time. Divya? "How complicated would be the... I guess there's this idea of duplicating the...
Nhưng dù sao, bạn cũng phải đảm bảo PC đích được xác định, và việc đó tốn thời gian. Divya? "Sẽ phức tạp đến mức nào nếu... Tôi đoán có ý tưởng nhân đôi...
while alternating the instructions in the same pipeline, where each of the threads is forwarded in the same way, so that makes sense." So alternating, you mean one pipeline is...
trong khi xen kẽ các lệnh trong cùng một đường ống, trong đó mỗi luồng được forward theo cùng một cách, nên điều đó hợp lý." Vậy xen kẽ, ý bạn là một đường ống...
It was complicated from the beginning, right?
Nó vốn đã phức tạp ngay từ đầu rồi, đúng không?
Right, so when you, especially when you get to the project, you will see basically when, even when we start a pipeline new, right, you basically need to duplicate your control signal in some sense for each pipeline stage, right?
Đúng vậy, nên khi các bạn làm đến phần project, về cơ bản các bạn sẽ thấy rằng, ngay cả khi ta bắt đầu một đường ống mới, đúng không, các bạn về cơ bản cần nhân đôi các tín hiệu điều khiển theo một nghĩa nào đó cho mỗi tầng của đường ống, đúng không?
So now you're basically having diverging paths, basically to do another duplication of control signals, managing which paths we're executing.
Như vậy bây giờ các bạn có những đường đi phân nhánh, nghĩa là phải nhân đôi thêm một lần nữa các tín hiệu điều khiển, để quản lý xem ta đang thực thi những đường đi nào.
Put that aside, today's branch predictor is pretty good, right? So it's not like the branch predictor is bad, that we don't know how to actually do that. Today's branch predictor is pretty good.
Tạm gác chuyện đó sang một bên, bộ dự đoán rẽ nhánh ngày nay khá tốt, đúng không? Không phải là bộ dự đoán rẽ nhánh kém hay là ta không biết cách làm điều đó. Bộ dự đoán rẽ nhánh ngày nay khá tốt.
There are actually a lot of strong patterns in our execution.
Thực ra trong quá trình thực thi có rất nhiều quy luật rõ rệt.
So it's always better and simpler to actually design a better branch predictor, and then have a single, simpler pipeline, simpler datapaths.
Vì vậy luôn tốt hơn và đơn giản hơn nếu thiết kế một bộ dự đoán rẽ nhánh tốt hơn, rồi dùng một đường ống duy nhất, đơn giản hơn, với các datapath đơn giản hơn.
It's going to be an interesting, I guess, extra credit project if you want to do that trade-off. I'm curious whether...
Đó sẽ là một project điểm cộng khá thú vị nếu các bạn muốn thử đánh đổi này. Tôi tò mò liệu...
It definitely sounds pretty complex, because you need to do a lot of management, making sure things are actually on track, doing what they're supposed to be doing.
Nghe chắc chắn là khá phức tạp, vì bạn phải quản lý rất nhiều thứ, đảm bảo mọi thứ đi đúng hướng, làm đúng việc chúng phải làm.
Zero? "How do we calculate whether the guess result is correct? How do we check whether the guess result..." So for conditional branch, right, so we're basically doing a branch...
Zero? "Làm sao ta tính được kết quả dự đoán có đúng hay không? Làm sao ta kiểm tra kết quả dự đoán..." Với rẽ nhánh có điều kiện, đúng không, về cơ bản ta đang thực hiện một phép rẽ nhánh...
Remember the branch comparator that we have seen, we had before? So whenever, after the branch comparator, we know whether the branch is taken or not taken.
Các bạn còn nhớ bộ so sánh nhánh mà ta đã thấy trước đây không? Thì sau bộ so sánh nhánh, ta biết nhánh có được rẽ hay không.
Mm-hmm. Right, so when we say prediction, let me go back to the pipeline here.
Ừm. Đúng vậy, nên khi ta nói dự đoán, để tôi quay lại sơ đồ đường ống ở đây.
So when we say branch prediction, we're basically predicting whether a branch is taken or not taken. We're predicting a binary choice, whether it's taken or not taken.
Khi ta nói dự đoán rẽ nhánh, về cơ bản ta đang dự đoán nhánh sẽ được rẽ hay không được rẽ. Ta dự đoán một lựa chọn nhị phân: rẽ hoặc không rẽ.
That decision will be naturally resolved when we get to the branch comparator, right? Because all the branch comparator does is basically check whether the branch condition is met or not.
Quyết định đó tự nhiên sẽ được xác định khi ta đến bộ so sánh nhánh, đúng không? Bởi vì bộ so sánh nhánh chỉ làm một việc là kiểm tra xem điều kiện rẽ nhánh có thỏa mãn hay không.
So when we get to the branch comparator, we will know whether our prediction is correct or not. Is that your question? Yeah, we're not predicting the address.
Vì vậy khi đến bộ so sánh nhánh, ta sẽ biết dự đoán của mình đúng hay sai. Đó có phải là câu hỏi của bạn không? Vâng, ta không dự đoán địa chỉ.
We're just predicting a binary option, whether we should go to the next instruction or we go to the target. That's what's being predicted.
Ta chỉ dự đoán một lựa chọn nhị phân, là đi tới lệnh kế tiếp hay đi tới đích rẽ. Đó là thứ được dự đoán.
So the jump, you mean the label? So that's deterministic, right? That's part of the instruction. We're not predicting the target.
Vậy ý bạn là lệnh nhảy, tức là nhãn? Cái đó là xác định, đúng không? Nó là một phần của lệnh. Ta không dự đoán đích rẽ.
We are predicting whether the branch is taken or not, a binary choice. That's an important distinction. So you would go to here.
Ta dự đoán nhánh có được rẽ hay không, một lựa chọn nhị phân. Đó là một điểm khác biệt quan trọng. Vậy bạn sẽ đi đến đây.
All we are predicting is whether the branch is taken, whether T0 and T1 are equal or not. We either go to PC plus 4 or go to the label. This label is deterministic.
Tất cả những gì ta dự đoán là nhánh có được rẽ hay không, liệu T0 và T1 có bằng nhau hay không. Ta hoặc đi đến PC cộng 4, hoặc đi đến nhãn. Nhãn này là xác định.
So we make a prediction. Let's say in this example, we predict the branch is not taken, so we jump to PC plus 4. We start executing.
Vì vậy ta đưa ra một dự đoán. Giả sử trong ví dụ này, ta dự đoán rẽ nhánh không được thực hiện, nên ta nhảy đến PC cộng 4. Ta bắt đầu thực thi.
And then once we actually get to the ALU stage, we know actually the branch comparator results show that the branch is actually taken.
Và rồi khi thực sự đến giai đoạn ALU, ta biết là kết quả của bộ so sánh rẽ nhánh cho thấy rằng thực ra nhánh được thực hiện.
So we are checking the branch is taken or not. And if it's taken, it naturally means that we need to go to the label.
Vậy ta đang kiểm tra xem nhánh có được thực hiện hay không. Và nếu nó được thực hiện, đương nhiên có nghĩa là ta cần đi đến nhãn.
And this is what is being predicted, not the label. Okay, good question.
Và đây là thứ được dự đoán, chứ không phải nhãn. Được rồi, câu hỏi hay.
Yeah, that's a good question. A big part of hardware design, you will see actually a lot about the trade-off analysis or design space exploration.
Vâng, đó là một câu hỏi hay. Một phần lớn của thiết kế phần cứng, các bạn sẽ thấy rất nhiều về phân tích đánh đổi hay khám phá không gian thiết kế.
Some students actually in the past, they actually did an amazing job in actually doing all the different trade-off analysis, Whether it makes sense to build a very complex branch predictor.
Một số sinh viên trước đây đã làm rất xuất sắc trong việc thực hiện đủ loại phân tích đánh đổi, xem có hợp lý không khi xây dựng một bộ dự đoán rẽ nhánh rất phức tạp.
Some students actually do the superscalar execution pipeline. And then you can do the trade-off, whether it is actually valuable by adding that actual hardware there. So it's a trade-off analysis.
Một số sinh viên còn làm đường ống thực thi superscalar. Và sau đó bạn có thể phân tích đánh đổi, xem việc thêm phần cứng đó vào có thực sự đáng giá không. Vậy đây là một phân tích đánh đổi.
And then that's why we need very good tools to actually provide us with reliable feedback to actually figure out whether it's worth doing certain designs or not. Okay.
Và đó là lý do ta cần những công cụ rất tốt để cung cấp phản hồi đáng tin cậy, nhằm xác định xem có đáng làm một số thiết kế nhất định hay không. Được rồi.
Is there feedback?
Có phản hồi không?
Oh, that's a good question. So branch predictor is always evolving. Remember, we see, we track the history, right? So whenever a new branch is resolved, we actually add that history back to our table.
Ồ, câu hỏi hay. Bộ dự đoán rẽ nhánh luôn luôn phát triển. Nhớ là ta theo dõi lịch sử, đúng không? Nên mỗi khi một nhánh mới được xác định kết quả, ta lại thêm lịch sử đó vào bảng của mình.
So it's always updated. It's like you're collecting training data to your branch predictor, yeah. Well, we don't draw a branch predictor here, right?
Vì vậy nó luôn được cập nhật. Giống như bạn đang thu thập dữ liệu huấn luyện cho bộ dự đoán rẽ nhánh vậy. À, ở đây ta không vẽ bộ dự đoán rẽ nhánh, đúng không?
So you can imagine, basically, we actually, after branch comparison, we know whether it's taken or not. We basically update our history table, right?
Nên bạn có thể hình dung, về cơ bản, sau khi so sánh nhánh, ta biết nó được thực hiện hay không. Về cơ bản ta cập nhật bảng lịch sử, đúng không?
So everything is, you have all the information in your control logic. Last question, Ethan.
Vậy mọi thứ đều nằm trong logic điều khiển, bạn có toàn bộ thông tin ở đó. Câu hỏi cuối cùng, Ethan.
You mean, when we jump to a particular address, whether the microarchitecture needs to know whether
Ý bạn là, khi ta nhảy đến một địa chỉ cụ thể, vi kiến trúc có cần biết
the new address is in the ICache or not? So for cache, even when we make a load store, data access, do we need to know whether it's in cache or not?
địa chỉ mới có trong ICache hay không? Với cache, ngay cả khi ta thực hiện load store, truy cập dữ liệu, ta có cần biết nó có trong cache hay không?
Exactly. So all the...
Chính xác. Vậy tất cả...
Yeah, but it's all handled by cache. So cache, all the hit and miss. So when we access cache, we don't actually have...
Vâng, nhưng tất cả đều do cache xử lý. Còn với cache, toàn bộ việc hit và miss. Nên khi truy cập cache, thực ra chúng ta không...
So we do have scratchpad, where complete software control will actually know whether the data is in or not. The benefit of cache is that we don't need to care.
Chúng ta cũng có scratchpad, nơi phần mềm hoàn toàn kiểm soát và thực sự biết dữ liệu có ở đó hay không. Lợi ích của cache là chúng ta không cần bận tâm.
So everything is taken care of by cache. So everything is taken care of by cache. It's automatic. Okay, we are going to move on so that we can get started on the FPGA discussion.
Mọi thứ đều do cache lo. Mọi thứ đều do cache lo. Nó hoàn toàn tự động. Được rồi, chúng ta sẽ chuyển sang phần tiếp theo để bắt đầu thảo luận về FPGA.
But all those are very interesting discussion, very important. I encourage all of you to continue the discussion either after class available or during the discussion in the office hours.
Nhưng những thảo luận này đều rất thú vị và rất quan trọng. Tôi khuyến khích các bạn tiếp tục thảo luận, hoặc sau giờ học nếu tôi rảnh, hoặc trong giờ làm việc (office hours).
Those are very good questions. So we mentioned different hazards, different pipelining logic. This concludes our RISC-V discussion.
Đó đều là những câu hỏi rất hay. Chúng ta đã nói về các hazard khác nhau, các logic đường ống khác nhau. Đến đây là kết thúc phần thảo luận về RISC-V.
We're going to move on to other different platforms, how we actually design different platforms today, especially in the contactless class where we have the FPGA and the ASIC platform.
Chúng ta sẽ chuyển sang các nền tảng khác, xem ngày nay chúng ta thực sự thiết kế các nền tảng khác nhau như thế nào, đặc biệt trong lớp này, nơi chúng ta có nền tảng FPGA và ASIC.
Now, a lot of the components may seem pretty familiar.
Nhiều thành phần có thể trông khá quen thuộc.
For folks who are taking FPGA lab, you have seen some parts of this, but still good to actually present it in a more coherent fashion.
Với những bạn đang học phòng thí nghiệm FPGA, các bạn đã thấy một số phần của nội dung này, nhưng vẫn nên trình bày lại một cách mạch lạc hơn.
For folks in ASIC lab, you haven't seen this before, which is okay. It's just good to know all the different terminologies and where we are in terms of FPGA technology.
Với những bạn học phòng thí nghiệm ASIC, các bạn chưa thấy nội dung này, không sao cả. Chỉ cần nắm được các thuật ngữ khác nhau và biết công nghệ FPGA hiện đang ở đâu.
So FPGA is a pretty amazing innovation in the hardware industry.
FPGA là một đổi mới khá tuyệt vời trong ngành phần cứng.
In some sense, it actually has been overlooked in some area when people talk about, today's semiconductor industry is always Intel, AMD, CPUs, GPUs.
Theo một nghĩa nào đó, nó đã bị bỏ qua ở một số mảng khi người ta nói về ngành bán dẫn ngày nay thì lúc nào cũng là Intel, AMD, CPU, GPU.
But FPGA is very important in both using as basically a prototype devices for us to actually get to see different components, but also very useful in terms of actually doing hardware emulation.
Nhưng FPGA rất quan trọng, vừa dùng như thiết bị làm mẫu thử để chúng ta có thể quan sát các thành phần khác nhau, vừa rất hữu ích cho việc mô phỏng phần cứng (hardware emulation).
That's actually one of the major use of FPGA. Before the tape out, we actually emulate the hardware behavior on FPGA.
Đó là một trong những công dụng chính của FPGA. Trước khi tape out, chúng ta mô phỏng hành vi phần cứng trên FPGA.
So this is early, I guess at this point, almost 40 years ago, where transistors are actually pretty expensive. So when designers are approaching transistors, they basically want to make the best use of transistors.
Đó là thời kỳ đầu, tôi đoán khi ấy là gần 40 năm trước, khi transistor còn khá đắt. Vì vậy khi các nhà thiết kế làm việc với transistor, họ muốn tận dụng transistor tốt nhất có thể.
Design the transistors so that it can actually serve its purpose, does its job to actually maximize performance.
Thiết kế transistor sao cho nó đáp ứng đúng mục đích, làm đúng việc của nó để tối đa hóa hiệu năng.
The idea of FPGA is really betting on the assumption that transistors are going to get cheaper.
Ý tưởng của FPGA thực chất là đặt cược vào giả định rằng transistor sẽ ngày càng rẻ hơn.
If transistors are not that expensive, if they are going to get cheaper, we don't need to actually squeeze all the performance from the transistor.
Nếu transistor không quá đắt, nếu chúng sẽ rẻ đi, thì chúng ta không cần vắt kiệt toàn bộ hiệu năng từ transistor.
We can actually afford maybe not fully utilizing all the transistors, but make it a little bit more flexible, configurable, programmable, so that it can actually be used in a different scenario.
Chúng ta có thể chấp nhận không tận dụng hết mọi transistor, mà làm cho nó linh hoạt hơn một chút, cấu hình được, lập trình được, để có thể dùng trong các tình huống khác nhau.
So that's really what FPGA was betting on. And with a more small, it's a very good bet because transistors are getting cheaper every generation.
Đó chính là điều FPGA đã đặt cược. Và với quy mô ngày càng nhỏ, đó là một canh bạc rất tốt vì transistor rẻ hơn qua mỗi thế hệ.
So the idea here is, instead of actually trying so hard to design, making sure each transistor actually serves its function, its purpose, we can actually, well, I guess, design it more loosely, right?
Vậy ý tưởng ở đây là, thay vì cố gắng hết sức để thiết kế, đảm bảo mỗi transistor đều thực hiện đúng chức năng, đúng mục đích của nó, thì thực ra chúng ta có thể thiết kế một cách thoải mái hơn, đúng không?
So they are actually configurable and can be reconfigured for a different purpose. So that they can, maybe we need to actually use multiple transistors for that.
Tức là chúng có thể cấu hình được và có thể cấu hình lại cho một mục đích khác. Để chúng có thể, có thể ta phải dùng nhiều transistor cho việc đó.
There's some overhead because we're not really utilizing the transistors as much as it should be, compared to, like, ASIC design, but the benefit is really the flexibility, right?
Có một chút chi phí phụ trội vì chúng ta không thực sự tận dụng các transistor đầy đủ như lẽ ra phải có, so với thiết kế ASIC chẳng hạn, nhưng lợi ích thực sự là sự linh hoạt, đúng không?
So yeah, what we discussed earlier, right?
Vậy đó, những gì chúng ta đã thảo luận lúc nãy, đúng không?
So they made a very good bet that the transistors are going to get cheaper and that flexibility, programmability will eventually become very important, at least in some scenario, right?
Họ đã đặt cược rất đúng rằng transistor sẽ ngày càng rẻ hơn và tính linh hoạt, khả năng lập trình, cuối cùng sẽ trở nên rất quan trọng, ít nhất là trong một số tình huống, đúng không?
With that, there is a market where we can actually use flexible, configurable transistors so that we can reprogram it for a different purpose instead of actually hard-coded to certain functionality.
Nhờ đó, có một thị trường mà ta có thể dùng các transistor linh hoạt, có thể cấu hình, để lập trình lại cho một mục đích khác thay vì bị gắn cứng vào một chức năng nhất định.
So that's what Xilinx was betting on, basically 40 years ago, and it's a very good bet.
Đó là điều Xilinx đã đặt cược, khoảng 40 năm trước, và đó là một canh bạc rất đúng.
And this is, and then it's become a pretty big industry in really thinking about an alternative way of building hardware substrate. So specifically, what do we mean by FPGA and why FPGAs are interesting?
Và từ đó nó trở thành một ngành khá lớn, với việc suy nghĩ về một cách khác để xây dựng nền tảng phần cứng. Cụ thể thì FPGA nghĩa là gì và vì sao FPGA lại thú vị?
So this is the board that we're using in our FPGA lab, right? So from a technical point of view, they are pretty similar, right?
Đây là bo mạch mà chúng ta dùng trong phòng thí nghiệm FPGA, đúng không? Về mặt kỹ thuật thì chúng khá giống nhau, đúng không?
Still a hardware platform, but they can actually be designed faster, in the sense that we talk about PayPal, right? How about PayPal class, so you folks are interested next spring.
Vẫn là một nền tảng phần cứng, nhưng chúng có thể được thiết kế nhanh hơn, theo nghĩa như chúng ta đã nói về PayPal, đúng không? Còn lớp PayPal thì sao, các bạn nào quan tâm thì học vào mùa xuân tới.
Your folks really need to actually ship your design by the end of spring semester, and if you're lucky, you can actually get your design, supposed to be, the beginning of the fall semester, but looking at this year's PayPal class, It's more like Thanksgiving-ish, maybe Christmas, like maybe the end of the semester, right?
Các bạn thực sự phải gửi đi chế tạo thiết kế của mình trước cuối học kỳ mùa xuân, và nếu may mắn, bạn có thể nhận được thiết kế của mình, theo dự kiến là vào đầu học kỳ mùa thu, nhưng xét lớp PayPal năm nay thì phải đến khoảng Lễ Tạ ơn, có thể là Giáng sinh, tức là gần cuối học kỳ, đúng không?
So there's a big turnaround time, three months to six months at least, right? The bigger companies maybe get a faster turnaround, but it takes time.
Vậy là thời gian chờ rất lâu, ít nhất ba đến sáu tháng, đúng không? Các công ty lớn hơn có thể nhận nhanh hơn, nhưng vẫn mất thời gian.
Versus FPGA, you design something, you can actually immediately program on your FPGA board, and then you can actually interact with the board very quickly, right?
Còn với FPGA, bạn thiết kế một thứ gì đó, rồi có thể lập trình ngay lên bo mạch FPGA của mình, và sau đó tương tác với bo mạch rất nhanh, đúng không?
So you can basically do PayPal on your FPGA every minute, every hour, right?
Nên về cơ bản bạn có thể làm PayPal trên FPGA mỗi phút, mỗi giờ, đúng không?
So that's why it's actually so valuable for hardware emulation, because we don't want to actually catch a big bug like six months earlier, six months later, that just completely shut our product timeline, right?
Đó là lý do nó rất có giá trị cho việc mô phỏng phần cứng, vì chúng ta không muốn phát hiện một lỗi lớn sau sáu tháng, sáu tháng sau đó, khiến toàn bộ tiến độ sản phẩm của chúng ta bị đình trệ, đúng không?
So we want to actually use FPGA to emulate the behavior, right? So this is very important for FPGA, so that's why it's called field programmable.
Nên chúng ta muốn dùng FPGA để mô phỏng hành vi đó, đúng không? Điều này rất quan trọng với FPGA, và đó là lý do nó được gọi là field programmable.
It's like, oh, we'll get to the field, you can actually reprogram it for different functionality, right? Instead of hardened logic. But there is always cost, right? It's not free, right?
Kiểu như, ồ, ta đem nó ra thực địa, rồi có thể lập trình lại cho chức năng khác, đúng không? Thay vì logic cố định. Nhưng lúc nào cũng có cái giá phải trả, đúng không? Không miễn phí đâu.
Even the beginning of FPGA, right? They are really betting on transistors are getting cheaper, we can actually afford having a little bit more transistors for a limited set of functionality, right?
Ngay từ thuở đầu của FPGA cũng vậy, đúng không? Họ thực sự đặt cược vào việc transistor ngày càng rẻ hơn, nên chúng ta có thể chấp nhận dùng thêm một chút transistor cho một tập chức năng hạn chế, đúng không?
So this flexibility also have cost, right? So bigger die area, slower circuits, and then more energy, right?
Vậy sự linh hoạt này cũng có cái giá của nó, đúng không? Đó là diện tích die lớn hơn, mạch chậm hơn, và tốn nhiều năng lượng hơn, đúng không?
So people always ask me, for the same design we actually implemented, either ASIC or FPGA, what would be the gap, right?
Mọi người luôn hỏi tôi, với cùng một thiết kế mà chúng ta hiện thực hóa, dù là bằng ASIC hay FPGA, thì khoảng cách sẽ là bao nhiêu?
So again, things are changing, every generation is different, but roughly I would expect 10x performance and efficiency gap, the same design mapping on FPGA or ASIC, right?
Một lần nữa, mọi thứ đang thay đổi, mỗi thế hệ lại khác, nhưng nói đại khái thì tôi kỳ vọng chênh lệch khoảng 10 lần về hiệu năng và hiệu quả, khi ánh xạ cùng một thiết kế lên FPGA hay ASIC, đúng không?
So there is definitely a penalty, because we want to support, we'll see later how FPGA actually support this flexibility, and it's not free, right? It takes time to do that.
Vậy chắc chắn có một cái giá phải trả, vì chúng ta muốn hỗ trợ sự linh hoạt này, lát nữa chúng ta sẽ thấy FPGA hỗ trợ nó như thế nào, và nó không miễn phí, đúng không? Việc đó tốn thời gian.
We'll also see later, today's FPGA is not only just having this kind of reconfigurable logic, they actually have a lot of what they call hardened logic.
Sau này chúng ta cũng sẽ thấy, FPGA ngày nay không chỉ có loại logic có thể cấu hình lại này, mà còn có rất nhiều thứ gọi là logic cứng hóa (hardened logic).
Those are basically ASIC blocks, specialized blocks, because in some scenario, There are certain computations that have very fixed patterns, so we will still want to harden some blocks.
Về cơ bản đó là các khối ASIC, các khối chuyên dụng, bởi vì trong một số tình huống, có những phép tính có mẫu rất cố định, nên chúng ta vẫn muốn cứng hóa một số khối.
So it's more like really a system with heterogeneous components: some components are more reconfigurable, some components are actually hardened. So today's FPGA is actually, today's FPGA companies have already become system companies, right?
Vì vậy nó giống một hệ thống gồm các thành phần không đồng nhất hơn: một số thành phần có thể cấu hình lại hơn, một số thì được cứng hóa. Vậy FPGA ngày nay thực ra, các công ty FPGA ngày nay đã trở thành các công ty hệ thống, đúng không?
Even on your PYNQ board, your books don't use that much, but there's also an ARM core there, so it's already an SoC system there. So it's getting more complex and also more interesting.
Ngay cả trên bo PYNQ của các bạn, các bạn không dùng nhiều đến thế, nhưng ở đó cũng có một lõi ARM, nên nó đã là một hệ SoC rồi. Nó ngày càng phức tạp hơn và cũng thú vị hơn.
So compared to FPGA versus ASIC, so again, FPGA is more flexible, we can actually field reprogram our FPGAs to support this flexibility.
Vậy khi so sánh FPGA với ASIC, một lần nữa, FPGA linh hoạt hơn, chúng ta có thể lập trình lại FPGA tại hiện trường để hỗ trợ sự linh hoạt này.
So generally, when we actually consider the cost perspective, right? Cost perspective for ASIC, there's always this particular pretty high non-recurring engineering cost we mentioned earlier, right?
Nói chung, khi xét từ góc độ chi phí, đúng không? Về chi phí đối với ASIC, luôn có khoản chi phí kỹ thuật một lần khá cao mà chúng ta đã nhắc trước đó, đúng không?
We need to design, go through the flow, do the test, do the verification, all of that contributes to the ASIC cost. Versus FPGA, you actually don't need to do a lot of specialized design.
Chúng ta cần thiết kế, đi qua cả quy trình, kiểm thử, kiểm chứng, tất cả những việc đó đều góp vào chi phí ASIC. Còn với FPGA, bạn thực sự không cần làm nhiều thiết kế chuyên biệt.
You're making sure you have this kind of, we'll talk about later, the configurable logic are designed there, and then you can start shipping your products, right?
Bạn chỉ cần đảm bảo có, lát nữa chúng ta sẽ nói, phần logic có thể cấu hình đã được thiết kế sẵn ở đó, rồi bạn có thể bắt đầu xuất xưởng sản phẩm, đúng không?
So we don't need to do that tailored specialized design for the specific use cases. So that's a major difference from the cost perspective.
Vậy chúng ta không cần làm việc thiết kế chuyên biệt, riêng cho từng trường hợp sử dụng. Đó là điểm khác biệt lớn xét từ góc độ chi phí.
Different people have different ways of thinking about the scaling, like basically from one generation to the next generation, right?
Mỗi người có cách nghĩ khác nhau về việc scaling, tức là về cơ bản từ thế hệ này sang thế hệ tiếp theo, đúng không?
So this figure is actually a little bit old, this is 2015, right? Seven years ago. This figure is still betting on, like, we look at the design, right?
Hình này hơi cũ rồi, là năm 2015, tức bảy năm trước. Hình này vẫn đặt cược vào việc, khi chúng ta nhìn vào thiết kế, thiết kế sẽ rẻ đi theo thời gian vì công nghệ mới rẻ hơn.
Design actually gets cheaper over time because the new technology is cheaper. It's actually not like that anymore, we already talked about early on, right?
Thực ra giờ không còn như vậy nữa, chúng ta đã nói từ đầu rồi, đúng không?
The design these days is actually getting a lot more expensive.
Ngày nay, việc thiết kế thực ra đang trở nên đắt hơn rất nhiều.
So the trade-off between FPGAs is actually getting a little bit blurred, in the sense of purely from the cost perspective, because today's FPGAs are also using very advanced technologies.
Vì vậy, sự đánh đổi giữa FPGA và ASIC thực ra đang trở nên mờ đi một chút, xét thuần túy từ góc độ chi phí, vì các FPGA ngày nay cũng đang dùng những công nghệ rất tiên tiến.
It's not like FPGAs actually stay behind, they can only use Older technology, that's fine. They are basically using the same state-of-the-art technologies as ASIC, so they are also using very advanced technology.
Không phải là FPGA bị tụt lại phía sau, rồi chỉ có thể dùng công nghệ cũ hơn, không phải vậy. Về cơ bản, chúng dùng cùng những công nghệ hiện đại nhất như ASIC, nên chúng cũng dùng công nghệ rất tiên tiến.
So the cost part is getting a little bit blurred, but the key differences is the NRE cost, where ASIC is generally higher, because we already need to design for our particular logic pretty early on before we do the cost.
Vì vậy phần chi phí đang trở nên mờ đi một chút, nhưng khác biệt then chốt là chi phí NRE, nơi ASIC nhìn chung cao hơn, vì chúng ta phải thiết kế cho phần logic cụ thể của mình từ khá sớm, trước khi tính đến chi phí.
Again, this part of the slides is what we keep updating over the past years. We have two dominant FPGA vendors, Xilinx and Altera.
Một lần nữa, phần này của các slide là phần chúng tôi liên tục cập nhật qua những năm qua. Có hai nhà cung cấp FPGA thống trị là Xilinx và Altera.
Xilinx is a bigger one and Altera is slightly smaller, but over the past decade, right, we see a lot of consolidation going on in our semiconductor industry.
Xilinx lớn hơn còn Altera nhỏ hơn một chút, nhưng trong thập kỷ vừa qua, chúng ta thấy rất nhiều vụ hợp nhất diễn ra trong ngành bán dẫn.
So Xilinx is now really part of AMD and Altera is now part of Intel.
Giờ đây Xilinx thực sự là một phần của AMD và Altera là một phần của Intel.
So a lot of things have actually changed, but both Intel and AMD are very committed in continuing FPGA development, so we're still seeing new FPGA boards actually released from both vendors every year.
Vậy nên có rất nhiều thứ đã thay đổi, nhưng cả Intel và AMD đều rất cam kết tiếp tục phát triển FPGA, nên chúng ta vẫn thấy các bo mạch FPGA mới được cả hai hãng phát hành mỗi năm.
So FPGA, that's a trade-off between FPGA and ASIC, right? Why it is actually very useful in today's design. What do we mean by FPGA? What is the core idea?
Vậy đó là sự đánh đổi giữa FPGA và ASIC, đúng không? Tại sao nó thực sự rất hữu ích trong thiết kế ngày nay. FPGA nghĩa là gì? Ý tưởng cốt lõi là gì?
Right, we mentioned the whole hypothesis FPGA was betting on is basically having a configurable, flexible logic that can be programmed later by software, right, which means that the hardware substrates need to be modular and also need to be configurable.
Chúng ta đã nói rằng giả thuyết mà FPGA đặt cược về cơ bản là có một phần logic cấu hình được, linh hoạt, có thể được lập trình sau bằng phần mềm, đúng không, nghĩa là nền tảng phần cứng cần có tính mô-đun và cũng cần cấu hình được.
So we look at the basic idea. This is actually one of the earliest Xilinx FPGA diagrams. A lot of today's designs actually look pretty similar. The key idea is still there.
Hãy xem ý tưởng cơ bản. Đây thực ra là một trong những sơ đồ FPGA Xilinx đầu tiên. Nhiều thiết kế ngày nay trông vẫn khá giống như vậy. Ý tưởng chủ chốt vẫn còn đó.
So they basically have an array of logics. We'll talk about what kind of logics they have inside specifically.
Về cơ bản chúng có một mảng các khối logic. Chúng ta sẽ nói cụ thể bên trong chúng có loại logic nào.
They have an array of logics, putting arithmetic, computation, and flip-flops, right, so that we can support a sequential logic, where the users can actually reconfigure the specific computation going on of each block.
Chúng có một mảng logic, gồm phép toán số học, tính toán, và flip-flop, để chúng ta có thể hỗ trợ logic tuần tự, trong đó người dùng có thể cấu hình lại phép tính cụ thể diễn ra trong từng khối.
We'll actually see later, it's actually pretty similar, the way we actually configure a lookup table, A design choose table, and also how the different blocks are connected.
Sau này chúng ta sẽ thấy nó khá giống nhau, cách chúng ta cấu hình một bảng tra cứu, một bảng chọn thiết kế, và cả cách các khối khác nhau được kết nối.
So basically two parts. One, what each block is doing, that can be configured. Second, how those different blocks are connected, that can also be configured. So with that, that's some terminology.
Vậy về cơ bản có hai phần. Một, mỗi khối làm gì, điều đó có thể cấu hình được. Hai, các khối khác nhau được kết nối với nhau như thế nào, điều đó cũng có thể cấu hình được. Đó là một số thuật ngữ.
You'll see there's a lot of CLBs, configurable logic blocks, that's basically the functional units. The first part, the arithmetic, that can be configured.
Bạn sẽ thấy có rất nhiều CLB, tức khối logic cấu hình được, về cơ bản là các đơn vị chức năng. Phần đầu tiên, phần số học, có thể cấu hình được.
And also the interconnect, we'll also talk briefly how we actually have different, making sure different parts of the compute logic actually talk to each other by configuring the interconnect.
Và cả phần kết nối liên thông, chúng ta cũng sẽ nói ngắn gọn về cách chúng ta có các loại khác nhau, đảm bảo các phần khác nhau của logic tính toán thực sự giao tiếp được với nhau bằng cách cấu hình mạng liên kết.
So that's basically, that's where FPGA started with many, I guess, 40 years ago.
Về cơ bản, FPGA bắt đầu từ đó, cách đây khoảng 40 năm.
A lot of the design are still similar, but we'll also talk about some of the more modern development for you later. So you look at state-of-art Xilinx FPGAs, right?
Nhiều thiết kế vẫn còn tương tự, nhưng sau này chúng ta cũng sẽ nói về một số phát triển hiện đại hơn. Vậy hãy xem các FPGA Xilinx tiên tiến nhất, đúng không?
So it's, as I mentioned earlier, it's actually always a pretty, this is also, I think, last year, a couple years ago, we were talking about 16 nanometer technology, which is state-of-art, but FPGAs are keep advancing.
Như tôi đã nói trước đó, thật ra lúc nào cũng khá là, cái này cũng là của năm ngoái, vài năm trước, khi đó chúng ta nói về công nghệ 16 nanomet, vốn là tiên tiến nhất, nhưng FPGA vẫn không ngừng phát triển.
They are basically using the latest technology, right. Generally, people talk about Virtex.
Về cơ bản chúng dùng công nghệ mới nhất, đúng không. Nhìn chung, người ta hay nói về Virtex.
Those are like bigger, bigger ones, like the one we are using, I think it's the Artix-7, like the PYNQ board that we are using. It's more like the lower-end FPGAs that we have, right.
Đó là những dòng lớn hơn nhiều, không như dòng chúng ta đang dùng, tôi nghĩ là Artix-7, như bo mạch PYNQ mà chúng ta đang sử dụng. Nó thuộc loại FPGA tầm thấp hơn, đúng không.
So you will look at like the blocks that we're using, it was still, especially looking at the bigger one, right, the high-end one, right.
Các bạn hãy xem những khối mà chúng ta đang dùng, đặc biệt là nhìn vào dòng lớn hơn, đúng rồi, dòng cao cấp.
So we are talking about, this is like the memory, the RAMs here, right. We're talking about tens or hundreds of megabytes actually on-chip memory on today's FPGA board.
Ở đây là bộ nhớ, các RAM, đúng không. Chúng ta đang nói đến hàng chục hay hàng trăm megabyte bộ nhớ ngay trên chip trên bo mạch FPGA ngày nay.
Very, very impressive, right. How much memory do you have on your PYNQ board for folks in the FPGA lab?
Rất ấn tượng, đúng không. Các bạn trong phòng thí nghiệm FPGA, bo mạch PYNQ của các bạn có bao nhiêu bộ nhớ?
Well, so those are the high-end, right. We're talking about tens of megabytes, hundreds of megabytes, right, a high-end. And your FPGA is more like the low-end, which is already pretty powerful, right?
Đó là dòng cao cấp, đúng không. Dòng cao cấp có hàng chục, hàng trăm megabyte. Còn FPGA của các bạn thuộc dòng tầm thấp, nhưng vậy cũng đã khá mạnh rồi, đúng không?
You can do a little bit, right? So any guesses? What's the range?
Cũng làm được kha khá đấy. Các bạn đoán thử xem? Khoảng bao nhiêu?
Two megabytes? Megabytes is a very big unit.
Hai megabyte ư? Megabyte là một đơn vị rất lớn.
It's more in the kilobytes, like single digits, tens of kilobytes range for lower-end FPGAs. That's still a lot. You can actually do a lot of things there.
Con số này thiên về kilobyte, cỡ một chữ số, đến hàng chục kilobyte với FPGA tầm thấp. Vậy vẫn là nhiều. Các bạn có thể làm được rất nhiều thứ với nó.
You look at actually the flip-flops here again, right?
Hãy xem lại các flip-flop ở đây.
So it's a bigger one where, like, hundreds of kilobytes, well, flip-flops, right, kilobytes or actually megabytes, it's also in the megabytes range, which is also pretty impressive.
Với dòng lớn hơn thì có hàng trăm kilobyte, à, flip-flop, kilobyte hay thậm chí megabyte, cũng ở mức megabyte, cũng khá ấn tượng.
And also the lookup table, we'll talk about lookup table later, right? So here, which row is lookup table? Okay, so this is lookup table, right?
Còn bảng tra cứu, lát nữa chúng ta sẽ nói về bảng tra cứu, đúng không? Vậy ở đây hàng nào là bảng tra cứu? Được rồi, đây là bảng tra cứu.
We're talking about hundreds of kilobytes, yeah, hundreds of kilobytes in terms of lookup table actually being stored, which is basically the functional units that are actually being configured there, right?
Chúng ta đang nói đến hàng trăm kilobyte, vâng, hàng trăm kilobyte bảng tra cứu được lưu trữ, về cơ bản chính là các đơn vị chức năng đang được cấu hình ở đó, đúng không?
So a lot of storage, very big storage actually being used. I even get to actually mega range. So today's FPGAs are actually pretty advanced. They have a lot of components.
Vậy là có rất nhiều dung lượng lưu trữ, rất lớn, đang được sử dụng. Thậm chí còn lên đến mức mega. FPGA ngày nay khá tiên tiến. Chúng có rất nhiều thành phần.
I think some of them also have HBM, yeah, like some of them actually have HBM support, right?
Tôi nghĩ một số còn có cả HBM, vâng, một số thực sự có hỗ trợ HBM, đúng không.
So they can actually do a lot of things, and those FPGAs are also in today's data center, right?
Vì vậy chúng làm được rất nhiều việc, và những FPGA này cũng có mặt trong các trung tâm dữ liệu ngày nay.
So there's not only server CPUs, this big FPGA also being used to do a lot of amazing things.
Vậy nên không chỉ có CPU máy chủ, mà những con FPGA lớn này cũng được dùng để làm rất nhiều việc tuyệt vời.
So yeah, so FPGA is actually getting a lot more advanced, but they actually have a lot of shared substrate.
Vâng, FPGA ngày càng tiên tiến hơn nhiều, nhưng chúng thực ra có chung rất nhiều nền tảng cơ bản.
It's actually being used to support the key functionality so that they can actually be programmed. So we talk about the configurable logic. We talk about the logic and the interconnect.
Nó được dùng để hỗ trợ các chức năng then chốt để chúng có thể được lập trình. Vậy ta sẽ nói về logic có thể cấu hình. Ta sẽ nói về logic và phần kết nối.
We'll start with the logic or the CLBs. Specifically, we'll talk about the key building block, lookup tables or LUTs. We already mentioned briefly earlier.
Ta sẽ bắt đầu với phần logic, hay các CLB. Cụ thể, ta sẽ nói về khối cơ bản then chốt là bảng tra cứu, hay LUT. Ta đã nhắc sơ qua trước đó.
We'll also talk about how we use LUTs to build different slices in our FPGA.
Ta cũng sẽ nói về cách dùng LUT để xây dựng các slice khác nhau trong FPGA.
So before we start the specific FPGA discussion, many of you, especially folks in the ASIC FPGA lab, have seen this. Just a quick refresher, right.
Trước khi bắt đầu thảo luận cụ thể về FPGA, nhiều bạn, đặc biệt là những bạn trong phòng thí nghiệm ASIC FPGA, đã thấy phần này rồi. Chỉ là nhắc lại nhanh thôi.
There are some key building blocks in FPGAs before I get to the details. Mux or multiplexers, right. We talked about this multiple times. Very useful logic, right.
Có một số khối cơ bản quan trọng trong FPGA trước khi tôi đi vào chi tiết. Mux, hay bộ dồn kênh. Ta đã nói về nó nhiều lần. Là một loại logic rất hữu ích.
Whenever we actually need to pick a particular input, right, we use muxes. And this is a very important building block in today's FPGA. We'll talk about it. We'll see later.
Bất cứ khi nào cần chọn một đầu vào cụ thể, ta dùng mux. Và đây là một khối cơ bản rất quan trọng trong FPGA ngày nay. Ta sẽ nói về nó. Ta sẽ thấy sau.
It's basically a big lookup table, right, based on the different conditions. We pick the different entries of the lookup table, which means the multiplexer is very useful because we're doing that selection.
Về cơ bản nó là một bảng tra cứu lớn, dựa trên các điều kiện khác nhau. Ta chọn các mục khác nhau của bảng tra cứu, nghĩa là bộ dồn kênh rất hữu ích vì ta đang thực hiện việc chọn đó.
Another important component is basically how we actually store the configuration, or the latches. We actually use a latch to actually store the configuration.
Một thành phần quan trọng khác về cơ bản là cách ta lưu cấu hình, hay chính là latch. Ta dùng một latch để lưu cấu hình.
It's similar to the flip-flop, but instead of edge triggered, in the flip-flop we always have this triangle here in the flip-flop, right, edge triggered.
Nó tương tự flip-flop, nhưng thay vì kích theo sườn, ở flip-flop ta luôn có hình tam giác này trong flip-flop, đúng không, kích theo sườn.
This is actually more, a latch is more level triggered, right. If it is one, we pass the data in. If it is zero, we don't pass the data in.
Còn latch thì kích theo mức. Nếu là một, ta cho dữ liệu đi vào. Nếu là không, ta không cho dữ liệu vào.
We'll see roughly in a month how we actually want, how we actually build flip-flops and the memories. And you will see this a lot, this pair, we call cross-coupled inverters.
Khoảng một tháng nữa ta sẽ thấy cách ta muốn xây dựng flip-flop và các bộ nhớ. Và bạn sẽ thấy cặp này rất nhiều, gọi là các cặp inverter mắc chéo.
This is a key building block where we actually want to store any bits, any bits of information. That's basically a key building block that we will use to store that information.
Đây là khối cơ bản then chốt khi ta muốn lưu bất kỳ bit nào, bất kỳ bit thông tin nào. Về cơ bản đó là khối then chốt ta sẽ dùng để lưu thông tin đó.
So those are the two building blocks that we see actually in today's, well, in the history of FPGAs, but also exist in today's FPGAs: multiplexers and latches to store the configuration.
Vậy đó là hai khối cơ bản mà ta thấy trong à, suốt lịch sử của FPGA, và cũng có mặt trong FPGA ngày nay: bộ dồn kênh và latch để lưu cấu hình.
So specifically, what exactly is a CLB, or configurable logic block, right? So it's basically the template that we use to support combinational and sequential logic, right.
Vậy cụ thể CLB, hay khối logic có thể cấu hình, chính xác là gì? Về cơ bản nó là khuôn mẫu ta dùng để hỗ trợ logic tổ hợp và logic tuần tự.
We mentioned additional logic, specifically combinational and sequential logic. It has a lookup table or LUTs, right? So we talk about LUTs.
Ta đã nhắc đến logic bổ sung, cụ thể là logic tổ hợp và tuần tự. Nó có bảng tra cứu hay LUT. Vậy ta nói về LUT.
For folks in the ASIC lab, you'll probably hear your friends from the FPGA lab keep talking about LUTs, right? So that's basically this lookup table.
Với các bạn trong phòng thí nghiệm ASIC, có lẽ các bạn sẽ nghe bạn bè bên phòng thí nghiệm FPGA cứ nhắc đến LUT mãi, đúng không? Về cơ bản đó chính là bảng tra cứu (lookup table).
It's very similar to the truth table we'll see in a minute. We also want to support sequential logic, right?
Nó rất giống với bảng chân trị mà một lát nữa chúng ta sẽ thấy. Chúng ta cũng muốn hỗ trợ logic tuần tự, đúng không?
So we do have flip-flops there so that we can also store actually sequential logic, that is, actually clock-triggered elements. We also mentioned we have our muxes, right?
Vì vậy ở đó có các flip-flop để chúng ta cũng có thể lưu trữ logic tuần tự, tức là các phần tử được kích bởi xung clock. Chúng ta cũng đã nhắc đến các mux, đúng không?
So that actually selects which output that we want to use. So in this particular scenario, we can actually select either the combinational output or the sequential output after the register.
Chúng chọn ra đầu ra mà chúng ta muốn dùng. Như vậy, trong trường hợp này, chúng ta có thể chọn đầu ra tổ hợp hoặc đầu ra tuần tự sau thanh ghi.
And whenever we have muxes, we need to configure the mux to actually figure out what we want to do, right? We need to have the latches that we mentioned earlier to store the configuration.
Và bất cứ khi nào có mux, chúng ta cần cấu hình mux để xác định xem chúng ta muốn làm gì, đúng không? Chúng ta cần các latch mà chúng ta đã nhắc trước đó để lưu cấu hình.
This is basically where your bitstream goes, right? Your bitstream basically goes to actually select which outputs you want to function for this circuit.
Đây chính là nơi bitstream của bạn đi vào, đúng không? Bitstream của bạn đi vào để chọn đầu ra nào bạn muốn cho mạch này hoạt động.
So we'll zoom in a little bit on the different components and how we build all the different slices using those small building blocks. So first, the lookup table, our LUTs, right?
Bây giờ ta sẽ phóng to một chút vào các thành phần khác nhau và cách chúng ta xây dựng các slice từ những khối cơ bản nhỏ này. Đầu tiên là bảng tra cứu, tức LUT, đúng không?
So this is basically the key building block in an FPGA. It's actually very intuitive. It literally means that we implement the truth table in our hardware, right?
Đây chính là khối cơ bản then chốt trong một FPGA. Nó thực ra rất trực quan. Nghĩa là chúng ta cài đặt bảng chân trị ngay trong phần cứng, đúng không?
So we mentioned that with a truth table, you can basically represent any logic, right? Specify the input, we get the output, right? So that's basically the truth table.
Chúng ta đã nói rằng với một bảng chân trị, bạn có thể biểu diễn bất kỳ logic nào, đúng không? Cho đầu vào thì ta có đầu ra, đúng không? Đó chính là bảng chân trị.
And the idea of the FPGA is very intuitive. If that's the way we like to represent digital logic, right, why don't we just implement the truth table in our FPGA, right?
Và ý tưởng của FPGA rất trực quan. Nếu đó là cách chúng ta thích dùng để biểu diễn logic số, thì tại sao không cài đặt luôn bảng chân trị trong FPGA, đúng không?
So that's basically the idea, right? So we mentioned we actually want to configure all the different latches. It's basically setting up the different entries of your truth table, and then by having different inputs.
Đó chính là ý tưởng. Chúng ta đã nói là muốn cấu hình tất cả các latch khác nhau. Về cơ bản là thiết lập các mục khác nhau của bảng chân trị, rồi sau đó có các đầu vào khác nhau.
And then remember the key building block that we have: the muxes, right? We can select the appropriate output based on the input combination, right? The mux, the truth table is pretty expensive, right?
Và hãy nhớ khối cơ bản mà chúng ta có: các mux, đúng không? Chúng ta có thể chọn đầu ra phù hợp dựa trên tổ hợp đầu vào, đúng không? Mux, bảng chân trị này khá tốn kém, đúng không?
We already talked about, you will have n-bit input, right? We basically need to add 2 to the power of n, our number of entries, to store all the different combinations, right?
Chúng ta đã nói rồi, bạn sẽ có đầu vào n bit, đúng không? Về cơ bản chúng ta cần thêm 2 mũ n mục, tức số mục, để lưu tất cả các tổ hợp khác nhau, đúng không?
We'll see actually later, generally we don't build super big lookup tables. Like 4 to 8 are pretty common.
Sau này chúng ta sẽ thấy, nói chung ta không xây các bảng tra cứu quá lớn. Từ 4 đến 8 đầu vào là khá phổ biến.
Those are basically the mux that we can go, and after that we basically will do things hierarchically, right? Because this gets very expensive, it grows exponentially, right?
Đó là những mux mà chúng ta có thể dùng, và sau đó chúng ta sẽ làm theo kiểu phân cấp, đúng không? Vì cách này trở nên rất tốn kém, nó tăng theo hàm mũ, đúng không?
So this is basically a key building block, the lookup table, in our FPGA.
Vậy đây là một khối cơ bản then chốt trong FPGA của chúng ta: bảng tra cứu.
Generic logic. What do you mean, generic logic?
Logic tổng quát. Ý bạn là gì khi nói logic tổng quát?
It's different. So those are basically more about different fundamentals, but we'll actually talk about CMOS, like all the different two-input, three-input gates, the fundamental gates like AND, OR, AOI, all the different gates.
Nó khác. Vậy những cái đó chủ yếu nói về các nguyên lý nền tảng khác nhau, nhưng chúng ta sẽ nói về CMOS, như tất cả các cổng hai đầu vào, ba đầu vào khác nhau, các cổng cơ bản như AND, OR, AOI, tất cả các loại cổng.
So those are more architecture building blocks for CMOS. So that's actually, those gates are actually, or those transistors are designed specifically for those functions.
Đó là những khối kiến trúc cơ bản hơn của CMOS. Vậy những cổng này thực ra, hay đúng hơn là những transistor này, được thiết kế riêng cho các chức năng đó.
Whereas here in the lookup table, we never design an AND gate, we never design an OR gate. We always use the lookup table to define that functionality.
Trong khi ở đây, với bảng tra cứu, chúng ta không bao giờ thiết kế một cổng AND hay một cổng OR. Chúng ta luôn dùng bảng tra cứu để định nghĩa chức năng đó.
So that's the key difference between FPGA and ASIC. Yeah, so the ASIC building blocks are actually more 2 to 4. I think we at most get to 4.
Đó là điểm khác biệt chính giữa FPGA và ASIC. Vâng, các khối cơ bản của ASIC thường có từ 2 đến 4 đầu vào. Tôi nghĩ nhiều nhất là 4.
It's very rare to go beyond that. Still small input, but multi-input gates are the building blocks there. And then we get to technology specific.
Rất hiếm khi vượt quá mức đó. Số đầu vào vẫn nhỏ, nhưng các cổng nhiều đầu vào là khối cơ bản ở đó. Rồi chúng ta đến phần phụ thuộc vào công nghệ.
We'll talk about, even for an AND gate, there are many different ways of actually building this AND gate. So that all gets to the technology-specific part. This is unique to FPGA, where we're building.
Chúng ta sẽ nói rằng, ngay cả với một cổng AND, cũng có nhiều cách khác nhau để xây dựng cổng AND này. Tất cả những điều đó thuộc phần phụ thuộc vào công nghệ. Điều này là đặc thù của FPGA, nơi chúng ta xây dựng.
You also see the inefficiency, right? We spend a lot of area just to build this big table, but this is flexible. We can do a lot of things here.
Các bạn cũng thấy sự kém hiệu quả, đúng không? Chúng ta tốn rất nhiều diện tích chỉ để xây dựng bảng lớn này, nhưng nó linh hoạt. Chúng ta có thể làm được rất nhiều việc ở đây.
So exactly, so lookup table is basically a direct implementation of the truth table, but then it grows exponentially, right, with the number of inputs.
Đúng vậy, bảng tra cứu về cơ bản là sự triển khai trực tiếp của bảng chân trị, nhưng nó tăng theo hàm mũ, đúng không, theo số đầu vào.
So generally, we see 4 input to 8 input lookup table. That's pretty common, but then we rarely actually see beyond that. Just grows too big. It's really hard to do.
Nên thông thường ta thấy bảng tra cứu từ 4 đến 8 đầu vào. Như vậy là khá phổ biến, nhưng ta hiếm khi thấy vượt quá mức đó. Nó lớn quá. Thực sự rất khó làm.
We'll see that we actually do things hierarchically to actually support different functionalities.
Chúng ta sẽ thấy rằng ta làm theo cách phân cấp để hỗ trợ các chức năng khác nhau.
Some of the folks in the FPGA lab, especially first lab, when they send you a 200-page document and ask you to read, a lot of the terms, what's that?
Một số bạn trong phòng thí nghiệm FPGA, nhất là bài thí nghiệm đầu tiên, khi họ gửi cho các bạn một tài liệu 200 trang và yêu cầu đọc, rất nhiều thuật ngữ, cái đó là gì?
I remember that. You remember that. Yeah, that's a fun part. Always read the data sheet. But a lot of questions about all the different slices, right?
Tôi nhớ chuyện đó. Bạn nhớ chứ. Vâng, đó là phần thú vị. Luôn luôn đọc data sheet. Nhưng có nhiều câu hỏi về các slice khác nhau, đúng không?
So it may seem pretty confusing, especially early on, right, when you actually first approach the design.
Nên nó có thể khá khó hiểu, nhất là lúc đầu, khi các bạn mới tiếp cận thiết kế.
All of this seems pretty familiar to you, but I like to also put this way in a more organized way of thinking about slice.
Tất cả những điều này có vẻ khá quen thuộc với các bạn, nhưng tôi cũng muốn trình bày theo cách có tổ chức hơn để nghĩ về slice.
These are really just the terminology, especially design experience, to actually talk about the different hierarchy, how we can actually build up more components in a hierarchical fashion. So that's why they call slice, right?
Đây thực chất chỉ là thuật ngữ, nhất là trong kinh nghiệm thiết kế, để nói về các cấp bậc khác nhau, về cách ta xây dựng thêm nhiều thành phần theo kiểu phân cấp. Vì vậy người ta gọi là slice, đúng không?
So you can basically think about slices are basically cooking, like remember the lookup table, muxes, flip-flops that we have seen before.
Các bạn có thể hình dung slice về cơ bản là một nhóm, nhớ lại bảng tra cứu, mux, flip-flop mà chúng ta đã thấy trước đây.
So it's basically a way to organize all the different lookup tables and flip-flops instead of just have a CL lookup table and flip-flops.
Về cơ bản đó là cách tổ chức tất cả các bảng tra cứu và flip-flop khác nhau, thay vì chỉ có một bảng tra cứu CL và các flip-flop.
We have this hierarchy so that we can talk about how we map things eventually into the hardware. Generally, we have two types of slices. The key differences is whether it has memory or not.
Chúng ta có cấp bậc này để có thể nói về cách chúng ta ánh xạ các thứ vào phần cứng. Nhìn chung, chúng ta có hai loại slice. Điểm khác biệt chính là nó có bộ nhớ hay không.
Slice L just do the logic. Slice M also have distributed RAM so that you can also implement buffers there, memory shift registers.
Slice L chỉ làm phần logic. Slice M còn có RAM phân tán nên bạn cũng có thể cài đặt các bộ đệm ở đó, các thanh ghi dịch bằng bộ nhớ.
So you have some buffers, small files, you can use slice M with memory, while logic slice L is basically only have lookup tables, muxes, and flip-flops, right?
Vậy nếu bạn có một số bộ đệm, các tệp nhỏ, bạn có thể dùng slice M có bộ nhớ, còn slice L logic về cơ bản chỉ có các bảng tra cứu, bộ dồn kênh, và flip-flop, đúng không?
So that's really the key differences, Whether the memory, the distributed RAM, is pretty handy. You have some small buffers. Generally, they do asynchronous read, so you can read combinationally, but synchronous write, right?
Đó thực sự là điểm khác biệt chính, có bộ nhớ hay không; RAM phân tán khá tiện. Bạn có một số bộ đệm nhỏ. Thông thường, chúng đọc không đồng bộ, nên bạn có thể đọc theo kiểu tổ hợp, nhưng ghi đồng bộ, đúng không?
So there's still clocks there to write the data. So the memory is pretty handy with slice M. We'll also talk about bigger memory. Those are small distributed memory in slice M.
Vậy vẫn có xung clock ở đó để ghi dữ liệu. Vậy bộ nhớ ở slice M khá tiện. Chúng ta cũng sẽ nói về bộ nhớ lớn hơn. Đó là những bộ nhớ phân tán nhỏ trong slice M.
We'll talk about block RAM later. Those are much bigger memory we can also use on today's FPGAs. Versus slice L, it's just we're doing logic only. That's really the key difference.
Chúng ta sẽ nói về block RAM sau. Đó là những bộ nhớ lớn hơn nhiều mà chúng ta cũng có thể dùng trên các FPGA ngày nay. Còn slice L thì chỉ làm logic mà thôi. Đó thực sự là điểm khác biệt chính.
You will zoom in to those slides. These are basically doing hierarchical lookup table or hierarchical LUTs organization here. Specifically, generally, we start with five inputs.
Bạn sẽ phóng to vào những slide này. Những cái này về cơ bản là tổ chức bảng tra cứu phân cấp, hay LUT phân cấp, ở đây. Cụ thể, nhìn chung chúng ta bắt đầu với năm đầu vào.
So this is basically a five-input lookup table. We have five different inputs, and then we have, for each input, a corresponding output, right? So then we can use this, configure this.
Vậy đây là một bảng tra cứu năm đầu vào. Chúng ta có năm đầu vào khác nhau, và với mỗi tổ hợp đầu vào, chúng ta có một đầu ra tương ứng, đúng không? Rồi chúng ta có thể dùng và cấu hình cái này.
We mentioned the earlier truth table can represent any functionality, right? So instead of using a Boolean expression to express the circuit functionality, circuit behavior, right?
Ở trên chúng ta đã nói bảng chân trị có thể biểu diễn bất kỳ chức năng nào, đúng không? Thay vì dùng biểu thức Boolean để diễn tả chức năng của mạch, hành vi của mạch, đúng không?
We just have a dump of a big table there. Seems to be a dumb idea, but this works pretty well, right? 40 years later, this is still the key component of our hardware industry.
Chúng ta chỉ đổ ra một bảng lớn ở đó. Nghe có vẻ là ý tưởng ngớ ngẩn, nhưng nó hoạt động khá tốt, đúng không? 40 năm sau, đây vẫn là thành phần chủ chốt của ngành công nghiệp phần cứng.
Very straightforward, right? So then we'll talk about MUXes. Before, timing is independent of the functionality, right? No matter what the functionality that we're designing, we're basically reading the data from our lookup table, right?
Rất đơn giản, đúng không? Tiếp theo chúng ta sẽ nói về các bộ dồn kênh. Trước đó, thời gian không phụ thuộc vào chức năng, đúng không? Dù chúng ta đang thiết kế chức năng nào, về cơ bản chúng ta đều đọc dữ liệu từ bảng tra cứu, đúng không?
So no matter the complexity of functionality, the timing is independent, which is different from ASIC, right? So some Boolean expressions are longer, more complex, some are actually easier, right?
Nên dù chức năng phức tạp đến đâu, thời gian vẫn độc lập, khác với ASIC, đúng không? Có những biểu thức Boolean dài hơn, phức tạp hơn, có những biểu thức thực ra dễ hơn, đúng không?
And then we set those configuration, the different input-output combinations, during the configuration time. Those are basically part of your bitstream, right? That are really programmed to specify the functionality of our lookup table.
Và sau đó chúng ta đặt các cấu hình đó, các tổ hợp đầu vào-đầu ra khác nhau, trong thời gian cấu hình. Đó về cơ bản là một phần của bitstream, đúng không? Được lập trình để xác định chức năng của bảng tra cứu.
Again, generally, we do things hierarchically, right? We talk about five-input, we want to do six-input, right?
Một lần nữa, nhìn chung chúng ta làm theo kiểu phân cấp, đúng không? Chúng ta nói về năm đầu vào, giờ muốn làm sáu đầu vào, đúng không?
Instead of building another six-input lookup table, we basically combine two five-input lookup tables.
Thay vì xây dựng thêm một bảng tra cứu sáu đầu vào, chúng ta kết hợp hai bảng tra cứu năm đầu vào.
Again, whenever there is a condition, there are differences, we have a MUX there to handle those conditions, right?
Một lần nữa, bất cứ khi nào có một điều kiện, có những khác biệt, chúng ta đặt một MUX ở đó để xử lý các điều kiện đó, đúng không?
So with this, we can either give a six input and one output, we can get a one output, treat this as six input MUXes, though, or we can still do this as the two five input lookup tables, right?
Như vậy, chúng ta có thể đưa vào sáu đầu vào và nhận một đầu ra, tức là ta có một đầu ra, coi đây như các MUX sáu đầu vào, hoặc vẫn có thể dùng nó như hai bảng tra cứu năm đầu vào, đúng không?
So there are some flexibilities in terms of supporting both five input or a single six input.
Vậy là có một chút linh hoạt trong việc hỗ trợ cả năm đầu vào hoặc một bảng sáu đầu vào duy nhất.
How do we...
Làm thế nào để chúng ta...
Yeah, so like each of the last five is actually configured differently, right? So you still need to configure each of the last, basically the inputs there.
Vâng, mỗi đầu vào trong năm đầu vào cuối thực ra được cấu hình khác nhau, đúng không? Vậy bạn vẫn cần cấu hình từng đầu vào cuối đó.
Right, so I guess we don't have, we'll talk a little bit, if you, it's harder to see now, but you actually look at some of the old FPGAs, pretty cool.
Đúng rồi, tôi nghĩ là chúng ta chưa có, chúng ta sẽ nói một chút, bây giờ khó thấy hơn, nhưng nếu bạn nhìn vào một số FPGA đời cũ thì khá thú vị.
You can actually see the bitstream and then goes through your FPGA die vertically, and then those bitstreams basically go to different parts of FPGA to configure there. So that's how you load your bitstreams.
Bạn thực sự có thể thấy bitstream đi xuyên qua die FPGA theo chiều dọc, và các bitstream đó đi đến các phần khác nhau của FPGA để cấu hình ở đó. Đó là cách bạn nạp bitstream.
The bitstreams basically configure the, consist of the address, which lookup table that we're configuring, and the value we're writing, right? So they basically load the bitstream.
Bitstream dùng để cấu hình, gồm có địa chỉ, cho biết bảng tra cứu nào đang được cấu hình, và giá trị chúng ta ghi vào, đúng không? Vậy là chúng nạp bitstream.
Generally, they have a vertical chain because you want to write all the different lookup tables. Then before you use FPGA, you actually program that first.
Thông thường, chúng có một chuỗi dọc vì bạn muốn ghi vào tất cả các bảng tra cứu khác nhau. Sau đó, trước khi dùng FPGA, bạn phải lập trình nó trước.
So there is a explicit programming phase of the FPGA. A lot of people, it's less popular now. I remember when I was in college, it was very popular of doing fast FPGA reprogramming.
Vì vậy có một giai đoạn lập trình rõ ràng cho FPGA. Nhiều người, giờ thì nó ít phổ biến hơn. Tôi nhớ khi tôi còn học đại học, việc lập trình lại FPGA nhanh rất phổ biến.
So that's writing FPGA program is the same like writing like another Python or C program on your processor.
Viết chương trình cho FPGA cũng giống như viết một chương trình Python hay C khác trên bộ xử lý của bạn.
You can quickly reprogram it for different functionality, but then still bounded by this reprogramming speed, right? It takes time to actually load all the bitstream to that FPGA.
Bạn có thể nhanh chóng lập trình lại để có chức năng khác, nhưng vẫn bị giới hạn bởi tốc độ lập trình lại này, đúng không? Cần thời gian để nạp toàn bộ bitstream vào FPGA đó.
Yeah, so there is an explicit reprogramming steps there. Omar? So if you want to have two or five people on your team, Those two people will have the same lookup table, right?
Vâng, vậy có các bước lập trình lại rõ ràng ở đó. Omar? Nếu bạn muốn có hai hoặc năm người trong nhóm, hai người đó sẽ có cùng một bảng tra cứu, đúng không?
Because they are on the same slides. Why do they have the same table? Because they have the same input, right?
Vì họ ở cùng một slice. Tại sao họ có cùng bảng? Vì họ có cùng đầu vào, đúng không?
Or you can do it the way it sits.
Hoặc bạn có thể làm theo cách nó đang đặt.
We want to listen to them, but they will not have the same output. Because basically, imagine like a six input circuit.
Chúng ta muốn lắng nghe họ, nhưng họ sẽ không có cùng đầu ra. Vì hãy hình dung một mạch sáu đầu vào.
And we want to create, basically what you're doing is, six is, you're isolating five of those six inputs. And then calculating what, and then you do two calculations.
Và chúng ta muốn tạo, về cơ bản việc bạn làm là, đầu vào thứ sáu, bạn tách riêng năm trong sáu đầu vào đó. Rồi tính toán, và bạn thực hiện hai phép tính.
Calculate what the input is given your five. So calculate what the output is given your input and your six is zero. And then do it again, give your input.
Tính xem đầu vào là gì khi cho năm đầu vào của bạn. Tức là tính đầu ra khi cho đầu vào của bạn và đầu vào thứ sáu bằng không. Rồi làm lại một lần nữa, với đầu vào của bạn.
And so you have those two single outputs. Right, so what Ben just described is that each of the five input nodes can actually work independently, right?
Và như vậy bạn có hai đầu ra đơn lẻ đó. Đúng rồi, vậy điều Ben vừa mô tả là mỗi nút trong năm nút đầu vào thực ra có thể hoạt động độc lập, đúng không?
They don't need to work the same. I think, Omar, you're also asking something slightly different, in the sense that how they are connected or how they can actually behave differently.
Chúng không cần hoạt động giống nhau. Omar, tôi nghĩ bạn cũng đang hỏi một điều hơi khác, theo nghĩa là chúng được kết nối với nhau như thế nào hoặc làm sao chúng có thể hoạt động khác nhau.
We go back, the inputs are actually selection signals of the muxes, right?
Quay lại, các đầu vào thực ra là tín hiệu chọn của các mux, đúng không?
So the table, the value actually stored in the lookup table is configured during the programming time, where we write all the, you can imagine basically treated as the lookup table is pre-populated during the programming time, and during run time the inputs are used to select the muxes.
Vậy bảng, giá trị thực sự được lưu trong bảng tra cứu được cấu hình trong lúc lập trình, khi chúng ta ghi tất cả các, bạn có thể hình dung là bảng tra cứu được xem như được điền sẵn trong lúc lập trình, và trong lúc chạy, các đầu vào được dùng để chọn các mux.
So you can populate the table differently. So the input is the same but the output is different, because each, they have different values.
Vì vậy bạn có thể điền bảng theo cách khác nhau. Nên đầu vào giống nhau nhưng đầu ra khác nhau, vì mỗi bảng có các giá trị khác nhau.
Exactly, so I guess this, this is how this is implemented, right? All of those signals actually come to the mux to do the selection.
Chính xác, tôi nghĩ đây là cách nó được triển khai, đúng không? Tất cả các tín hiệu đó đều đi đến mux để thực hiện việc chọn.
But each of the entry, the choose table, is actually populated differently. Quick question, remember? Yeah, I guess it's a little down for people to say, well, I think it can be programmable.
Nhưng mỗi mục trong bảng chọn thực ra được điền khác nhau. Một câu hỏi nhanh, nhớ không? Vâng, tôi đoán là hơi khó để mọi người nói rằng, à, tôi nghĩ nó có thể lập trình được.
Because if we pay power, the end date, save the end date forever, There is literally nothing that can be configured to compute for the fixed amount.
Vì nếu cấp điện, cổng AND, lưu cổng AND mãi mãi, thì thực sự không có gì có thể được cấu hình để tính toán cho một lượng cố định.
So, but the full FPGA is so in the LUT, right? That the fact that it's changing what we want to make out of FPGAs.
Nhưng toàn bộ FPGA là như vậy trong LUT, đúng không? Việc nó thay đổi chính là điều chúng ta muốn tạo ra từ FPGA.
So that means every time we program, the underneath chemical material changes, right? Like the configuration. It's literally different after every time. And how can, how can it be different?
Vậy nghĩa là mỗi lần chúng ta lập trình, vật liệu hóa học bên dưới thay đổi, đúng không? Như cấu hình vậy. Mỗi lần nó thực sự khác đi. Và làm sao nó có thể khác được?
It's just like, you put a signal in, like sending all this to the computer. They must be different. It's not that magical.
Giống như bạn đưa một tín hiệu vào, như gửi tất cả cái này đến máy tính. Chúng chắc chắn phải khác nhau. Nó không kỳ diệu đến thế.
There's not, you treat it in a very fancy way. It's a very slow process. You can basically treat it as you have the SRAM, you have the memory we talked about earlier.
Không phải bạn xử lý nó theo cách cầu kỳ. Đó là một quá trình rất chậm. Về cơ bản bạn có thể xem như bạn có SRAM, bộ nhớ mà chúng ta đã nói trước đó.
We need to write every address of the memory. That's what's happening at the configuration time. It's not like, oh, I send the one signal.
Chúng ta cần ghi vào mọi địa chỉ của bộ nhớ. Đó là điều xảy ra ở thời điểm cấu hình.
Oh, all of a sudden my FPGA just changed. It takes time. You actually write one bit at a time, write every bit of your FPGA to perform a different functionality.
Không phải kiểu, ồ, tôi gửi một tín hiệu, và đột nhiên FPGA của tôi thay đổi. Nó cần thời gian. Thực ra bạn ghi từng bit một, ghi mọi bit của FPGA để nó thực hiện một chức năng khác.
So it sounds like every time you're trying to convert a logic, it's almost like a three address and then like load word, that kind of thing? You can think about it.
Vậy nghe như mỗi lần bạn cố chuyển đổi một logic, nó gần giống như mã ba địa chỉ rồi load word, kiểu như vậy phải không? Bạn có thể nghĩ như vậy.
So basically a lot, like I mentioned, like we're loading a lot of bits into the, into the truth table, right? We're putting a lot of memory updating basically.
Về cơ bản là rất nhiều, như tôi đã đề cập, chúng ta đang nạp rất nhiều bit vào bảng chân trị, đúng không? Về cơ bản là chúng ta đang thực hiện rất nhiều thao tác cập nhật bộ nhớ.
It's, yeah, it's pretty, it's pretty impressive. It works, but it's not that magic. Just all of a sudden everything changed. There's a slow process. Last question, Benton.
Vâng, nó khá là ấn tượng. Nó hoạt động được, nhưng không phải phép màu gì cả, đâu phải tự nhiên mọi thứ thay đổi hết. Đó là một quá trình chậm. Câu hỏi cuối cùng, Benton.
I'm aware of the notion that on the chip, you have sort of two of the speeds.
Em biết là trên chip có hai kiểu tốc độ.
You have one that allows you to overwrite the latches and one that allows you to overwrite the inputs.
Một kiểu cho phép ghi đè các latch và một kiểu cho phép ghi đè các đầu vào.
And the one that allows you to overwrite the latches changes the actual, it actually allows you to configure the FPGA, but that actual writing process is much slower.
Kiểu cho phép ghi đè các latch thì thay đổi phần thực sự, nó cho phép cấu hình FPGA, nhưng quá trình ghi đó chậm hơn nhiều.
Whereas with the screen for the inputs, that is a lot quicker. But it's basically an execute now. Exactly.
Còn với kiểu dành cho các đầu vào thì nhanh hơn rất nhiều. Nhưng về cơ bản nó là thực thi ngay lập tức. Chính xác.
That's a good way to think about it. You can also think about it.
Đó là một cách nghĩ hay. Em cũng có thể nghĩ theo cách này.
This is basically a compilation process versus the execution process, the compilation process where we're writing and updating all the lookup tables, basically whatever, whenever you compile a GCC, that's what happened.
Về cơ bản đây là quá trình biên dịch so với quá trình thực thi, quá trình biên dịch là lúc chúng ta ghi và cập nhật tất cả các bảng tra cứu, cũng như mỗi khi em biên dịch bằng GCC, đó chính là điều xảy ra.
And the execution process is where you actually do the trigger, the executable, where it's actually executed. But there is a compilation process to actually populate all those bits.
Còn quá trình thực thi là lúc em thực sự kích hoạt tệp thực thi, tức là nó thực sự được chạy. Nhưng có một quá trình biên dịch để điền tất cả các bit đó.
Yeah, it's pretty interesting how this thing works. That's the penalty, or that's the overhead of flexibility, where we do a lot of configuration, right?
Vâng, cách nó hoạt động khá thú vị. Đó là cái giá phải trả, hay chi phí phụ của tính linh hoạt, khi chúng ta phải cấu hình rất nhiều, đúng không?
So this is six inputs. We can actually keep building this up. I'll stay a little bit longer here.
Vậy đây là sáu đầu vào. Chúng ta có thể tiếp tục xây dựng thêm. Tôi sẽ nói thêm một chút ở đây.
So this is actually basically a basic, the simplest view of thinking about the slice, where we have lookup tables. We have, we also have flip-flops, right? We also can also get registered output, right?
Đây thực chất là cách nhìn cơ bản, đơn giản nhất về slice, trong đó chúng ta có các bảng tra cứu. Chúng ta cũng có các flip-flop, đúng không? Chúng ta cũng có thể lấy đầu ra qua thanh ghi, đúng không?
So we can either get a combinational output, we can also get a registered output, right? So far we'll only get to the six inputs, right? Let's keep building this up, right?
Vậy chúng ta có thể lấy đầu ra tổ hợp, hoặc cũng có thể lấy đầu ra qua thanh ghi, đúng không? Cho đến giờ chúng ta mới chỉ có sáu đầu vào, đúng không? Hãy tiếp tục xây dựng thêm nhé?
What if we have more complex functionalities? So this is how we convert our baseline slice to support seven inputs.
Nếu chúng ta cần chức năng phức tạp hơn thì sao? Đây là cách chuyển slice cơ sở của chúng ta để hỗ trợ bảy đầu vào.
There's nothing magic here, just keep adding muxes. All the tricks with FPGA, a lot more muxes, right?
Không có gì kỳ diệu cả, chỉ cần thêm các mux. Mọi mánh của FPGA là thêm thật nhiều mux, đúng không?
So now we can actually combine two six input FPGA a lot to actually support seven input. So then we can actually get two seven output muxes, two outputs.
Vậy bây giờ chúng ta có thể kết hợp hai bảng tra cứu sáu đầu vào của FPGA lại để hỗ trợ bảy đầu vào. Như vậy chúng ta có thể có hai mux đầu ra bảy đầu vào, tức hai đầu ra.
Well, we'll still have the actual, whenever we do this, we're basically keep adding muxes and also to support more inputs, right?
Mỗi khi làm như thế này, về cơ bản chúng ta cứ thêm mux để hỗ trợ nhiều đầu vào hơn, đúng không?
So instead of getting four six input output lookup table, we now get two, basically using the six input lookup table, but behaves like a seven input lookup table.
Thay vì có bốn bảng tra cứu sáu đầu vào, giờ chúng ta có hai, về cơ bản dùng bảng tra cứu sáu đầu vào, nhưng hoạt động như bảng tra cứu bảy đầu vào.
And then we keep doing this, we can further combine this by adding another mux, right? So then we can actually get the seven, eight input lookup table.
Rồi chúng ta tiếp tục làm như vậy, có thể kết hợp thêm nữa bằng cách thêm một mux khác, đúng không? Như vậy chúng ta có thể có bảng tra cứu tám đầu vào.
Again, we have combinational input and we can also get register input, right? We add another mux, so we add another input, right? So whenever we add input, we add mux.
Một lần nữa, chúng ta có đầu ra tổ hợp và cũng có thể lấy đầu ra qua thanh ghi, đúng không? Thêm một mux nữa thì thêm được một đầu vào nữa, đúng không? Vậy nên mỗi khi thêm một đầu vào, chúng ta thêm một mux.
That's basically the process of building up the slice. Again, well, you will actually bring back all the different muxes. We basically want to support either direct five, six, seven inputs or more combined.
Về cơ bản đó là quá trình xây dựng nên slice. Một lần nữa, ta sẽ đưa trở lại tất cả các mux khác nhau. Về cơ bản, ta muốn hỗ trợ trực tiếp năm, sáu, bảy đầu vào hoặc nhiều hơn khi kết hợp lại.
So we bring everything back and also adding our registers, right? So this is actually more represented.
Vậy ta đưa mọi thứ trở lại và thêm cả các thanh ghi, đúng không? Như vậy hình này biểu diễn đầy đủ hơn.
It's a little bit hard to see with everything there, but all we do is basically gradually adding muxes so that we can also support all the different input here.
Hơi khó nhìn khi có mọi thứ ở đó, nhưng tất cả những gì ta làm chỉ là dần dần thêm các mux để cũng có thể hỗ trợ tất cả các đầu vào khác nhau ở đây.
One more thing, actual logic that also exists in slice, even this pretty basic FPGA operation, they already have some hardened logic. One of the hardened logic is basically the ripple carry chain.
Còn một điều nữa, là logic thực sự cũng có mặt trong slice, ngay cả với hoạt động FPGA khá cơ bản này, họ đã có một số logic cứng hóa. Một trong những logic cứng hóa đó chính là chuỗi nhớ ripple carry.
We already briefly talked about adder. We'll also come back to adder later this semester, right?
Chúng ta đã nói sơ qua về bộ cộng. Chúng ta cũng sẽ quay lại bộ cộng sau trong học kỳ này, đúng không?
So whenever we do addition, right, we need to have the carry need to actually ripple through our computation chain. This is so common. We see this a lot.
Vậy mỗi khi thực hiện phép cộng, ta cần có số nhớ phải lan truyền qua chuỗi tính toán của chúng ta. Điều này rất phổ biến. Chúng ta thấy nó rất nhiều.
Addition is one of the basic operators there. So FPGA also decide, oh, this is so important, so common. Keep using all the different lookup table, it's so inefficient in designing this.
Phép cộng là một trong những toán tử cơ bản. Nên FPGA cũng quyết định rằng cái này quan trọng và phổ biến như vậy. Cứ dùng các bảng tra cứu khác nhau thì thiết kế việc này rất kém hiệu quả.
So they end up adding a dedicated ripple carry chain to actually support this functionality, right? So there's already some hardened logic because this is a very commonly used building block.
Vì thế cuối cùng họ thêm một chuỗi ripple carry chuyên dụng để hỗ trợ chức năng này, đúng không? Như vậy đã có một số logic cứng hóa vì đây là một khối xây dựng được dùng rất thường xuyên.
We'll see a little bit more, there are more hardened logic in FPGA these days, but even early on the carry chain, because it's so fundamental, it's also part of today's, just a basic building block of today's slice.
Chúng ta sẽ thấy thêm, ngày nay FPGA có nhiều logic cứng hóa hơn, nhưng ngay từ đầu đã có chuỗi carry, vì nó quá cơ bản, nó cũng là một phần của slice ngày nay, chỉ là một khối xây dựng cơ bản của slice ngày nay.
So putting all of this together, this is basically our slice L.
Vậy gộp tất cả những thứ này lại, về cơ bản đây là slice L của chúng ta.
We have hierarchical lookup tables, all the different muxes, so that we can select the different inputs, and we also have all the different registers.
Chúng ta có các bảng tra cứu phân cấp, tất cả các mux khác nhau, để có thể chọn các đầu vào khác nhau, và chúng ta cũng có tất cả các thanh ghi khác nhau.
So we can store either registered, sequential output or combinational output. We also have this hardened logic to actually, to do the carry chain propagation. So that's basically how a logic slice works.
Nhờ vậy ta có thể lưu đầu ra có thanh ghi, tuần tự, hoặc đầu ra tổ hợp. Chúng ta cũng có logic cứng hóa này để thực hiện lan truyền nhớ trong chuỗi carry. Đó chính là cách một logic slice hoạt động.
We already mentioned slice memory, very much similar, slice M, but it has distributed RAM so that we can do asynchronous read, synchronous write, like pretty small.
Chúng ta đã nhắc đến slice bộ nhớ, rất giống, là slice M, nhưng nó có RAM phân tán để ta có thể đọc không đồng bộ, ghi đồng bộ, và khá nhỏ.
We have shift registers or buffers, we can use slice M to do some actual storage. So that's basically the key building blocks of FPGAs, all the different slices.
Chúng ta có các thanh ghi dịch hoặc bộ đệm, có thể dùng slice M để lưu trữ thực sự. Vậy về cơ bản đó là các khối xây dựng chính của FPGA, tất cả các loại slice.
Let's see.
Để xem nào.
50% of the slices, or the total slices on FPGA. So slice L is pretty common, and the slice M, oh, just roughly half and half.
50% các slice, hay tổng số slice trên FPGA. Slice L khá phổ biến, còn slice M thì, ừ, khoảng một nửa một nửa.
We see, like, different FPGAs, these are just general patterns, but different FPGAs will also structure things, they also tailor things differently, but both of them are pretty common and commonly used in today's designs.
Chúng ta thấy các FPGA khác nhau, đây chỉ là những mẫu chung, nhưng các FPGA khác nhau cũng sẽ cấu trúc khác nhau, họ cũng điều chỉnh khác nhau, nhưng cả hai đều khá phổ biến và được dùng thường xuyên trong các thiết kế ngày nay.
So, some announcements.
Giờ là một số thông báo.
Many of you have, we had a long discussion this week in staff meeting, and what we realized is that, at least from what we observed, what took a lot of your time in doing lab 3 and lab 4 is actually understanding how the DAC and the NCO, we've generated all those different things, work.
Nhiều bạn trong số các bạn, tuần này chúng tôi đã có một cuộc thảo luận dài trong buổi họp nhóm giảng viên, và điều chúng tôi nhận ra là, ít nhất theo những gì quan sát được, phần tốn nhiều thời gian nhất của các bạn khi làm lab 3 và lab 4 thực ra là hiểu DAC và NCO, tất cả những thứ mà chúng ta đã tạo ra, hoạt động như thế nào.
We designed the lab, there's a little bit of history so you understand where we are coming from.
Chúng tôi đã thiết kế bài lab, có một chút bối cảnh để các bạn hiểu chúng tôi xuất phát từ đâu.
We designed the lab, especially the FPGA lab, in a sense that to help you to see how hardware can be designed or can be used to support different functionalities, and can also put together a lot of your prior experience, like different concepts you learn in different classes, actually in building up a pretty complex project, right?
Chúng tôi thiết kế bài lab, đặc biệt là lab FPGA, theo hướng giúp các bạn thấy phần cứng có thể được thiết kế hoặc sử dụng để hỗ trợ các chức năng khác nhau như thế nào, đồng thời kết hợp nhiều kinh nghiệm trước đây của các bạn, như những khái niệm khác nhau các bạn học ở các lớp khác nhau, để xây dựng một dự án khá phức tạp, đúng không?
So we definitely have some assumptions about 16B experience, And maybe also a little bit signal processing experience so that we can actually put together a cool project that you can interact with FPGA.
Vì vậy chúng tôi chắc chắn có một số giả định về kinh nghiệm từ môn 16B, và có thể cả một chút kinh nghiệm về xử lý tín hiệu, để có thể kết hợp lại thành một dự án thú vị mà các bạn có thể tương tác với FPGA.
But we also realized, again, first, not everyone has that background; those are not required, again.
Nhưng chúng tôi cũng nhận ra rằng, một lần nữa, trước hết, không phải ai cũng có nền tảng đó; những thứ đó không bắt buộc.
And even for students who have that background, and also for staff who have that background, it actually took a while to understand it.
Và ngay cả với những sinh viên có nền tảng đó, và cả với các thành viên trong nhóm giảng viên có nền tảng đó, cũng mất một lúc mới hiểu được.
So we decided to put together some walkthrough videos so that you can see how that works, that are actually independent from your hardware implementations.
Vì vậy chúng tôi quyết định làm một số video hướng dẫn chi tiết để các bạn thấy nó hoạt động ra sao, và những video này độc lập với phần hiện thực phần cứng của các bạn.
So for folks who haven't, especially for folks who haven't started or are still in the process of doing lab 3 or, more likely, lab 4, definitely take a look at those videos.
Vậy với những bạn chưa, đặc biệt là những bạn chưa bắt đầu hoặc vẫn đang làm lab 3 hoặc, nhiều khả năng hơn, lab 4, nhất định hãy xem những video này.
That will actually help you to clarify, especially, some conceptual misunderstandings about how those things work before you actually turn to hardware implementation, right?
Chúng sẽ giúp các bạn làm rõ, đặc biệt là một số hiểu lầm về mặt khái niệm về cách những thứ này hoạt động trước khi các bạn chuyển sang hiện thực phần cứng, đúng không?
We want to make sure you are prepared, so take a look at the videos. Our staff literally can produce those videos like overnight.
Chúng tôi muốn đảm bảo các bạn đã chuẩn bị tốt, nên hãy xem các video. Nhóm giảng viên có thể làm những video này gần như chỉ trong một đêm.
They work pretty hard, work really hard, and want to help you as much as possible, so definitely let them know if you have any feedback, whether that's helpful, that contributes to your understanding, makes it easier for you to approach the lab, right?
Họ làm việc rất chăm chỉ, thực sự rất chăm chỉ, và muốn giúp các bạn hết mức có thể, nên hãy cho họ biết nếu các bạn có phản hồi nào, ví dụ video có hữu ích không, có góp phần giúp các bạn hiểu bài không, có giúp các bạn tiếp cận bài lab dễ hơn không, đúng không?
Give them some feedback. We really appreciate that. And I'll have a homework for you this week to wrap it up.
Hãy cho họ phản hồi. Chúng tôi thực sự trân trọng điều đó. Và tuần này tôi sẽ có một bài tập về nhà cho các bạn để kết thúc phần này.
We'll have a short homework on pipelining, not having FPGA or ASIC logic, just on pipelining, coming up this week. Should be a short one.
Sẽ có một bài tập về nhà ngắn về pipelining, không có logic FPGA hay ASIC, chỉ về pipelining, sẽ ra trong tuần này. Sẽ là một bài ngắn.
You should be able to start now because we'll have a guest lecture coming up, right? So no new content here. Any questions?
Các bạn có thể bắt đầu ngay bây giờ vì sắp tới sẽ có một bài giảng của khách mời, đúng không? Vậy nên không có nội dung mới ở đây. Có câu hỏi nào không?
Okay, so we talked about, we spent a lot of time on the logic. I do want to briefly mention another part of the reconfiguration is interconnect, right?
Được rồi, vậy chúng ta đã nói về, đã dành rất nhiều thời gian cho phần logic. Tôi muốn nói ngắn gọn về một phần khác của khả năng cấu hình lại, đó là kết nối liên thông, đúng không?
We talked about all the different devices, right? But then they eventually will be connected to different parts, different arrays on the FPGA substrate, right?
Chúng ta đã nói về tất cả các thiết bị khác nhau, đúng không? Nhưng cuối cùng chúng sẽ được kết nối với các phần khác nhau, các mảng khác nhau trên nền FPGA, đúng không?
So another part, we talked about the bitstream programming to program the lookup table. Another part of programming is actually to program whether certain components are connected or not.
Vậy một phần khác, chúng ta đã nói về việc lập trình bitstream để lập trình bảng tra cứu (lookup table). Một phần khác của việc lập trình thực ra là lập trình xem một số thành phần có được kết nối với nhau hay không.
So all the interconnect in our FPGA is also reconfigurable. Again, you'll see this cross-coupled inverter again whenever you see a paired inverter.
Vì vậy, toàn bộ mạng kết nối (interconnect) trong FPGA của chúng ta cũng có thể cấu hình lại được. Một lần nữa, các bạn sẽ thấy cặp inverter mắc chéo này mỗi khi các bạn thấy một cặp inverter.
We'll discuss this in more detail in a few months, more likely, right? But you'll see this a lot whenever you see a pair of inverters. We're doing some storage.
Chúng ta sẽ bàn chi tiết hơn về điều này trong vài tháng nữa, nhiều khả năng là vậy, đúng không? Nhưng các bạn sẽ gặp cấu trúc này rất nhiều mỗi khi thấy một cặp inverter. Chúng ta đang thực hiện việc lưu trữ.
We're storing some values and using this coupled inverter to reinforce the value, right? So this is another configuration, another part of your bitstream, right? So you are actually also configuring how things are interconnected.
Chúng ta lưu một số giá trị và dùng cặp inverter mắc chéo này để củng cố giá trị đó, đúng không? Vậy đây là một cấu hình khác, một phần khác của bitstream của các bạn. Như vậy, thực ra các bạn cũng đang cấu hình cách các thành phần được kết nối với nhau.
That's also happened in the earlier terminology in the compilation time. We also reconfigure the interconnect. So that's another reconfiguration.
Theo thuật ngữ trước đó, điều này cũng diễn ra ở thời điểm biên dịch. Chúng ta cũng cấu hình lại mạng kết nối. Đó là một dạng cấu hình lại khác.
We talk about lookup tables, slices, and interconnect. I'll quickly go through some of the hardened logic we already mentioned briefly earlier. Today's FPGA is pretty diverse. We have a lot of different logics there.
Chúng ta đã nói về bảng tra cứu, slice và mạng kết nối. Tôi sẽ điểm nhanh qua một số logic cứng hóa (hardened logic) mà chúng ta đã nhắc sơ qua trước đó. FPGA ngày nay khá đa dạng. Có rất nhiều loại logic khác nhau trong đó.
So far, we're mostly talking about lookup tables and the interconnect switches, right? Another very important FPGA resource you will see a lot is basically block RAM or BRAM, right?
Cho đến giờ, chúng ta chủ yếu nói về bảng tra cứu và các công tắc kết nối, đúng không? Một tài nguyên rất quan trọng khác của FPGA mà các bạn sẽ gặp nhiều là block RAM hay BRAM.
So this is actually used to store large amounts of data on our FPGA, right? So there are also dedicated memory components that we can actually do storage.
Nó được dùng để lưu trữ lượng lớn dữ liệu trên FPGA của chúng ta. Như vậy cũng có các thành phần bộ nhớ chuyên dụng để chúng ta có thể lưu trữ.
Another very dedicated compute logic is DSPs. When you read your FPGA report, you may see sometimes actually there is also DSP, right?
Một logic tính toán chuyên dụng khác là DSP. Khi đọc báo cáo FPGA của mình, đôi khi các bạn sẽ thấy cũng có DSP.
So because FPGA, especially the field programmable part, in addition to using as an emulation device, especially if you are talking to folks even here at Berkeley in signal processing, actually a lot of our students, after they took this class, they started research.
Bởi vì FPGA, đặc biệt là phần field programmable (lập trình tại chỗ), ngoài việc dùng làm thiết bị mô phỏng, đặc biệt nếu các bạn trao đổi với những người ngay tại Berkeley làm về xử lý tín hiệu, thì thực ra rất nhiều sinh viên của chúng tôi, sau khi học lớp này, đã bắt đầu làm nghiên cứu.
They're working like MRI labs or signal processing lab. They're actually using FPGA to do a lot of signal processing. So FPGA is also very popular in doing a lot of signal processing.
Họ làm việc ở các phòng thí nghiệm MRI hoặc xử lý tín hiệu. Họ dùng FPGA để thực hiện rất nhiều công việc xử lý tín hiệu. Vì vậy FPGA cũng rất phổ biến trong xử lý tín hiệu.
So we also hardened a lot of DSP logic in FPGA so that we can do those computation, again, in hardened logic instead of doing multiplication in lookup table, which can be very impatient.
Do đó chúng ta cũng cứng hóa rất nhiều logic DSP trong FPGA để thực hiện các phép tính đó trong logic cứng hóa, thay vì thực hiện phép nhân bằng bảng tra cứu, vốn có thể rất chậm chạp.
And more recently, we also have the AI engine. Today's FPGA also have dedicated AI engine. So if something is actually very important, we harden it, right?
Và gần đây hơn, chúng ta còn có AI engine. FPGA ngày nay cũng có AI engine chuyên dụng. Vậy nếu điều gì đó thực sự rất quan trọng, chúng ta cứng hóa nó.
So we see this trend. It's not that everything is programmable. There is also AI engine here. If we look at today's FPGA platform, we have the programmable logic.
Chúng ta thấy xu hướng này. Không phải mọi thứ đều lập trình được. Ở đây cũng có AI engine. Nếu nhìn vào nền tảng FPGA ngày nay, chúng ta có logic lập trình được.
We actually have CPUs, different ARM cores. The AI engine actually gets pretty significant, and the DSP engine. So we have, it's really a system.
Chúng ta thực sự còn có CPU, các lõi ARM khác nhau. AI engine thực sự trở nên khá quan trọng, và cả DSP engine nữa. Như vậy, nó thực sự là một hệ thống.
Not only just the lookup tables, it becomes really a system. So with that, this is the end of today's lecture.
Không chỉ có các bảng tra cứu (lookup table), nó thực sự trở thành một hệ thống. Đến đây là kết thúc bài giảng hôm nay.
We talked about FPGAs, the core FPGA building blocks, and how FPGAs are used today. We have a guest lecture next Tuesday.
Chúng ta đã nói về FPGA, các khối xây dựng cốt lõi của FPGA, và cách FPGA được sử dụng ngày nay. Thứ Ba tuần sau chúng ta có một bài giảng của khách mời.
From Apple, they will share with us how they use FPGA to do emulation. With that, great to see you. Have a good weekend, and I'll see you next week. No problem.
Đến từ Apple, họ sẽ chia sẻ với chúng ta cách họ dùng FPGA để thực hiện mô phỏng phần cứng (emulation). Vậy nhé, rất vui được gặp các em. Chúc các em cuối tuần vui vẻ, hẹn gặp lại tuần sau. Không có gì.
Đă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.