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.
Được rồi, chào buổi sáng cả lớp. 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.
Well, great to see you all today, especially on such a rainy day, so hope everyone stays dry and stays warm. So in today's lecture, we're going to continue some of the discussions of adders.
Rất vui được gặp các bạn hôm nay, nhất là vào một ngày mưa như thế này, nên hy vọng mọi người đều khô ráo và giữ ấm. Trong bài giảng hôm nay, chúng ta sẽ tiếp tục thảo luận về các bộ cộng.
We went through them pretty quickly, but some of the interactions are pretty important, so we'll go through some of the interactions there, and then we'll start our discussions on multipliers.
Chúng ta đã đi qua chúng khá nhanh, nhưng một số tương tác ở đó khá quan trọng, nên chúng ta sẽ xem qua một số tương tác đó, rồi sau đó bắt đầu thảo luận về các bộ nhân.
As I mentioned last week, right, we are starting our third module, really talking about how we design different modules, starting from arithmetic units, adders, and multipliers, and then we'll get to memory modules, how we actually build flip-flops and SRAMs in the next couple of weeks.
Như tôi đã nói tuần trước, chúng ta đang bắt đầu module thứ ba, nói về cách chúng ta thiết kế các module khác nhau, bắt đầu từ các đơn vị số học, bộ cộng và bộ nhân, rồi sau đó sẽ đến các module bộ nhớ, tức là cách chúng ta xây dựng flip-flop và SRAM trong vài tuần tới.
So since we're talking about different arithmetic units, right, it will be interesting to see some of the history of how different arithmetic units are actually integrated in our processor pipeline, right?
Vì chúng ta đang nói về các đơn vị số học khác nhau, nên sẽ thú vị khi xem một chút lịch sử về cách các đơn vị số học được tích hợp vào đường ống của bộ xử lý như thế nào, đúng không?
Some of you know, like, a lot of our research here at Berkeley is really looking at domain-specific accelerators.
Một số bạn biết đấy, rất nhiều nghiên cứu của chúng tôi ở Berkeley là về các bộ tăng tốc chuyên biệt theo miền.
Those are basically hardware that are designed for different computational patterns, different applications, or different domains of applications, right?
Về cơ bản đó là phần cứng được thiết kế cho các mẫu tính toán khác nhau, các ứng dụng khác nhau, hoặc các miền ứng dụng khác nhau, đúng không?
Whenever we talk about accelerators, I always tell people that accelerator is really not a new idea, right? We have actually been using accelerators. We look at the history of computing, right?
Mỗi khi nói về bộ tăng tốc, tôi luôn nói với mọi người rằng bộ tăng tốc thực ra không phải là ý tưởng mới. Thực ra chúng ta đã dùng bộ tăng tốc từ lâu. Hãy nhìn vào lịch sử của ngành máy tính.
For generation and generation, we realize certain primitives are important.
Qua hết thế hệ này đến thế hệ khác, chúng ta nhận ra một số phép toán cơ bản là quan trọng.
We first build a specialized logic for it and see how frequently they are used, and then eventually we integrate them to our general-purpose computing platform, right?
Đầu tiên ta xây dựng logic chuyên dụng cho chúng và xem chúng được dùng thường xuyên đến mức nào, rồi cuối cùng ta tích hợp chúng vào nền tảng tính toán đa dụng của mình, đúng không?
A good example is what people call math coprocessors. Those are basically floating-point units. So when they are actually first introduced, not everyone actually needs floating-point units, right?
Một ví dụ tốt là cái mà người ta gọi là bộ đồng xử lý toán học. Về cơ bản đó là các đơn vị dấu phẩy động. Khi chúng mới được giới thiệu lần đầu, không phải ai cũng cần đơn vị dấu phẩy động, đúng không?
If you're actually using your hardware doing some, like, scientific computing or doing some calculation, you may need actually floating-point, but for a lot of other applications, you don't need it, right?
Nếu bạn dùng phần cứng của mình để làm tính toán khoa học hay một số phép tính nào đó, thì có thể bạn cần dấu phẩy động, nhưng với rất nhiều ứng dụng khác thì không cần, đúng không?
So first floating-point unit, or people back then call it math coprocessor. So this was actually introduced as a separate chip, like the chip over there, 387, right?
Vậy đơn vị dấu phẩy động đầu tiên, hay hồi đó người ta gọi là bộ đồng xử lý toán học. Nó được giới thiệu dưới dạng một con chip riêng, như con chip ở đằng kia, 387, đúng không?
So it's actually a completely separate coprocessor on a different chip, and you need to actually buy it together, right? So 387 was actually introduced together. This is from Intel, right?
Tức là một bộ đồng xử lý hoàn toàn riêng biệt trên một chip khác, và bạn phải mua nó kèm theo, đúng không? 387 được giới thiệu cùng lúc. Đây là của Intel, đúng không?
Together with, what's the main processor for 387? 386, right? The picture shows there, right? 386 is a pretty important processor.
Cùng với, bộ xử lý chính của 387 là gì nhỉ? 386, đúng không? Hình ảnh hiển thị ở đó, đúng không? 386 là một bộ xử lý khá quan trọng.
We look at the history of microprocessor design. Anything interesting you're aware of 386? There were some 152 students, right? Or even 61c students. Did you folks cover history of Intel processors?
Nhìn vào lịch sử thiết kế vi xử lý. Các bạn có biết điều gì thú vị về 386 không? Chắc có vài bạn từng học 152 nhỉ? Hoặc cả các bạn học 61c nữa. Các bạn đã học về lịch sử các bộ xử lý của Intel chưa?
Nothing interesting about 386 before your time? This is roughly late 80s. 386, 486. Well, 386 was the first Intel 32-bit processor.
Không có gì thú vị về 386 từ trước thời của các bạn sao? Đây là khoảng cuối thập niên 80. 386, 486. Vâng, 386 là bộ xử lý 32 bit đầu tiên của Intel.
So 286 was still 16-bit. 386 was the first 32-bit processor.
Còn 286 vẫn là 16 bit. 386 là bộ xử lý 32 bit đầu tiên.
And then, so when 386 was first introduced, or 387 is a separate floating-point unit, and 486, basically the next generation, they actually integrate the floating-point unit together. So 486, just floating-point is pretty important.
Và khi 386 mới được giới thiệu, thì 387 là một đơn vị dấu phẩy động riêng, còn 486, về cơ bản là thế hệ tiếp theo, thì thực sự tích hợp luôn đơn vị dấu phẩy động vào. Vậy với 486, dấu phẩy động khá quan trọng.
A lot of applications are using floating-point. Let's actually put it on chip. So 486 is actually basically integrated both this integer pipeline and also a floating-point pipeline.
Rất nhiều ứng dụng dùng dấu phẩy động. Vậy hãy đưa nó lên chip. Vậy 486 về cơ bản tích hợp cả đường ống số nguyên này lẫn đường ống dấu phẩy động.
There is also an interesting email on a mailing list related to about 386 and 486.
Cũng có một email thú vị trên một danh sách thư liên quan đến 386 và 486.
Some folks from somewhere sent an email saying they're interested in doing a free operating system on 386, 486. And they are wondering whether there's interest or folks are interested in joining the effort.
Một người nào đó đã gửi email nói rằng họ muốn làm một hệ điều hành miễn phí trên 386, 486. Và họ hỏi xem có ai quan tâm hoặc muốn tham gia cùng không.
Any idea who sent this email? Any guesses?
Có ai đoán được ai gửi email này không? Thử đoán xem?
Kubi? Kubi? That's a good guess. Any other thoughts? Linus, yes. So that's the beginning of the Linux operating system on this generation of processor.
Kubi? Kubi? Đoán hay đấy. Còn ai nữa không? Linus, đúng rồi. Đó là khởi đầu của hệ điều hành Linux trên thế hệ bộ xử lý này.
Well, I cut the beginning and the end. There is a full email on this. But yes, he started this building a free operating system as a hobby.
Tôi đã cắt phần đầu và phần cuối. Có một email đầy đủ về chuyện này. Nhưng đúng vậy, ông bắt đầu xây dựng một hệ điều hành miễn phí như một sở thích.
And then the processor they're using is 386, 486. That's actually really the wide adoption of processors for personal computing.
Và bộ xử lý họ dùng là 386, 486. Đó thực sự là sự phổ biến rộng rãi của bộ xử lý cho máy tính cá nhân.
And then see how we can actually build a software stack on top of this generation. So, very interesting history, really looking at late 80s, early 90s, how the different processors are being built.
Rồi xem làm thế nào để xây dựng một software stack trên thế hệ này. Đó là một lịch sử rất thú vị, nhìn vào cuối thập niên 80, đầu thập niên 90, các bộ xử lý khác nhau được xây dựng ra sao.
So we talk about 386, 486, right? Any idea? Or Omer? For a second, I thought this email was recent.
Vậy ta nói về 386, 486, nhỉ? Có ý kiến gì không? Hay Omer? Trong một giây tôi tưởng email này mới gần đây.
Who wants to make a clone of the 386?
Ai muốn làm một bản sao của 386?
Well, I guess it still runs, right? Yeah, that could still run. But yeah, this is a very dated, well, not dated, but this is a historical moment, historical moment in computing.
Chắc là nó vẫn chạy được nhỉ? Vâng, nó vẫn có thể chạy. Nhưng đây là một thứ rất cũ, à không phải cũ, mà đây là một thời khắc lịch sử, một thời khắc lịch sử của ngành điện toán.
So 386, 486. And the interesting thing was 586. Or Pentium, as Intel switched to the codename, when they realized they cannot codename numbers.
Vậy 386, 486. Và điều thú vị là 586. Hay Pentium, vì Intel chuyển sang dùng tên mã, khi họ nhận ra không thể đặt tên mã bằng số.
So the Pentium processor. So 152 students. I think Edison has a good guess about Pentium Pro. Pentium is the first superscalar processor.
Vậy là bộ xử lý Pentium. Các bạn học 152. Tôi nghĩ Edison có một đoán hay về Pentium Pro. Pentium là bộ xử lý superscalar đầu tiên.
So after we get to 32-bit, and then we start, okay, we need more processing power. So Pentium start introduce superscalar.
Sau khi đã lên 32 bit, thì ta bắt đầu thấy cần thêm sức xử lý. Vậy Pentium bắt đầu đưa vào superscalar.
And we talked about P6, I guess, a couple weeks ago, when we talked about delay, right? P6 is the first out-of-order processor, right? So superscalar, out-of-order, right?
Và chúng ta đã nói về P6, tôi nhớ là vài tuần trước, khi chúng ta nói về độ trễ, đúng không? P6 là bộ xử lý out-of-order đầu tiên, đúng không? Vậy là superscalar, out-of-order, đúng không?
And then Intel tried this super deep pipeline. It doesn't really work. And then we basically reverted back to a Pentium Pro processor. A lot of today's processors are basically descendants of Pentium Pro.
Sau đó Intel thử đường ống siêu sâu này. Nó thực sự không hiệu quả. Và rồi về cơ bản họ quay lại với bộ xử lý Pentium Pro. Rất nhiều bộ xử lý ngày nay về cơ bản là hậu duệ của Pentium Pro.
Pentium Pro architecture, a lot of architecture. Very rich history there. So you see how the different things connected, right? 286, just 16-bit.
Kiến trúc Pentium Pro, rất nhiều kiến trúc. Lịch sử ở đó rất phong phú. Vậy các em thấy các thứ kết nối với nhau thế nào, đúng không? 286 chỉ có 16-bit.
And then we get to 32-bit, first a separate floating point unit, then things combined.
Rồi chúng ta lên 32-bit, đầu tiên là một khối dấu phẩy động riêng biệt, sau đó mọi thứ được gộp lại.
And then out-of-order process, superscalar out-of-order processing, all of the very important architectural features are highly correlated with a wide adoption of computing, of processors in the history.
Rồi đến xử lý out-of-order, xử lý superscalar out-of-order, tất cả những đặc điểm kiến trúc rất quan trọng này đều có tương quan rất cao với việc máy tính, bộ xử lý được áp dụng rộng rãi trong lịch sử.
Okay, well, since we're talking about arithmetic in it, some interesting history in how things actually evolved in a very short period of time, Right? So this is late 80s, early 90s, right?
Được rồi, vì chúng ta đang nói về số học trong đó, đây là một chút lịch sử thú vị về việc mọi thứ đã phát triển thế nào trong một khoảng thời gian rất ngắn, đúng không? Đó là cuối thập niên 80, đầu thập niên 90, đúng không?
So like 20, 30 years ago, that's where a lot of very key architectural innovations happened during that time. Okay, with that, let's transition to the topic of today.
Tức là khoảng 20, 30 năm trước, đó là lúc rất nhiều đổi mới then chốt về kiến trúc đã xảy ra. Được rồi, với phần đó, chúng ta chuyển sang chủ đề hôm nay.
We talked about all the different things that are used, and many of them are very related. As I mentioned, the history of personal computing.
Chúng ta đã nói về tất cả những thứ khác nhau được sử dụng, và nhiều thứ trong đó có liên quan rất chặt chẽ. Như tôi đã đề cập, lịch sử của máy tính cá nhân.
Just a quick recap: last lecture, we started the discussion on energy and the power. We talked about there were two components, right? Dynamic power.
Xin nhắc lại nhanh: ở bài giảng trước, chúng ta bắt đầu thảo luận về năng lượng và công suất. Chúng ta đã nói có hai thành phần, đúng không? Công suất động.
We talked about all the different factors, how we can potentially reduce the dynamic power. Also talked about a short-circuit power, which is also dynamic power.
Chúng ta đã nói về tất cả các yếu tố khác nhau, về cách có thể giảm công suất động. Cũng đã nói về công suất ngắn mạch, cũng là một dạng công suất động.
There were some questions during the lecture last time: what are the ways to actually potentially reduce a short-circuit power? I looked a little bit more into it.
Có một vài câu hỏi trong bài giảng lần trước: có những cách nào để có thể giảm công suất ngắn mạch? Tôi đã tìm hiểu thêm một chút về vấn đề này.
There are just not a lot of very good options. First, they are just less important. And even before, it's really just about 10%.
Thực sự không có nhiều lựa chọn tốt. Thứ nhất, nó vốn kém quan trọng hơn. Ngay cả trước đây, nó cũng chỉ khoảng 10%.
And even nowadays, our survival is actually much lower, just never a big concern. Things that could potentially help is basically we can make the transition faster, right? So we talk about short-circuit power.
Và ngay cả ngày nay, nó còn thấp hơn nhiều, không bao giờ là mối quan tâm lớn. Điều có thể giúp được về cơ bản là làm cho quá trình chuyển mức nhanh hơn, đúng không? Chúng ta đang nói về công suất ngắn mạch.
It's basically during the transition, both PMOS and NMOS are on, right? Then there's a circuit from, like, from power VDD to ground, right?
Về cơ bản, trong lúc chuyển mức, cả PMOS và NMOS đều bật, đúng không? Khi đó có một đường dẫn từ nguồn VDD xuống đất, đúng không?
We make the transition faster without significantly changing the delay behavior, right? We can potentially reduce the short-circuit power. So that's another component. But it's still a dynamic power.
Nếu ta làm cho quá trình chuyển mức nhanh hơn mà không thay đổi đáng kể hành vi về độ trễ, đúng không? thì có thể giảm được công suất ngắn mạch. Vậy đó là một thành phần khác. Nhưng nó vẫn là công suất động.
It's very related to the switching activity. It's less of a concern these days because our VDD is pretty low, especially compared to threshold voltage. We also talk about static leakage power.
Nó liên quan rất nhiều đến hoạt động chuyển mạch. Ngày nay nó ít đáng lo hơn vì VDD của chúng ta khá thấp, đặc biệt là so với điện áp ngưỡng. Chúng ta cũng nói về công suất rò tĩnh.
It's actually getting a lot more important. Also related, our VDD is actually much, much closer to a threshold. There were some discussion about technology corners, right?
Thực ra nó đang trở nên quan trọng hơn nhiều. Cũng liên quan đến điều đó, VDD của chúng ta hiện nay tiến gần ngưỡng hơn rất nhiều. Đã có một số thảo luận về các technology corner, đúng không?
For folks who are interested, especially for ASAP7 technology, this is a link where you can actually see all the different technology corners. Typically, people say PVT: process, voltage, and temperature.
Với những bạn quan tâm, đặc biệt là công nghệ ASAP7, đây là đường liên kết để các bạn xem tất cả các technology corner khác nhau. Thông thường người ta nói PVT: quy trình, điện áp và nhiệt độ.
I checked your lab file. You folks are only using really a different VDD and different temperature. That's basically your timing report. But there are also other available technology corners in the ASAP7 library.
Tôi đã kiểm tra tệp lab của các bạn. Các bạn thực ra chỉ đang dùng VDD khác nhau và nhiệt độ khác nhau. Về cơ bản đó là báo cáo timing của các bạn. Nhưng trong thư viện ASAP7 còn có các technology corner khác nữa.
You can also take a look at different regular high VT, regular VT, and low VT designs that are also included in this ASAP7 file. We started our discussion on adders, right?
Các bạn cũng có thể xem các thiết kế high VT, regular VT và low VT cũng được đưa vào tệp ASAP7 này. Chúng ta đã bắt đầu thảo luận về bộ cộng, đúng không?
Because it is a very important component. We also mentioned that arithmetic unit is very important, right? Generally, carry is a critical path. That's the longest path, right?
Vì đó là một thành phần rất quan trọng. Chúng ta cũng đã nói đơn vị số học rất quan trọng, đúng không? Nhìn chung, nhớ là đường tới hạn. Đó là đường dài nhất, đúng không?
So all the crazy or interesting adder design, basically trying to think how we can potentially reduce the critical paths. One of the very important designs, basically, carry-lookahead tree adder, right?
Vì vậy mọi thiết kế bộ cộng điên rồ hay thú vị về cơ bản đều tìm cách làm giảm các đường tới hạn. Một trong những thiết kế rất quan trọng là bộ cộng dạng cây carry-lookahead, đúng không?
So this is a preferred design, especially when we have wider widths, right? Today's processor is 64-bit, right? So pretty wide. We went through this part pretty quickly.
Đây là thiết kế được ưa chuộng, đặc biệt khi độ rộng bit lớn, đúng không? Bộ xử lý ngày nay là 64 bit, khá rộng. Chúng ta đã đi qua phần này khá nhanh.
So I'm going to just do a quick review and make sure we get the high-level ideas, right?
Vì vậy tôi sẽ chỉ ôn lại nhanh và đảm bảo chúng ta nắm được các ý tưởng ở mức tổng quát, đúng không?
Just what are the key ideas and what are the things that we can think of with a carry-lookahead adder.
Tức là các ý tưởng chính là gì và những điều gì chúng ta có thể nghĩ đến với bộ cộng carry-lookahead.
So basically, we talk about all the ideas with adder designs, how we can actually generate carry quickly, right?
Về cơ bản, chúng ta nói về mọi ý tưởng trong thiết kế bộ cộng, làm sao để tạo ra nhớ một cách nhanh chóng, đúng không?
Instead of having the carry propagate bit by bit through the ripple-carry design, we want to actually generate carry or potentially shorten the critical path so that we don't need to carry actually bit by bit, right?
Thay vì để nhớ lan truyền từng bit qua thiết kế ripple-carry, chúng ta muốn tạo ra nhớ hoặc có thể rút ngắn đường tới hạn để không cần phải chuyển nhớ từng bit một, đúng không?
We talk about, if you remember, we talk about using the propagate and generate signal, right?
Các bạn còn nhớ, chúng ta đã nói về việc dùng tín hiệu propagate và generate, đúng không?
So instead of using A and B directly, we can actually use propagate and generate signal directly related to carry, right? Whether we want to propagate carry or not, or generate carry or not.
Vì vậy thay vì dùng trực tiếp A và B, chúng ta có thể dùng tín hiệu propagate và generate liên quan trực tiếp đến nhớ, đúng không? Tức là có muốn lan truyền nhớ hay không, hoặc có tạo nhớ hay không.
We talked about carry-skip adder last time, right? So carry-skip adder is basically using that MUX, and that MUX is basically controlled by group, which signal is controlling the carry-skip adder.
Lần trước chúng ta đã nói về bộ cộng carry-skip, đúng không? Bộ cộng carry-skip về cơ bản dùng MUX đó, và MUX đó về cơ bản được điều khiển theo nhóm, tức là tín hiệu nào đang điều khiển bộ cộng carry-skip.
Which signal is controlling the carry, whether we actually skip or we actually, whether we just propagate that directly or whether we actually use the carry generated.
Tín hiệu nào điều khiển nhớ, xem chúng ta có bỏ qua hay chỉ truyền thẳng nó đi, hay dùng nhớ đã được tạo ra.
Remember, we have a... Exactly, so it's basically the product of the propagate signal, right?
Nhớ là chúng ta có một... Chính xác, về cơ bản đó là tích của các tín hiệu propagate, đúng không?
So then we can actually use this propagate signal directly to see whether we want to propagate carry or use the pre-computed, like the carry that we actually computed for this stage, right?
Như vậy chúng ta có thể dùng trực tiếp tín hiệu propagate này để xem có muốn lan truyền nhớ hay dùng giá trị tính trước, tức là nhớ mà chúng ta đã tính cho tầng này, đúng không?
So the first step of carry lookahead adder is basically, let's not only do propagate, let's also do generate, right?
Vậy bước đầu tiên của bộ cộng carry lookahead về cơ bản là, ta không chỉ làm propagate, mà còn làm cả generate, đúng không?
Both signals, we can actually see whether we want to generate the carry and also propagate carry, right? So first, of course, we have all the different propagate and generate signals.
Với cả hai tín hiệu, ta có thể biết được liệu mình có muốn tạo ra nhớ và cả lan truyền nhớ hay không, đúng không? Trước hết, tất nhiên ta có tất cả các tín hiệu propagate và generate khác nhau.
We can actually quickly compute them, right? They are basically dependent only on the input, right? So we can actually quickly compute them directly. That's the first step.
Ta có thể tính chúng rất nhanh, đúng không? Về cơ bản chúng chỉ phụ thuộc vào đầu vào, đúng không? Nên ta có thể tính trực tiếp chúng rất nhanh. Đó là bước đầu tiên.
But even after this step, it doesn't really change anything, right? So, okay, we can use generate, but this is still like O(N), right?
Nhưng ngay cả sau bước này, thực ra chẳng có gì thay đổi, đúng không? Ừ thì ta dùng được generate, nhưng nó vẫn là O(N), đúng không?
So it's still linear because we still have this carry chain, right? So this first step is basically generating the individual propagate and generate signals. The second step is really grouping them together, right?
Tức là vẫn tuyến tính vì ta vẫn còn chuỗi nhớ này, đúng không? Vậy bước đầu tiên này về cơ bản là tạo ra các tín hiệu propagate và generate riêng lẻ. Bước thứ hai thực sự là gom chúng lại với nhau, đúng không?
So what we realize is that instead of doing this at the individual bit level, we could actually group them together to have our group propagate signal and the group generate signal, right?
Điều ta nhận ra là thay vì làm ở mức từng bit riêng lẻ, ta có thể gom chúng lại để có tín hiệu group propagate và tín hiệu group generate, đúng không?
So we basically keep replacing the propagate and generate signals using the previous ones, right?
Tức là ta liên tục thay thế các tín hiệu propagate và generate bằng các tín hiệu trước đó, đúng không?
So we can actually, like Omer mentioned, the carry skip adder is basically using the product of the propagate signal, right?
Như Omer đã đề cập, bộ cộng carry skip về cơ bản dùng tích của các tín hiệu propagate, đúng không?
We talked about this before in carry skip adder, but in carry lookahead adder, we also rewrite the generate signal using the nested generate and the propagate signal to actually see whether we want to generate carry or not at this group level, right?
Ta đã nói về điều này trước đây với bộ cộng carry skip, nhưng với bộ cộng carry lookahead, ta còn viết lại tín hiệu generate bằng generate lồng nhau và tín hiệu propagate để xem ta có muốn tạo ra nhớ hay không ở mức nhóm này, đúng không?
So it's not that individual bit. This is the individual bit. Now the second stage is to have this group propagate and generate signal. Everything within this group is only dependent on the input, right?
Vậy nó không phải bit riêng lẻ. Đây mới là bit riêng lẻ. Giờ giai đoạn thứ hai là có tín hiệu group propagate và generate này. Mọi thứ trong nhóm này chỉ phụ thuộc vào đầu vào, đúng không?
So we're using just the propagate and generate signal. And then this can be pre-computed as long as the inputs are ready, right?
Vì ta chỉ dùng các tín hiệu propagate và generate. Và cái này có thể tính trước miễn là đầu vào đã sẵn sàng, đúng không?
And then once the carry in arrives for this group, we can just quickly, all of the, both term G and P are available, right?
Rồi khi carry in của nhóm này đến, ta có thể nhanh chóng, cả hai số hạng G và P đều đã có sẵn, đúng không?
So whenever the carry actually arrives, we can pretty quickly produce the carry out, right? So we now, by doing this rewrite, we use both. So carry skip only uses the propagate signal, right?
Nên bất cứ khi nào nhớ đến, ta có thể tạo ra carry out khá nhanh, đúng không? Vậy bằng cách viết lại này, ta dùng cả hai. Carry skip chỉ dùng tín hiệu propagate, đúng không?
So carry-lookahead uses both generate and propagate signal. By doing this group rewrite at the group level, we can quickly propagate the carry signal.
Còn carry-lookahead dùng cả tín hiệu generate và propagate. Bằng cách viết lại ở mức nhóm như vậy, ta có thể lan truyền tín hiệu nhớ rất nhanh.
Once the input is ready, we can get the carry output, right? So this is a nice feature to have, right?
Khi đầu vào sẵn sàng, ta có thể có ngay carry output, đúng không? Đây là một đặc điểm rất tốt, đúng không?
So okay, so whenever we can pre-compute the P and the G, we can propagate the carry pretty quickly. But the complexity of actually doing this group P and G signal is also non-trivial, right?
Vậy nên bất cứ khi nào có thể tính trước P và G, ta có thể lan truyền nhớ khá nhanh. Nhưng độ phức tạp của việc tính các tín hiệu group P và G cũng không hề nhỏ, đúng không?
So you just look at the complexity here, right? We're doing a lot of nested replacement to actually calculate the propagate and generate signal, right?
Bạn cứ nhìn độ phức tạp ở đây, đúng không? Ta đang thực hiện rất nhiều phép thay thế lồng nhau để tính tín hiệu propagate và generate, đúng không?
Like another visual, more visual way of looking at the complexity, right? Of course, it's pretty fast for the lower bits, the LSBs, right?
Một cách khác, trực quan hơn để nhìn vào độ phức tạp này, đúng không? Tất nhiên, với các bit thấp, tức các LSB, thì khá nhanh, đúng không?
We can actually get this group P and G, the second step, right? We're doing the group P and G, right? So the second step for the LSBs, we can actually get them pretty quickly.
Ta có thể lấy được P và G nhóm ở bước thứ hai, đúng không? Ta đang tính P và G nhóm, đúng không? Vậy ở bước thứ hai, với các LSB, ta có thể lấy chúng khá nhanh.
And let's look at the higher order bits, right? There's still a non-trivial amount of computation there to actually calculate the propagate and the group propagate and generate signal, right?
Và hãy nhìn vào các bit bậc cao, đúng không? Vẫn còn một lượng tính toán không hề nhỏ ở đó để tính tín hiệu propagate và tín hiệu group propagate và generate, đúng không?
So, okay, this is an interesting idea. Now we use generate. We can replace everything with propagate and generate signal. But even doing this, this computation is still pretty expensive.
Vậy, được rồi, đây là một ý tưởng thú vị. Giờ ta dùng generate. Ta có thể thay mọi thứ bằng tín hiệu propagate và generate. Nhưng dù làm vậy, phép tính này vẫn khá tốn kém.
Second step is still pretty expensive. So that gets us to think about how we can actually also make this faster, especially when we have higher order bits.
Bước thứ hai vẫn khá tốn kém. Điều đó khiến ta nghĩ đến cách làm cho nó nhanh hơn nữa, đặc biệt khi có các bit bậc cao.
We'll actually need to do that, do a lot of them pretty quickly. So that gets to the tree adder.
Ta sẽ cần làm rất nhiều phép như vậy, và phải làm khá nhanh. Điều đó dẫn đến bộ cộng dạng cây (tree adder).
But before I move to the tree reduction, any questions? Are we on the same page? We see what's going on from carry skip. Now with the generate signal, and then we're doing this complexity.
Nhưng trước khi chuyển sang tree reduction, có câu hỏi nào không? Ta đã theo kịp chưa? Ta đã thấy chuyện gì xảy ra với carry skip. Giờ với tín hiệu generate, và rồi ta xét độ phức tạp này.
Okay, then I get to our next optimization. So, okay, we understand it's still pretty long with this group propagate and generate signal, right? Can we actually make that faster?
Được rồi, vậy ta sang phần tối ưu hóa tiếp theo. Vậy, ta hiểu rằng với group propagate và generate này thì vẫn còn khá dài, đúng không? Liệu ta có thể làm cho nó nhanh hơn không?
So that starts, that's where we introduce a tree reduction or basically tree adder, right?
Và đó là chỗ ta đưa vào tree reduction, hay nói đơn giản là bộ cộng dạng cây, đúng không?
For all the different propagate and generate signal, right, we mentioned this can actually also grow a lot more complex because there are like a lot of things going on.
Với tất cả các tín hiệu propagate và generate khác nhau, ta đã nói rằng chúng có thể ngày càng phức tạp hơn nhiều vì có rất nhiều thứ diễn ra.
So the idea here is basically using this tree reduction logic, we can actually combine this calculation into a tree data structure, right? Because they are actually fully associative, right?
Ý tưởng ở đây là dùng logic tree reduction này, ta có thể gộp phép tính này thành một cấu trúc dữ liệu dạng cây, đúng không? Vì chúng hoàn toàn có tính kết hợp, đúng không?
So it doesn't really matter which part we actually compute first or second, we can actually do this kind of hierarchical group propagate and generate signal, I guess generation, to actually figure out what's the final P and G need to be.
Nên việc tính phần nào trước hay sau thực ra không quan trọng, ta có thể làm kiểu phân cấp các tín hiệu group propagate và generate, tôi đoán là sinh ra, để tìm xem P và G cuối cùng phải là gì.
Once we figure out final P and G, once the carry in is here, right, so it's very, the carry. This is a group P and G. The carry out is very easy, right?
Một khi ta tìm được P và G cuối cùng, khi carry in đã có ở đây, đúng không, thì rất, carry. Đây là P và G nhóm. Carry out rất dễ, đúng không?
It's just generate or propagate and carry, right? So we can pre-compute this part quickly, then we can actually do things very quick. So this is basically how we do that.
Nó chỉ là generate hoặc propagate và carry, đúng không? Vậy ta có thể tính trước phần này nhanh, rồi mọi thứ sẽ rất nhanh. Về cơ bản đây là cách ta làm.
Using this tree-based reduction structure, leveraging all the different components are fully associative, right? Instead of having that linear reduction path that we have before, we reorganize into a tree reduction.
Dùng cấu trúc rút gọn dạng cây này, tận dụng việc mọi thành phần đều hoàn toàn có tính kết hợp, đúng không? Thay vì có đường rút gọn tuyến tính như trước, ta tổ chức lại thành tree reduction.
The benefit is basically instead of on the order of N, right? So now it's really a log N, Right?
Lợi ích là thay vì cỡ N, đúng không? thì giờ thực sự là log N, đúng không?
Depends on the radix of the tree, but we can actually get a log N delay to actually make the group P and G generation faster. We'll talk about different tree structure in a minute.
Tùy thuộc vào cơ số của cây, nhưng ta có thể đạt độ trễ log N để làm cho việc tạo tín hiệu P và G của nhóm nhanh hơn. Lát nữa chúng ta sẽ nói về các cấu trúc cây khác nhau.
We'll skip through that part pretty quickly. We'll talk about some of the examples of tree reduction structure. We'll also talk about the NVIDIA work using reinforcement learning.
Phần đó chúng ta sẽ lướt qua khá nhanh. Chúng ta sẽ nói về một số ví dụ về cấu trúc rút gọn dạng cây. Chúng ta cũng sẽ nói về công trình của NVIDIA dùng reinforcement learning.
They are also basically trying to figure out what would be a good tree structure. But the underlying idea is still, okay, we use P and G signal, we isolate this ripple-carry path.
Về cơ bản họ cũng đang cố tìm ra cấu trúc cây nào là tốt. Nhưng ý tưởng nền tảng vẫn là, được rồi, ta dùng tín hiệu P và G, ta tách riêng đường nhớ ripple-carry này.
Everything only depends on the input. But even getting that P and G signal is pretty expensive. So how we do that quickly? Let's use a tree.
Mọi thứ chỉ phụ thuộc vào đầu vào. Nhưng ngay cả việc tính tín hiệu P và G cũng khá tốn kém. Vậy làm sao để làm việc đó nhanh? Hãy dùng một cây.
So those are the key ideas with this carry-lookahead tree pattern.
Đó là những ý tưởng chính của mẫu cây carry-lookahead này.
Before we get to the tree structures, does this make sense? Questions, comments? The high-level ideas?
Trước khi sang các cấu trúc cây, phần này đã rõ chưa? Có câu hỏi hay nhận xét nào không? Về các ý tưởng ở mức tổng quát?
Okay, so we see the first part is just generate the propagate and generate signal at each position, right?
Được rồi, vậy phần đầu tiên chỉ là tạo ra tín hiệu propagate và generate tại mỗi vị trí, đúng không?
Second, we actually do this group P and G signal, right? So then we can actually combine them to see for this group how we calculate that.
Thứ hai, ta tạo tín hiệu P và G của nhóm, đúng không? Rồi ta có thể kết hợp chúng để xem với nhóm này thì tính như thế nào.
But this is still pretty complex, right? And then we use this tree structure to actually reduce the complexity to do this actually faster. And everything is actually independent of the carry.
Nhưng việc này vẫn còn khá phức tạp, đúng không? Và sau đó ta dùng cấu trúc cây này để giảm độ phức tạp, để làm việc này nhanh hơn. Và mọi thứ đều độc lập với tín hiệu nhớ.
Now, all right, we can actually do this. Whenever the inputs are ready, we can actually do this quickly. And then we can get the results.
Nào, vậy là ta làm được việc này. Bất cứ khi nào đầu vào sẵn sàng, ta có thể làm việc này rất nhanh. Và rồi ta có được kết quả.
Okay, so that's the high-level ideas of the carry-lookahead tree adder. I mentioned there are a lot of different trees, right? For a while, different ideas in hardware design. Ruben?
Được rồi, đó là các ý tưởng tổng quát của bộ cộng dạng cây carry-lookahead. Tôi đã nói là có rất nhiều loại cây khác nhau, đúng không? Trong một thời gian, có nhiều ý tưởng khác nhau trong thiết kế phần cứng. Ruben?
Is there a particular tree structure it works for?
Có một cấu trúc cây cụ thể nào mà nó hoạt động không?
Are you wondering for this tree, we're doing this two-to-one reduction? Is there other ways to do that? I see.
Bạn đang thắc mắc là với cây này, ta rút gọn hai về một phải không? Có cách nào khác để làm không? Tôi hiểu rồi.
So just how we approach this. Yeah, that's a good question. That's basically related to the trees. Here, I'm showing this perfect two-to-one or Radix-2 tree, right? There could be actually different ways.
Tức là ta tiếp cận việc này thế nào. Vâng, câu hỏi hay. Điều đó về cơ bản liên quan đến các cây. Ở đây, tôi đang cho thấy cây hai-về-một hoàn hảo, hay cây Radix-2, đúng không? Thực ra có thể có nhiều cách khác nhau.
Like, why do we actually have two inputs here, right? So here, this output only goes to one block, right? How about other different structures to do this?
Chẳng hạn, tại sao ở đây ta lại có hai đầu vào, đúng không? Còn ở đây, đầu ra này chỉ đi tới một khối, đúng không? Vậy còn các cấu trúc khác nhau để làm việc này thì sao?
So there are a lot of different ways to actually optimize this recursive function. This is just one example. This is an example, but there are other ways. There's no universal way of doing that.
Vậy có rất nhiều cách khác nhau để tối ưu hàm đệ quy này. Đây chỉ là một ví dụ. Đây là một ví dụ, nhưng còn có những cách khác. Không có cách nào là phổ quát cả.
We can take a look at some of the examples here. So basically, the idea is similar to the parallel algorithm. It's a prefix sum or scan operation.
Chúng ta có thể xem một vài ví dụ ở đây. Về cơ bản, ý tưởng này tương tự như thuật toán song song. Đó là phép tính tổng tiền tố hay phép quét (scan).
We're having this associative reduction, and then we can actually reduce this, right? We talk about different ways to actually support this recursive function or support this tree adder, right?
Ta có phép rút gọn có tính kết hợp này, và rồi ta có thể rút gọn nó, đúng không? Chúng ta nói về các cách khác nhau để hỗ trợ hàm đệ quy này hay để hỗ trợ bộ cộng dạng cây này, đúng không?
So there are actually a lot of different trees. Because all we said is this is a recursive function. We want to run it faster, right?
Thực ra có rất nhiều loại cây khác nhau. Vì tất cả những gì ta nói là đây là một hàm đệ quy. Ta muốn nó chạy nhanh hơn, đúng không?
But these structures are highly parameterizable, with actually different ways to think about how to approach it. There's a lot of interesting designs that came up in the 50s and 60s.
Nhưng các cấu trúc này có thể tham số hóa rất nhiều, với những cách nghĩ khác nhau về việc tiếp cận nó. Có rất nhiều thiết kế thú vị xuất hiện từ những năm 50 và 60.
It was still pretty heavily researched, even in the 80s, actually. It's coming up with a very good tree reduction.
Thậm chí đến những năm 80 nó vẫn được nghiên cứu khá nhiều. Đó là việc tìm ra một cách rút gọn dạng cây thật tốt.
And the reinforcement learning, some of the more recent work, is actually thinking about this from a machine learning perspective, right?
Còn học tăng cường, một số công trình gần đây hơn, thì đang nhìn vấn đề này từ góc độ học máy, đúng không?
So like Uber mentioned, when we actually approach this, what are the general parameters to actually approach this recursive function? Like the first one, I think what we mentioned, the radix, right?
Vậy như Uber đã đề cập, khi ta tiếp cận vấn đề này, các tham số chung để tiếp cận hàm đệ quy này là gì? Như tham số đầu tiên, tôi nghĩ ta đã nhắc đến, là radix, đúng không?
So the example I showed earlier, we're doing this 2-to-1 reduction, right? Do we always need to do 2-to-1? How about we have higher radix? We can also have higher reduction, right?
Ví dụ tôi cho xem lúc nãy, ta đang làm phép rút gọn 2 về 1, đúng không? Có phải lúc nào cũng cần rút gọn 2 về 1 không? Nếu ta dùng radix cao hơn thì sao? Ta cũng có thể rút gọn nhiều đầu vào hơn, đúng không?
So that could be a design optimization we can actually try. We'll talk about some of the trade-offs here, right? We can actually go to a wider radix, right?
Đó có thể là một cách tối ưu thiết kế mà ta có thể thử. Ta sẽ nói về một số đánh đổi ở đây, đúng không? Ta có thể dùng radix rộng hơn, đúng không?
So the group is bigger, but also it can reduce the depth of the tree, right? So instead of, we talked about before, it's like log n, right?
Nhóm sẽ lớn hơn, nhưng cũng có thể giảm độ sâu của cây, đúng không? Thay vì như đã nói trước đây là log n, đúng không?
With different radix, we'll have a different tree, right? Also talk about sparseness of the tree. Instead of having everything connected, we could actually make the tree a little bit sparser.
Với radix khác nhau, ta sẽ có cây khác nhau, đúng không? Ngoài ra còn có độ thưa của cây. Thay vì nối mọi thứ với nhau, ta có thể làm cho cây thưa hơn một chút.
We talked about wires. We want to avoid having a lot of wires in our system, right?
Ta đã nói về dây dẫn. Ta muốn tránh có quá nhiều dây dẫn trong hệ thống, đúng không?
So there are also ideas actually thinking about sparseness of the tree or doing optimizations to actually make the trees a little bit more regular.
Vì vậy cũng có những ý tưởng xem xét độ thưa của cây hoặc tối ưu để làm cho cây đều đặn hơn một chút.
So I also see some of the examples in thinking about the tree reduction there.
Tôi cũng thấy một vài ví dụ về cách rút gọn dạng cây ở đó.
Again, this part, no need to memorize this, especially this is a very both established and can also be automated area with this kind of more learning-based algorithm.
Một lần nữa, phần này không cần học thuộc, nhất là đây là một lĩnh vực vừa đã có nền tảng vững vừa có thể tự động hóa bằng các thuật toán dựa trên học máy.
So you don't need to remember this, but it's just good to understand what are the different parameters when people are searching different prefix adder trees, what exactly they're doing, right?
Nên bạn không cần nhớ phần này, nhưng nên hiểu các tham số khác nhau là gì khi người ta tìm kiếm các cây bộ cộng tiền tố khác nhau, và họ thực sự đang làm gì, đúng không?
So we talked about radix, right? Let's take a look at some of the radix, different radixes. So a very common one is a Kogge-Stone tree. And this is just like very, very regular.
Vậy ta đã nói về radix, đúng không? Hãy xem một vài radix, các radix khác nhau. Một loại rất phổ biến là cây Kogge-Stone. Và loại này cực kỳ đều đặn.
We can actually see the, let's see. Actually, we can actually see the reduction patterns here. We actually, I will start from here. These are the inputs. This is a sum, right?
Ta có thể thấy, để xem nào. Thực ra ta có thể thấy các mẫu rút gọn ở đây. Tôi sẽ bắt đầu từ đây. Đây là các đầu vào. Đây là tổng, đúng không?
So the bottom, like sometimes you'll see different formats. So for our format where this is bottom, this is input A and B and this is sum, right?
Ở phía dưới, đôi khi bạn sẽ thấy các định dạng khác nhau. Với định dạng của ta, phía dưới này là đầu vào A và B, còn đây là tổng, đúng không?
So we're doing like two to one reduction. You can see here, we're getting the inputs and then we produce an output here, right? So this is a very standard radix two reduction tree.
Vậy ta đang làm phép rút gọn hai về một. Các bạn có thể thấy ở đây, chúng ta nhận các đầu vào và sau đó tạo ra một đầu ra ở đây, đúng không? Đây là một cây rút gọn cơ số 2 rất chuẩn.
This is like 16-bit input, Right? 16 bit adder. We can actually do this again, hierarchically, to actually get to the final sum, right?
Đây là đầu vào 16 bit, đúng không? Bộ cộng 16 bit. Chúng ta thực sự có thể làm lại điều này theo phân cấp, để đi đến tổng cuối cùng, đúng không?
So we kind of, this is 16 bits, right? So log two 16, right? So it's a four steps reduction tree here, right?
Vậy đây là 16 bit, đúng không? Nên log2 16, đúng không? Tức là ở đây có cây rút gọn bốn bước, đúng không?
What could be some potential problems or challenges? We talk about wires, right? What are some potential challenges with this kind of tree here?
Những vấn đề hay thách thức tiềm tàng có thể là gì? Ta đang nói về dây dẫn, đúng không? Loại cây này có thể gặp những thách thức tiềm tàng nào?
Delay and energy, right? So delay, what kind of delay? What kind of? It's going to be RC delay, right? So we talk about wires, right? Do we have short wires or long?
Độ trễ và năng lượng, đúng không? Vậy độ trễ, loại độ trễ nào? Loại nào? Đó sẽ là độ trễ RC, đúng không? Vì ta đang nói về dây dẫn. Ta có dây ngắn hay dây dài?
What's the longest wire here? You think about adder layout in a grid fashion.
Dây dài nhất ở đây là dây nào? Hãy hình dung bố cục bộ cộng theo dạng lưới.
This is pretty similar to actual layout. It's very regular, right? We look at all those wires here. In the final reduction stages, right, we are actually combining them to produce the final sum.
Nó khá giống bố cục thực tế. Rất đều đặn, đúng không? Hãy nhìn tất cả những dây dẫn ở đây. Ở các tầng rút gọn cuối cùng, đúng không, chúng ta kết hợp chúng để tạo ra tổng cuối cùng.
Those are generally the longer wires that we actually observe. And we have basically half of the last step, right?
Đó thường là những dây dài hơn mà chúng ta quan sát thấy. Và về cơ bản ta có một nửa của bước cuối, đúng không?
Half of the inputs actually need to produce, have the output need to be produced this way. So those are some of the, again, this is trade off, right?
Một nửa số đầu vào thực sự cần tạo ra, tức là đầu ra cần được tạo ra theo cách này. Đó là một số điểm, và đây lại là sự đánh đổi, đúng không?
Nothing's perfect, but those are the longer wires. This is something we generally avoid when we actually see, when we actually build this kind of structure, right?
Không có gì hoàn hảo, nhưng đó là những dây dài hơn. Đây là điều chúng ta thường tránh khi xây dựng loại cấu trúc này, đúng không?
So this is a pretty common Kogge-Stone tree or adder with radix of two. We can basically extend it into a radix of four tree, right?
Đây là cây Kogge-Stone khá phổ biến, hay bộ cộng với cơ số 2. Chúng ta có thể mở rộng nó thành cây cơ số 4, đúng không?
So now we see, again, this is the input, still 16 bits. This is output, right? So now for the first stage, we actually have a four to one reduction, right?
Vậy bây giờ ta thấy, đây vẫn là đầu vào 16 bit. Đây là đầu ra, đúng không? Ở tầng đầu tiên, ta có phép rút gọn bốn về một, đúng không?
So, and then again, so then we look at the depth, right? So it's log four of 16, right? So it's only two levels if needed. So we have a shallower depth.
Và rồi ta xét độ sâu, đúng không? Đó là log4 của 16, đúng không? Vậy chỉ cần hai mức. Nên độ sâu nông hơn.
And then we actually, we have this higher radix grouping here, right? What other things are also changed when we have this higher radix?
Và ta có cách nhóm với cơ số cao hơn ở đây, đúng không? Khi có cơ số cao hơn thì còn những gì khác thay đổi?
We think about how the different intermediate nodes are actually used.
Hãy nghĩ về cách các nút trung gian khác nhau được sử dụng.
Ben?
Ben?
Right, so, yeah, so you would think about our logical effort discussion, right?
Đúng rồi, vâng, bạn sẽ nghĩ đến phần thảo luận về logical effort của chúng ta, đúng không?
So you will actually see some of the intermediate nodes, they are actually used multiple places. Well, of course they have, there's always like everything actually affected, right?
Bạn sẽ thấy một số nút trung gian được dùng ở nhiều chỗ. Tất nhiên là mọi thứ đều bị ảnh hưởng, đúng không?
When you have more. But you remember our logical effort discussion, right? So this basically means higher fan-out, right? So we are actually supporting more nodes, right? More downstream nodes here, right?
Khi có nhiều hơn. Nhưng các bạn nhớ phần thảo luận về logical effort chứ? Điều này về cơ bản có nghĩa là fan-out cao hơn, đúng không? Tức là ta đang cấp tín hiệu cho nhiều nút hơn, đúng không? Nhiều nút phía sau hơn ở đây, đúng không?
We measure like roughly a good fan-out is roughly four, in the four range, right? So this actually potentially actually has higher fan-out, right? Because each intermediate node is actually being used multiple times.
Theo đo đạc, fan-out tốt vào khoảng bốn, trong khoảng bốn, đúng không? Vì vậy cấu trúc này thực tế có thể có fan-out cao hơn, đúng không? Bởi vì mỗi nút trung gian thực tế được sử dụng nhiều lần.
So that's basically some of the trade-off, right? So we have a shallower depth, right? Which is good, but we also have higher fan-out, right? Which we also need to consider this very, very carefully.
Đó chính là một phần của sự đánh đổi, đúng không? Vậy là chúng ta có độ sâu nông hơn, đúng không? Điều đó tốt, nhưng chúng ta cũng có fan-out cao hơn, đúng không? Điều mà chúng ta cũng cần cân nhắc thật, thật cẩn thận.
So those are some of the tree structures, right? And also, this is a pretty regular reduction tree.
Đó là một số cấu trúc cây, đúng không? Và đây cũng là một cây rút gọn khá đều đặn.
There are also some of the reduction trees are actually more interesting. They're actually doing this, this way.
Cũng có một số cây rút gọn thú vị hơn. Chúng thực hiện theo cách này.
Again, having longer wires, but actually having fewer connections between different inputs to outputs, right? So they actually have this subgroups.
Một lần nữa, có dây dài hơn, nhưng lại có ít kết nối hơn giữa các đầu vào và đầu ra, đúng không? Vì vậy chúng có các nhóm con này.
So this, this is more like, you think about a binary tree, right? So this is more like a binary tree.
Cái này giống như khi bạn nghĩ về một cây nhị phân, đúng không? Vậy nên đây giống như một cây nhị phân.
Like, okay, to get this, this is a binary tree I need or divide or conquer, right? So figure this out.
Kiểu như, để có được cái này, đây là cây nhị phân, tôi cần chia để trị, đúng không? Vậy hãy tìm ra điều này.
And then to generate carry, and then we can actually generate our sums with the intermediate result, right? So this can also get to the carry pretty quickly.
Và sau đó để tạo ra nhớ, rồi chúng ta có thể tạo ra các tổng từ kết quả trung gian, đúng không? Vì vậy cách này cũng có thể đến được nhớ khá nhanh.
But then, and also having fewer longer wires, we just have a couple this kind of longer wires, but then have dedicated circuits.
Nhưng đồng thời, cũng có ít dây dài hơn, chúng ta chỉ có vài dây dài kiểu này, nhưng lại có các mạch chuyên dụng.
The top half of the tree will have a more dedicated circuits for the top half of the tree, right? So that's another tree structure.
Nửa trên của cây sẽ có các mạch chuyên dụng hơn cho nửa trên của cây, đúng không? Đó là một cấu trúc cây khác.
We think about different ways of organizing this propagate and the generate. So, so far, all the tree structures are talking about P and the G. So we're talking about propagate and generate signals.
Chúng ta nghĩ về những cách khác nhau để tổ chức tín hiệu lan truyền và tín hiệu tạo. Vậy cho đến giờ, tất cả các cấu trúc cây đều nói về P và G. Tức là chúng ta đang nói về các tín hiệu propagate và generate.
So, what's a Boolean, so we talked about the carry is basically generate and the carry, right? So that's the operation that we're using to do that.
Vậy, biểu thức Boolean là gì, chúng ta đã nói nhớ về cơ bản là generate và nhớ, đúng không? Đó là phép toán mà chúng ta dùng để làm việc đó.
And the generate is basically, let me go to the first slide. Well, generate is basically A and B, and propagate is A XOR B, right?
Còn generate về cơ bản là, để tôi quay lại slide đầu tiên. À, generate về cơ bản là A AND B, còn propagate là A XOR B, đúng không?
So this is basically a bunch of OR and XOR gates that are doing here.
Vậy đây về cơ bản là một loạt cổng OR và XOR đang làm việc ở đây.
Okay, so each of those nodes is one of those compound operations.
Được rồi, mỗi nút đó là một trong các phép toán ghép này.
We don't actually need to worry about the actual propagate.
Thực ra chúng ta không cần lo về propagate thực sự.
And so, when you go from one of those nodes to some, there's some that we, for example, in the, since you get two very responsive, the S0 would just be the AND A0 to 0.
Và khi đi từ một trong các nút đó đến một số nút, có một số mà chúng ta, ví dụ, trong trường hợp này, vì bạn có hai đáp ứng rất nhanh, S0 sẽ chỉ là phép AND của A0 với 0.
And then the S1, we have the AND A0 to 0. But also this node, and that would just be generating at that point.
Và sau đó với S1, chúng ta có phép AND của A0 với 0. Nhưng cũng có nút này, và khi đó nó sẽ chỉ là generate.
Oh, generate is the A1 to 1, and propagate, carry, S0.
À, generate là A1 với 1, và propagate, nhớ, S0.
So, let's see. Let's do a smaller redex here.
Nào, xem nào. Hãy làm một ví dụ nhỏ hơn ở đây.
Right, so basically every stage, we have basically AND and OR operation here. That's for each of the stage. That's basically what we are doing to generate each of the stage here, right?
Đúng rồi, về cơ bản ở mỗi tầng, chúng ta có phép AND và phép OR ở đây. Đó là cho mỗi tầng. Về cơ bản đó là những gì chúng ta làm để tạo ra từng tầng ở đây, đúng không?
So each of this node is basically AND gate followed by an OR gate, right? Each of this node.
Vậy mỗi nút này về cơ bản là một cổng AND theo sau là một cổng OR, đúng không? Mỗi nút này.
Actually, this, this part.
Thực ra là phần này.
So that's a generate signal, and then we have this AND signal, AND all those things together for the propagate signal.
Đây là tín hiệu generate, rồi chúng ta có tín hiệu AND này, AND tất cả những thứ đó lại với nhau để ra tín hiệu propagate.
Generate signal is the one that goes up to the sum bit.
Tín hiệu generate là tín hiệu đi lên bit tổng.
It means this part, basically.
Tức là phần này, về cơ bản.
The generate signal, let me double check how the sum can be rewrite here.
Tín hiệu generate, để tôi kiểm tra lại xem tổng có thể được viết lại như thế nào ở đây.
One second.
Chờ một chút.
So, actually, so sum is propagate, XOR, carry in. So that's a sum signal to generate the sum. Yeah.
Vậy, thực ra tổng là propagate, XOR, carry in. Đó là tín hiệu tổng để tạo ra tổng. Vâng.
So sum signal was, in the A and B, is A XOR B XOR carry in. Right? And A XOR B is the propagate signal, right, in the rewrite.
Vậy tín hiệu tổng, với A và B, là A XOR B XOR carry in. Đúng không? Và A XOR B chính là tín hiệu propagate, đúng không, khi viết lại.
Correct.
Chính xác.
Yes. So this will be the carry in, and this will be the propagate, and the propagate is generated by the black dots. So each of these is basically an XOR gate.
Vâng. Vậy đây sẽ là carry in, và đây sẽ là propagate, và propagate được tạo ra bởi các chấm đen. Vậy mỗi cái này về cơ bản là một cổng XOR.
Signal going...
Tín hiệu đi...
You mean this square?
Ý bạn là hình vuông này à?
Oh, okay. So this square, we assume the A and B can always be pre-computed for that bit, right?
À, được rồi. Vậy hình vuông này, chúng ta giả sử A và B luôn có thể được tính trước cho bit đó, đúng không?
So this square is basically the XOR gate, and the carry in is what's coming to the square.
Vậy hình vuông này về cơ bản là cổng XOR, và carry in là thứ đi vào hình vuông.
So here, this XOR.
Vậy ở đây, XOR này.
Right, so because we only need the carry in, right, and then we XOR, so the sum stage is basically an XOR gate.
Đúng, vì chúng ta chỉ cần carry in, rồi XOR, nên tầng tính tổng về cơ bản là một cổng XOR.
Okay. Any other questions? Makes sense? Kind of? Okay.
Được rồi. Còn câu hỏi nào khác không? Có hợp lý không? Tạm hiểu? Được rồi.
So when you do a Verilog variable and you say some wire sum will be A plus B, what do you synthesize? So, most of the time, it's synthesized into a parallel prefix tree adder.
Vậy khi bạn viết một biến Verilog và nói wire sum bằng A cộng B, thì nó tổng hợp ra cái gì? Phần lớn thời gian, nó được tổng hợp thành bộ cộng parallel prefix tree.
They may actually do some internal optimization. The tool is actually pretty good at doing these optimizations there. So generally, you just use addition. We'll talk about multiply, or just use multiply.
Thực ra công cụ có thể tự tối ưu hóa bên trong. Công cụ làm các tối ưu hóa này khá tốt. Nên nhìn chung bạn cứ dùng phép cộng. Chúng ta sẽ nói về phép nhân, hoặc cứ dùng phép nhân.
So you don't actually need to design those adders in a structural way. Does it make sense to synthesize a parallel prefix tree?
Vậy bạn thực sự không cần thiết kế các bộ cộng đó theo kiểu cấu trúc. Có nên tự tổng hợp một parallel prefix tree không?
Generally, no. I don't know whether the tool actually exposes that. Internally, they will consider a different trade-off, but they will just do a generated adder directly.
Nhìn chung là không. Tôi không biết công cụ có thực sự cho phép làm điều đó không. Bên trong, chúng sẽ cân nhắc một sự đánh đổi khác, nhưng chúng chỉ trực tiếp tạo ra một bộ cộng được sinh sẵn.
But if you are actually working on very high performance, where the adder having a high...
Nhưng nếu bạn thực sự làm việc với hiệu năng rất cao, mà ở đó bộ cộng có cao...
You can actually do some manual design there. But in most of the cases, just use the tool; it basically handles that. Any other questions? With the reduction tree?
thì bạn thực sự có thể thiết kế thủ công một phần ở đó. Nhưng trong hầu hết các trường hợp, cứ dùng công cụ; về cơ bản nó xử lý việc đó. Còn câu hỏi nào khác không? Về cây rút gọn?
Okay, so we spent a lot of time talking about adders, right? We say this is a common building block of our system.
Được rồi, vậy chúng ta đã dành nhiều thời gian nói về bộ cộng, đúng không? Chúng ta nói đây là một khối xây dựng phổ biến của hệ thống.
Carry is a critical path, and we talk about two different ways, like carry-skip adder and also carry-lookahead tree adder, for thinking about adder design. A lot of low-level implementation, low-level details.
Nhớ là một đường tới hạn, và chúng ta đã nói về hai cách khác nhau, như bộ cộng carry-skip và bộ cộng dạng cây carry-lookahead, để suy nghĩ về thiết kế bộ cộng. Có nhiều chi tiết cài đặt ở mức thấp.
So hopefully, we at least get the high-level ideas of how this works. Okay, so next we're going to transition to multipliers, right? So once we have an adder, right?
Hy vọng ít nhất chúng ta nắm được các ý tưởng ở mức cao về cách nó hoạt động. Được rồi, tiếp theo chúng ta sẽ chuyển sang bộ nhân, đúng không? Vậy khi đã có bộ cộng, đúng không?
So the next question is actually how we actually do multiplication, right?
Thì câu hỏi tiếp theo là thực sự làm phép nhân như thế nào, đúng không?
And you will see, actually, with multiplication, it's basically just a bunch of adders, like using a bunch of adders to add a bunch of partial sums together, right?
Và các bạn sẽ thấy, với phép nhân, về cơ bản nó chỉ là một loạt bộ cộng, tức là dùng một loạt bộ cộng để cộng nhiều tổng riêng phần với nhau, đúng không?
So the computation that happens in a multiplier is actually very similar to the addition, right?
Vậy phép tính diễn ra trong một bộ nhân thực ra rất giống với phép cộng, đúng không?
The way we actually do multiplication by hand, we actually go through, like, position by position, do the individual multiplications, and then actually sum them together, right?
Cách chúng ta nhân bằng tay, là đi qua từng vị trí một, thực hiện từng phép nhân riêng lẻ, rồi cộng chúng lại với nhau, đúng không?
So in a binary multiplier, we actually do the same thing, right?
Vậy trong bộ nhân nhị phân, chúng ta cũng làm y như thế, đúng không?
So for each bit, we actually multiply each of the bits in the multiplier with each of the bits in the multiplicand, and then we add them together, right?
Với mỗi bit, chúng ta nhân từng bit của số nhân với từng bit của số bị nhân, rồi cộng chúng lại với nhau, đúng không?
So that's basically how we learn how multiplication works. That's also how we implement multipliers in actual hardware. So specifically, let's look at multiplication, right? We have two operands, input A and input B.
Về cơ bản đó là cách chúng ta học phép nhân hoạt động. Đó cũng là cách chúng ta cài đặt bộ nhân trong phần cứng thực tế. Cụ thể, hãy xem phép nhân, đúng không? Chúng ta có hai toán hạng, đầu vào A và đầu vào B.
We want to multiply them together, right? So first, we mentioned the first step is basically to produce the partial products, right?
Chúng ta muốn nhân chúng với nhau, đúng không? Trước hết, bước đầu tiên về cơ bản là tạo ra các tích riêng phần, đúng không?
So each of the bits in our multiplier, we actually multiply with each of the bits in our multiplicand, right? From A0 all the way to A3, right?
Với mỗi bit trong số nhân, chúng ta nhân nó với từng bit trong số bị nhân, đúng không? Từ A0 cho đến A3, đúng không?
We do this for every bit of B, right? So B0, B1, B2, B3, and then we're doing 4-bit multiplication, so we have basically 16 partial products, right?
Chúng ta làm vậy cho mọi bit của B, đúng không? Tức là B0, B1, B2, B3, và vì ta đang nhân 4 bit, nên có tất cả 16 tích riêng phần, đúng không?
So all the partial products need to actually be summed together to actually create our final product, right? So you'll see, This is basically, we're still doing addition.
Tất cả các tích riêng phần này cần được cộng lại với nhau để tạo ra tích cuối cùng, đúng không? Vậy các bạn thấy, về cơ bản chúng ta vẫn đang làm phép cộng.
All of those partial products need to be actually summed together to produce a final product. And there are actually different ways to design multipliers.
Tất cả các tích riêng phần đó cần được cộng lại với nhau để tạo ra tích cuối cùng. Và thực ra có nhiều cách khác nhau để thiết kế bộ nhân.
One thing you will see in the multiplier designs are basically either reduce the number of partial products, right?
Điều bạn sẽ thấy ở các thiết kế bộ nhân là về cơ bản hoặc giảm số lượng tích riêng phần, đúng không?
So we have fewer number of partial products so that we can actually make our multiplier faster, right? Second is to actually reduce the depth of this kind of multiplication, this partial sum summation, right?
Tức là ta có ít tích riêng phần hơn để có thể làm cho bộ nhân chạy nhanh hơn, đúng không? Cách thứ hai là giảm độ sâu của kiểu phép nhân này, tức là phép cộng các tổng riêng phần này, đúng không?
So reduce the depth of this so that we can actually do fewer levels of summation faster. So those are the general ways of actually doing multiplication.
Vậy ta giảm độ sâu của nó để có thể thực hiện phép cộng với ít tầng hơn và nhanh hơn. Đó là những cách chung để thực hiện phép nhân.
We'll talk about how we actually design multipliers later. But eventually, the computation we're doing is basically produce all the partial products, sum them together.
Sau này ta sẽ nói về cách thiết kế các bộ nhân. Nhưng cuối cùng, phép tính ta làm về cơ bản là tạo ra tất cả các tích riêng phần, rồi cộng chúng lại với nhau.
And then in the summation process, we can reduce the number of partial products. We could also reduce the depth of the tree so that we can actually run things faster, right?
Và trong quá trình cộng, ta có thể giảm số lượng tích riêng phần. Ta cũng có thể giảm độ sâu của cây để có thể chạy nhanh hơn, đúng không?
So that will be what we will actually talk about, how we actually talk about different ways to actually design multipliers. Before we get to actually more complex multiplier design, right?
Đó sẽ là điều ta nói tới, tức là các cách khác nhau để thiết kế bộ nhân. Trước khi đến với các thiết kế bộ nhân phức tạp hơn, đúng không?
Since all we are doing is basically addition, right? A very simple multiplier is basically just use an adder, which just iteratively adds all the basically 16 partial sums that we've seen earlier together.
Vì tất cả những gì ta làm về cơ bản là phép cộng, đúng không? Một bộ nhân rất đơn giản là chỉ dùng một bộ cộng, lặp đi lặp lại việc cộng tất cả 16 tổng riêng phần mà ta đã thấy ở trên với nhau.
So we basically just have a single adder design. And then we just iterate them like multiple times to actually get all the different, get the final summation, right?
Tức là ta chỉ có một bộ cộng duy nhất. Rồi ta lặp lại nó nhiều lần để có được các kết quả khác nhau, để có được tổng cuối cùng, đúng không?
So this is a very sequential adder. We just keep adding them. And it takes actually n cycles to actually do this, right? Because every cycle we perform one level of addition, right?
Đây là một bộ cộng tuần tự. Ta cứ tiếp tục cộng. Và việc này mất n chu kỳ, đúng không? Vì mỗi chu kỳ ta thực hiện một tầng phép cộng, đúng không?
So it takes time to actually add them together. So all the optimization is basically how we can reduce this to a smaller number.
Nên cần thời gian để cộng chúng lại với nhau. Vậy mọi sự tối ưu hóa là làm sao giảm con số này xuống nhỏ hơn.
We basically mentioned we want to either reduce the number of partial products. That's one of the general styles of optimization.
Ta đã nói là muốn hoặc giảm số lượng tích riêng phần. Đó là một trong những kiểu tối ưu hóa chung.
The other is to reduce the depths of the reduction tree so that we can actually do the partial product summation faster, right?
Kiểu còn lại là giảm độ sâu của cây rút gọn để có thể cộng các tích riêng phần nhanh hơn, đúng không?
So before we talk about, we'll talk about some of the optimizations next when we actually approach multiplier, generally thinking about that way, those two general ways of doing optimization.
Vậy trước khi nói, ta sẽ nói về một số cách tối ưu hóa ở phần sau khi tiếp cận bộ nhân, nghĩ chung theo hướng đó, tức là hai cách tối ưu hóa chung ấy.
Before that, we're going to quickly go through some of the announcements for the class. So let's see, the first midterm feedback.
Trước đó, ta sẽ điểm nhanh qua một số thông báo của lớp. Nào, trước hết là phản hồi về bài giữa kỳ thứ nhất.
So generally, all of you folks, most of you folks did actually pretty well in the midterm. So good job. We have been receiving some of the different comments from different students.
Nhìn chung, các bạn, phần lớn các bạn làm bài giữa kỳ khá tốt. Làm tốt lắm. Chúng tôi đã nhận được một số ý kiến khác nhau từ các sinh viên.
They want a more individual feedback, especially for students who didn't do too well in the midterm, and you want to see how we can actually help you to improve.
Các bạn muốn có phản hồi riêng cho từng người hơn, đặc biệt là những bạn làm bài giữa kỳ chưa tốt, và muốn biết chúng tôi có thể giúp các bạn tiến bộ như thế nào.
So feel free to reach out to me or whoever the staff that you are mostly comfortable with.
Vì vậy, các bạn cứ thoải mái liên hệ với tôi hoặc bất kỳ thành viên nào trong đội ngũ giảng dạy mà các bạn cảm thấy thoải mái nhất.
We are very open to, also happy to give you some guidance and also go through the problems that you have in the midterm and see how we can help.
Chúng tôi rất cởi mở và cũng sẵn lòng hướng dẫn các bạn đồng thời cùng xem lại các bài mà các bạn gặp khó khăn trong bài giữa kỳ và xem chúng tôi có thể giúp gì.
Right. So again, the midterm is really just supposed to be a reminder to see whether you're on track or not. And if you're not, how we can actually help you to improve. Right.
Được chứ. Một lần nữa, bài giữa kỳ thực ra chỉ để nhắc nhở xem các bạn có đang đi đúng hướng hay không. Và nếu chưa, chúng tôi có thể giúp các bạn cải thiện như thế nào. Đúng không.
So as I mentioned, I'm not too worried about the midterm, but if you want to get some feedback, just feel free to reach out to us directly.
Như tôi đã nói, tôi không quá lo về bài giữa kỳ, nhưng nếu muốn nhận phản hồi, các bạn cứ liên hệ trực tiếp với chúng tôi.
Starting from this point, the most important thing is the project. So our project is very important, especially with Checkpoint 2. The majority of you folks have finished Checkpoint 1, so that's great. Good job.
Từ giờ trở đi, điều quan trọng nhất là dự án. Dự án của chúng ta rất quan trọng, đặc biệt là Checkpoint 2. Phần lớn các bạn đã hoàn thành Checkpoint 1, thế là tốt. Làm tốt lắm.
Checkpoint 2 is very substantial. That's basically the meat of this project. So definitely spend a solid amount of, like, roughly two weeks on this part to actually get all the different modules implemented.
Checkpoint 2 rất đồ sộ. Về cơ bản đó là phần cốt lõi của dự án này. Vì vậy hãy dành một khoảng thời gian thực sự đáng kể, khoảng hai tuần cho phần này để triển khai tất cả các mô-đun khác nhau.
As for the FPGA folks, I think there are some testing issues with the repository. The staff are fixing that now.
Với các bạn làm FPGA, tôi nghĩ có một số vấn đề về kiểm thử trong kho mã nguồn. Đội ngũ đang sửa lỗi đó.
They should maybe have already released or in the process of release during the lecture. So the lab should be actually updated before the labs in the afternoon.
Có thể họ đã phát hành rồi hoặc đang phát hành trong lúc chúng ta học. Vì vậy bài thực hành sẽ được cập nhật trước các buổi thực hành buổi chiều.
So you should actually get all the issues fixed for moving forward for your implementation. And we'll have a new homework this week. What's that? Homework 7.
Như vậy các bạn sẽ có mọi lỗi được sửa để tiếp tục triển khai phần của mình. Và tuần này sẽ có bài tập về nhà mới. Bài nào nhỉ? Bài tập 7.
Homework 8. Yeah, I think it's homework 8. So this will be on adder and McGuire. We went through the different designs. The homeworks are not too difficult.
Bài tập 8. Vâng, tôi nghĩ là bài tập 8. Bài này về bộ cộng và McGuire. Chúng ta đã đi qua các thiết kế khác nhau. Các bài tập về nhà không quá khó.
They are basically just reveal the material we covered in discussions and lectures, right?
Về cơ bản chúng chỉ giúp ôn lại kiến thức mà chúng ta đã học ở các buổi thảo luận và bài giảng, đúng không?
So use this homework to reveal, give you an opportunity to reveal the lectures and discussions and understand, again, the high level principles. Okay, I think those are the high announcement.
Vì vậy hãy dùng bài tập này để ôn lại, đây là cơ hội để các bạn ôn lại bài giảng và buổi thảo luận và hiểu một lần nữa, các nguyên lý ở mức cao. Được rồi, tôi nghĩ đó là những thông báo chính.
Any feedback, questions, comments with where we are? So what's not mentioned is the GSI strike on Monday.
Có phản hồi, câu hỏi hay ý kiến nào về tiến độ hiện tại không? Điều chưa được nhắc đến là cuộc đình công của GSI vào thứ Hai.
So what would happen regarding office hours, labs, etc.? So 7 was released. There will be a new homework this week. So 7 is on the Elmore delay, the RC delay part.
Vậy giờ hỗ trợ, buổi thực hành, v.v. sẽ ra sao? Bài 7 đã được phát hành. Tuần này sẽ có một bài tập về nhà mới. Bài 7 về độ trễ Elmore, phần độ trễ RC.
This is a new homework on adder and McGuire. Yeah, homework 7 is due this week. There was a question online. Yes, I was mentioning about the strike that's likely to happen on the 14th.
Đây là bài tập mới về bộ cộng và McGuire. Vâng, bài tập 7 hạn nộp trong tuần này. Có một câu hỏi trực tuyến. Vâng, tôi muốn nói về cuộc đình công có khả năng xảy ra vào ngày 14.
So what would happen regarding lectures, office hours, labs, etc.? Oh, are you asking the strike happening next week? Yes. Oh, I see.
Vậy các buổi giảng, giờ hỗ trợ, buổi thực hành, v.v. sẽ ra sao? À, bạn hỏi về cuộc đình công tuần sau phải không? Vâng. À, tôi hiểu rồi.
So I believe both parties are negotiating very actively these days. So from our point of view, we don't know what's the outcome of the negotiation.
Tôi tin rằng cả hai bên đang đàm phán rất tích cực những ngày này. Về phía chúng tôi, chúng tôi không biết kết quả đàm phán sẽ ra sao.
We certainly hope the negotiation is a successful negotiation. So we'll see what happens next Monday. At this point, we don't have a lot of visibility on what's going on.
Chúng tôi chắc chắn hy vọng cuộc đàm phán sẽ thành công. Vậy chúng ta sẽ xem chuyện gì xảy ra vào thứ Hai tới. Hiện tại, chúng tôi không nắm được nhiều thông tin về tình hình.
Our staff do have their own freedom in whether if negotiation was not a successful one. We certainly don't hope that happens.
Các thành viên trong đội ngũ của chúng tôi có quyền tự do quyết định, trong trường hợp cuộc đàm phán không thành công. Tất nhiên chúng tôi không mong điều đó xảy ra.
But the staff does have the option to exercise their freedom in whether they want to continue holding their labs, office hours or not. But we'll have to wait until next week. Thank you.
Nhưng các thành viên có quyền lựa chọn thực hiện quyền tự do của họ về việc có tiếp tục tổ chức buổi thực hành, giờ làm việc hay không. Nhưng chúng ta phải đợi đến tuần sau. Cảm ơn bạn.
Yeah, well, definitely. Again, we hope the negotiation is successful, but we'll keep you folks posted on our plan and what are the options next week.
Vâng, chắc chắn rồi. Một lần nữa, chúng tôi hy vọng đàm phán thành công, nhưng chúng tôi sẽ cập nhật cho các bạn về kế hoạch và các phương án trong tuần sau.
Any other questions?
Còn câu hỏi nào khác không?
Okay, so that's all the announcement related topics again for midterm. I noticed some of the folks are reaching out to add individually.
Được rồi, vậy là hết các thông báo liên quan đến bài kiểm tra giữa kỳ. Tôi thấy một số bạn đang liên hệ riêng với chúng tôi.
But again, feel free to just stop by our office hours and share our concerns. I wouldn't worry too much, especially if you are like above me or pretty near the me.
Nhưng một lần nữa, các bạn cứ ghé giờ làm việc của chúng tôi và chia sẻ mối lo của mình. Tôi sẽ không lo lắng quá nhiều, đặc biệt nếu điểm của bạn cao hơn tôi hoặc khá gần tôi.
You just get at least like half of the points for the midterm. If that, I wouldn't just worry too much. I think you are doing very well, actually.
Bạn đạt ít nhất khoảng một nửa số điểm của bài giữa kỳ. Nếu vậy thì tôi sẽ không lo quá. Thật ra tôi nghĩ các bạn đang làm rất tốt.
But if you are actually more like getting like less than 20 points out of the midterm, you want to actually have a discussion.
Nhưng nếu bạn thực sự chỉ đạt dưới 20 điểm trong bài giữa kỳ, thì bạn nên trao đổi với chúng tôi.
We're certainly very happy to have a discussion on the midterm feedback.
Chúng tôi rất sẵn lòng trao đổi về nhận xét bài giữa kỳ.
Okay.
Được rồi.
Why there is a mux?
Tại sao ở đây có một mux?
You mean this adder?
Ý bạn là bộ cộng này?
Oh, you mean this one. So this is the adder. Oh, to the right of it. Oh, so why, why this is so you will go back to this.
À, ý bạn là cái này. Đây là bộ cộng. À, bên phải của nó. À, vậy tại sao, tại sao cái này, nên ta quay lại chỗ này.
So there's basically zero here. Right. So we basically you look at A is basically shifted here. Right.
Vậy về cơ bản ở đây là số không. Đúng không. Ta xem A về cơ bản được dịch ở đây. Đúng không.
You basic. Yeah.
Về cơ bản. Vâng.
Oh, actually, I think I was saying something wrong. So this shift is actually handled by this shift register.
À, thật ra tôi nghĩ vừa rồi tôi nói sai. Phép dịch này thực ra được xử lý bởi thanh ghi dịch này.
What I said here, but what A is doing is basically whether look at the selection of the mux is basically the value of B.
Điều tôi nói ở đây nhưng việc A làm về cơ bản là xem xét đầu vào chọn của mux về cơ bản là giá trị của B.
Right. So if B is zero, we don't need to actually do any addition. And then we'll just get zero directly.
Đúng không. Nếu B bằng không, ta thực ra không cần cộng gì cả. Và ta sẽ nhận trực tiếp số không.
If B is one, we actually get in the value of one. But the value of A. Right. So if B is zero.
Nếu B bằng một, ta nhận được giá trị là một. Nhưng là giá trị của A. Đúng không. Vậy nếu B bằng không.
If this is a zero, we don't need to do any addition because all of this will be zero. Right.
Nếu đây là số không, ta không cần cộng gì cả vì tất cả chỗ này sẽ là không. Đúng không.
So this mux is basically controlled by B is zero or just through the zero directly in this one. We actually picks up, picks a value.
Vậy mux này về cơ bản được điều khiển bởi B bằng không hoặc cho số không đi thẳng qua ở đây. Nó thực ra chọn ra một giá trị.
You can think of this basically the end date. Right? Makes sense? Okay. Yes. So that's what this is doing.
Bạn có thể xem nó về cơ bản như cổng AND. Đúng không? Hợp lý chứ? Được rồi. Vâng. Vậy đó là việc phần này đang làm.
And the shift is actually handled by the shift register we're using here. Right. Oh, why not just use...
Còn phép dịch thì được xử lý bởi thanh ghi dịch mà ta đang dùng ở đây. Đúng không. Ồ, sao không dùng...
Yeah, so this is basically an individual bit of B. Right.
Vâng, đây về cơ bản là một bit riêng lẻ của B. Đúng không.
So then you're basically doing a bitwise operation for each individual bit of B, versus we just have a mux and then select whether we want to get the value of A or zero here.
Vậy là bạn về cơ bản đang thực hiện một phép toán theo từng bit cho mỗi bit riêng lẻ của B, còn ở đây ta chỉ có một mux rồi chọn xem ta muốn lấy giá trị của A hay là 0.
Yeah.
Vâng.
Yeah. It's a select signal. Yeah, both are basically both are known, right? They're not changing. And the only thing changing, speed.
Vâng. Đó là tín hiệu chọn. Vâng, cả hai về cơ bản đều đã biết, đúng không? Chúng không thay đổi. Và thứ duy nhất thay đổi là tốc độ.
Otherwise you're basically toggling these registers every cycle, right, based on the value of B, and then you're changing the values in. So this is a mux. Any other questions on this?
Nếu không thì về cơ bản bạn phải đảo các thanh ghi này mỗi chu kỳ, đúng không, dựa trên giá trị của B, rồi bạn thay đổi các giá trị trong đó. Vậy đây là một mux. Còn câu hỏi nào khác về phần này không?
Okay, good.
Được rồi, tốt.
Okay, so we talked about the basic other designs. Sorry, basic multiplier designs. And the first step actually doing optimization is to actually leverage the parallelism in our multiplier.
Vậy là ta đã nói về các thiết kế cơ bản khác. Xin lỗi, các thiết kế bộ nhân cơ bản. Và bước đầu tiên để thực sự tối ưu hóa là tận dụng tính song song trong bộ nhân của ta.
We have so many different partial products, right? Let's leverage the parallelism to actually build a parallel multiplier to do things faster.
Ta có rất nhiều tích riêng khác nhau, đúng không? Hãy tận dụng tính song song để xây dựng một bộ nhân song song, làm mọi thứ nhanh hơn.
So basically this implementation is a basic direct translation of what we have here. We have different partial products that need to be actually summed together.
Vậy về cơ bản cách triển khai này là một bản chuyển trực tiếp của những gì ta có ở đây. Ta có các tích riêng khác nhau cần được cộng lại với nhau.
And then we just instantiate in parallel for each of the additions.
Và ta chỉ việc tạo song song một khối cho mỗi phép cộng.
We instantiate a full adder here, and some of the half adders, full adders and half adders, to actually perform the addition explicitly.
Ta tạo một bộ cộng đầy đủ (full adder) ở đây, và một số bộ nửa cộng (half adder), full adder và half adder, để thực hiện phép cộng một cách tường minh.
Right, all of those can actually be done in parallel because there's no, no, actually, a lot of them can be actually...
Đúng, tất cả chúng đều có thể làm song song vì không có, không, thật ra là nhiều cái trong số đó có thể...
So some of those are actually still dependent here. So what we can do is basically do this again in three stages.
Một số trong đó vẫn còn phụ thuộc nhau ở đây. Vậy điều ta có thể làm là chia việc này thành ba giai đoạn.
First is actually to produce a partial product, we mentioned earlier, using this AND gate, right? So produce the partial product, right?
Đầu tiên là tạo ra tích riêng, như ta đã nói trước đó, bằng cổng AND này, đúng không? Vậy là tạo ra tích riêng, đúng không?
We'll have every a, and which ANDs every bit of A, and then, and the corresponding bit of B, and then we can actually produce the partial product, right?
Ta sẽ có mỗi a, thực hiện AND từng bit của A, với bit tương ứng của B, và như vậy ta có thể tạo ra tích riêng, đúng không?
Once we get the partial product, we can actually start doing summation, right? So summation, we can actually basically use an array of adders to actually sum things together, right?
Khi đã có tích riêng, ta có thể bắt đầu cộng, đúng không? Về phép cộng, ta về cơ bản có thể dùng một mảng các bộ cộng để cộng mọi thứ lại với nhau, đúng không?
So we have an array of adders. If we don't have additional input, we only have two inputs, so half adder, right?
Vậy ta có một mảng các bộ cộng. Nếu không có đầu vào bổ sung, ta chỉ có hai đầu vào, thì dùng half adder, đúng không?
You will have three inputs, both A and B and a carry, and then we took it to a full adder, right?
Còn nếu có ba đầu vào, cả A, B và một bit nhớ, thì ta đưa vào một full adder, đúng không?
And then we can basically lay out a parallel multiplier there by having an array of adders here.
Và rồi về cơ bản ta có thể bố trí một bộ nhân song song bằng cách có một mảng các bộ cộng ở đây.
Making sense, each individual building block here?
Từng khối xây dựng ở đây có dễ hiểu không?
So we basically, so for the first level here, right, to produce a partial product, we basically have a zero, and then, and with all the B elements here, right?
Vậy về cơ bản, ở tầng đầu tiên này, để tạo ra tích riêng, ta có một số 0, rồi thực hiện AND với tất cả các phần tử B ở đây, đúng không?
And then, actually, so this is a, so this is actually more layout this way.
Và rồi, thật ra thì đây là, đây thật ra là cách bố trí layout theo hướng này.
So we actually produce a partial product here, and then for the next, we produce a partial product here, right?
Vậy là ta tạo ra một tích riêng phần ở đây, và sau đó ở hàng tiếp theo, ta tạo ra một tích riêng phần ở đây, đúng không?
Once we have two vectors, a partial product, we can start doing addition to start actually generate, consolidate the partial product. And then we can do partial sums moving forward. Makes sense?
Khi đã có hai vectơ tích riêng phần, ta có thể bắt đầu thực hiện phép cộng để tạo ra, để gộp các tích riêng phần lại. Rồi ta tính các tổng riêng phần tiếp tục về phía sau. Hiểu chứ?
I feel like I lost most of you.
Tôi thấy hình như tôi làm các bạn mất dấu rồi.
A zero. Okay.
A0. Được rồi.
Yeah, so that's why this is basically the first element here, right?
Vâng, vậy nên đây chính là phần tử đầu tiên ở đây, đúng không?
So right, and then a one is basically the next row, and a two, next row, next column, next column.
Đúng rồi, và A1 chính là hàng tiếp theo, và A2 là hàng kế tiếp, cột kế tiếp, cột kế tiếp.
Yeah.
Vâng.
So the first level is basically just the AND gate, because we just produce the partial sum. Once we produce the second column of partial sum, we can start doing addition, right?
Vậy tầng đầu tiên chỉ là các cổng AND, vì ta chỉ tạo ra các tích riêng phần. Khi đã tạo ra cột tích riêng phần thứ hai, ta có thể bắt đầu cộng, đúng không?
So that's why we introduce the array of adders here. And then we just propagate in this wave of addition.
Đó là lý do ta đưa vào mảng các bộ cộng ở đây. Rồi ta cứ lan truyền theo làn sóng phép cộng này.
Questions? Confused? No, we're just kind of like discussing the previous model.
Có câu hỏi nào không? Có chỗ nào chưa rõ không? Không, chúng tôi chỉ đang thảo luận về mô hình trước đó.
It does take n plot cycles to complete, however, it takes up a lot less area and has a much shorter critical path.
Nó cần n chu kỳ để hoàn thành, tuy nhiên nó chiếm diện tích ít hơn nhiều và có đường tới hạn ngắn hơn nhiều.
This one has a long critical path. Oh, that's a good question, right? So where is a critical path for this one?
Cái này có đường tới hạn dài. À, câu hỏi hay đấy. Vậy đường tới hạn của cái này nằm ở đâu?
The critical path would be from B3, through that AND gate in that right half adder, then through that to the carry out. Oh, B3, this one, yeah.
Đường tới hạn sẽ đi từ B3, qua cổng AND đó trong bộ nửa cộng bên phải, rồi qua đó đến ngõ ra nhớ. À, B3, cái này, vâng.
Yeah, B3, through that AND gate, through actually two AND gates, to that half adder on the left, and then down through that pull ladder, carry out to the other pull ladder, and then down to another pull ladder and through another pull ladder.
Vâng, B3, qua cổng AND đó, thật ra là qua hai cổng AND, đến bộ nửa cộng bên trái, rồi đi xuống qua bộ cộng đầy đủ đó, ngõ ra nhớ sang bộ cộng đầy đủ khác, rồi đi xuống một bộ cộng đầy đủ nữa và qua một bộ cộng đầy đủ nữa.
So that's, what is that, one, two, three, four pull ladders, a half adder, and two AND gates? Is this what I highlighted, is what you said, the critical path?
Vậy là, đó là gì nhỉ, một, hai, ba, bốn bộ cộng đầy đủ, một bộ nửa cộng và hai cổng AND? Cái tôi tô sáng có phải là đường tới hạn mà bạn nói không?
I think I was pointing the way that you made that. Oh, no, it's from that half adder down. From the half adder down, okay. Down to the pull ladder.
Tôi nghĩ tôi đang chỉ theo cách bạn đã vẽ. À không, nó đi từ bộ nửa cộng đó xuống. Từ bộ nửa cộng đi xuống, được rồi. Xuống bộ cộng đầy đủ.
From the half adder down to the pull adder. From the bottom output. Okay, and? The pull ladder, now, to the left. Oh, okay, so from the half adder, three pull ladder, pull over.
Từ bộ nửa cộng xuống bộ cộng đầy đủ. Từ ngõ ra phía dưới. Được rồi, và tiếp? Bộ cộng đầy đủ, rồi sang bên trái. À, được rồi, vậy từ bộ nửa cộng, ba bộ cộng đầy đủ, nhớ sang.
Okay. Then left to that pull ladder, the left. Here? Yes, and then down to the next pull ladder, pull over. Down to the next pull ladder, okay. Right pull ladder.
Được. Rồi sang trái đến bộ cộng đầy đủ bên trái. Ở đây phải không? Đúng, rồi đi xuống bộ cộng đầy đủ tiếp theo, nhớ sang. Xuống bộ cộng đầy đủ tiếp theo, được rồi. Bộ cộng đầy đủ bên phải.
Let me see, so Ben said we start from here, right, from this half adder.
Để tôi xem, vậy Ben nói ta bắt đầu từ đây, đúng không, từ bộ nửa cộng này.
Well, so first let's say this half adder, so of course we have this.
Vâng, trước hết hãy xét bộ half adder này, tất nhiên là chúng ta có cái này.
Right, so B1.
Đúng rồi, vậy là B1.
From B1 and then to the left.
Từ B1 rồi sang bên trái.
Left again. Oh, someone said done? Yes. So what if you want to do pull ladders?
Lại sang trái nữa. Ồ, có ai nói xong rồi à? Vâng. Vậy nếu muốn dùng các full adder thì sao?
So take all the, so take all the pull adders.
Vậy hãy lấy tất cả, lấy tất cả các full adder.
So basically, well, we have this half adder, and then pull adder, pull adder, pull adder, pull adder, pull adder, and then all the way to the final, right?
Về cơ bản, chúng ta có half adder này, rồi full adder, full adder, full adder, full adder, full adder, rồi đi hết đến cuối cùng, đúng không?
So this is our critical path. There could be more, like you can also branch out here, right? There are similar paths, yes.
Vậy đây là đường tới hạn của chúng ta. Có thể còn nhiều đường khác, chẳng hạn bạn cũng có thể rẽ nhánh ở đây, đúng không? Có những đường tương tự, đúng vậy.
Right, so this is, yes, so it's not only just a downward, right? You just think about the way we calculate, right? It's basically both across a column and across rows.
Đúng, vậy là nó không chỉ đi xuống dưới thôi, đúng không? Bạn chỉ cần nghĩ đến cách chúng ta tính toán, đúng không? Về cơ bản là đi cả theo cột lẫn theo hàng.
We just need to actually go through all the summations here. Ethan?
Chúng ta cần đi qua tất cả các phép cộng ở đây. Ethan?
Right, so this, so this critical path is actually significantly longer than what we had before. It's basically a single adder, right?
Đúng rồi, vậy là đường tới hạn này thực ra dài hơn đáng kể so với cái chúng ta có trước đó. Về cơ bản đó là một bộ cộng duy nhất, đúng không?
But that single adder has a register there because it's actually accumulated over time, versus this. It's basically accumulated. Well, it depends on whether we can achieve actually in a single cycle, right?
Nhưng bộ cộng duy nhất đó có một thanh ghi ở đó vì nó thực ra được tích lũy theo thời gian, so với cái này. Về cơ bản nó được tích lũy. Còn tùy việc liệu chúng ta có thể thực hiện trong một chu kỳ hay không, đúng không?
But this is actually accumulated over space, and then we just do everything in one shot. So that adder will be faster. The critical path is shorter.
Nhưng cái này thực ra được tích lũy theo không gian, rồi chúng ta làm mọi thứ trong một lần. Nên bộ cộng đó sẽ nhanh hơn. Đường tới hạn ngắn hơn.
This adder will be longer. The critical path is much longer.
Bộ cộng này sẽ chậm hơn. Đường tới hạn dài hơn nhiều.
For most of our general, for most of our multiplier designs, especially with today's technology, this can still fit actually in one clock cycles, actually, in most of the data, yes.
Với hầu hết các thiết kế bộ nhân thông thường của chúng ta, đặc biệt với công nghệ ngày nay, cái này vẫn có thể nằm gọn trong một chu kỳ xung nhịp, thực ra là trong hầu hết các trường hợp, vâng.
So even with all the different adders and half adders, they're actually still pretty fast. We can still fit pretty comfortably in one cycle.
Vậy dù có tất cả các bộ cộng và half adder khác nhau, chúng thực ra vẫn khá nhanh. Chúng ta vẫn có thể nhét khá thoải mái vào một chu kỳ.
So generally, when we actually get to multi-cycle arithmetic units, that's actually when we start doing actually a floating point calculation. So floating point calculation is typically pipeline. We'll talk about adder, like multiplier.
Nên nói chung, khi chúng ta đến các đơn vị số học nhiều chu kỳ, thì đó là lúc chúng ta bắt đầu thực hiện tính toán dấu phẩy động. Tính toán dấu phẩy động thường dùng đường ống. Chúng ta sẽ nói về bộ cộng, như bộ nhân.
Older generation technology, we'll also talk about pipeline multipliers. But more recently, especially with a whole machine learning push, everything is basically multiply and accumulate.
Với công nghệ thế hệ cũ, chúng ta cũng sẽ nói về các bộ nhân dùng đường ống. Nhưng gần đây hơn, đặc biệt với làn sóng học máy, mọi thứ về cơ bản là nhân và tích lũy.
So generally, multiplier can still also be done in one clock cycle. But this is definitely a very much longer critical path compared to the single cycle shift and add multiplier.
Nên nói chung, bộ nhân vẫn có thể thực hiện trong một chu kỳ xung nhịp. Nhưng chắc chắn đây là một đường tới hạn dài hơn nhiều so với bộ nhân dịch và cộng một chu kỳ.
So let's say this can generally fit in a clock cycle. So let's say roughly 1 gigahertz, 2 gigahertz clock.
Vậy giả sử cái này nói chung có thể nằm gọn trong một chu kỳ xung nhịp. Giả sử khoảng xung nhịp 1 gigahertz, 2 gigahertz.
It's going to be very hard to write, let's say, 32-bit, 32 gigahertz clock, even for a very simple adder and multiplier.
Sẽ rất khó để viết, giả sử là xung nhịp 32 gigahertz cho 32 bit, thì ngay cả với một bộ cộng và bộ nhân rất đơn giản cũng khó.
There's a scaling that is not biasing towards the sequential. There's accumulation over time design, which is relatively scaling and the speed of things. Yeah.
Có một kiểu co giãn không thiên về mạch tuần tự. Có thiết kế tích lũy theo thời gian, tương đối liên quan đến việc co giãn và tốc độ của các thành phần. Vâng.
Yeah, and memory. Typically, memory register file access is typically executed generally, not the longest task.
Vâng, và cả bộ nhớ nữa. Thông thường, việc truy cập bộ nhớ và register file thường được thực hiện không phải là tác vụ dài nhất.
So for example, not all the processors actually have a dedicated multiplier. So for Cortex-M0, yeah, so M0 is basically the ARM microcontroller.
Ví dụ, không phải bộ xử lý nào cũng có bộ nhân riêng. Như Cortex-M0, M0 về cơ bản là vi điều khiển ARM.
Even in our ISA, we're not implementing multipliers. So M0 is basically the equivalent of RISC-V, the base ISA. That basically actually doesn't have a multiplier.
Ngay cả trong ISA của chúng ta, chúng ta cũng không cài đặt bộ nhân. M0 về cơ bản tương đương với RISC-V, tức ISA cơ sở. Về cơ bản nó không có bộ nhân.
So if you actually do a multiplication, that actually takes 32 cycles to actually do a multiplication for Cortex-M0.
Vì vậy nếu bạn thực hiện một phép nhân, thì với Cortex-M0 phải mất 32 chu kỳ để thực hiện một phép nhân.
So sometimes people still skip actually multipliers for extremely edge-embedded system scenario where multiplication is actually not required. Like multiplication M extension is also an extension on RISC-V.
Vì thế đôi khi người ta vẫn bỏ bộ nhân trong các kịch bản hệ thống nhúng biên cực kỳ nhỏ mà phép nhân không thật sự cần thiết. Như phần mở rộng M cho phép nhân cũng là một phần mở rộng của RISC-V.
It's not included in the base ISA. But generally, yeah, memory stages, register file accesses, those are the critical tasks.
Nó không nằm trong ISA cơ sở. Nhưng nói chung, đúng vậy, các tầng bộ nhớ, truy cập register file, đó mới là những tác vụ tới hạn.
Intel started their business actually making calculators. So calculators are important. There was a question over here on multiplying.
Intel bắt đầu kinh doanh bằng việc sản xuất máy tính bỏ túi. Vậy nên máy tính bỏ túi rất quan trọng. Ở đây có một câu hỏi về phép nhân.
Yeah, so I was thinking maybe in reality, we have 4 bits in and also 4 bits out. So can it just be 5 bits out?
Vâng, em nghĩ có thể thực tế là vào 4 bit và ra cũng 4 bit. Vậy có thể ra chỉ 5 bit không ạ?
So for multiplication, do we have 4 bits in and 4 bits out? If we do a 4-bit and 4-bit multiplication, how many bits do we have? 8 bits.
Với phép nhân, có phải vào 4 bit và ra 4 bit không? Nếu nhân 4 bit với 4 bit thì ta có bao nhiêu bit? 8 bit.
Yeah, so we have 8 bits out, right? So basically, we're looking at Cortex-M0 extension. Is the resulting wire 64 or 33? So it's 64.
Đúng, vậy ta có 8 bit ở đầu ra, đúng không? Vậy về cơ bản, ta đang xét phần mở rộng của Cortex-M0. Dây kết quả là 64 hay 33? Là 64.
And then if you actually want to actually access, they're actually separate. Upper and lower. Upper. Lower. If you read the ISA. Yes, yes. So that's actually exposed to there. Yes.
Và nếu bạn muốn truy cập thì chúng tách biệt nhau. Phần cao và phần thấp. Cao. Thấp. Nếu bạn đọc ISA. Vâng, vâng. Vậy nên điều đó được phơi bày ở đó. Vâng.
I thought it was going to be for children, but it's like separate instructions for multiplying. I'm referring to lower half. Multiplying looks like the upper half.
Em tưởng nó sẽ dành cho trẻ em, nhưng hóa ra là có các lệnh nhân riêng biệt. Em đang nói đến nửa thấp. Phép nhân trông giống như nửa cao.
Upper half, yeah. Yeah, so the result is actually more than 4 bits. So that's why it's laid out in this way. Yeah, and this is a multiplier design, how we actually use adders there.
Nửa cao, vâng. Vâng, vậy kết quả có nhiều hơn 4 bit. Vì thế nó được bố trí theo cách này. Vâng, và đây là một thiết kế bộ nhân, cách ta dùng các bộ cộng ở đó.
You see all the critical paths here, basically connecting each of the four adders to actually get.
Bạn thấy tất cả các đường tới hạn ở đây, về cơ bản nối từng bộ trong bốn bộ cộng để lấy kết quả.
And this critical path is longer, but generally for multipliers, especially with today's multipliers, it fits in one clock cycle pretty comfortably.
Và đường tới hạn này dài hơn, nhưng nói chung với bộ nhân, nhất là các bộ nhân ngày nay, nó nằm gọn trong một chu kỳ xung nhịp khá thoải mái.
You will look at a more regular layout. The multiplier, or array multiplier, is basically what we discussed earlier, right? This is a more shifted version of the diagram that we had before. Right.
Bạn sẽ xem một cách bố trí đều đặn hơn. Bộ nhân, hay bộ nhân mảng, về cơ bản là cái ta đã thảo luận trước đó, đúng không? Đây là phiên bản dịch chuyển hơn của sơ đồ ta có trước đó. Đúng.
We basically have n times n parallel adders. And then we basically consolidate all the partial sums together, right?
Về cơ bản, ta có n nhân n bộ cộng song song. Và sau đó ta gộp tất cả các tổng riêng phần lại với nhau, đúng không?
Using all those adders to actually get our multiplied results. Right. So we talk about multiplier optimizations. Generally, there are like a lot of partial sums, right? Partial products need to be produced.
Dùng tất cả các bộ cộng đó để thực sự có được kết quả phép nhân. Đúng vậy. Vậy ta nói về các tối ưu hóa bộ nhân. Nhìn chung, có rất nhiều tổng riêng phần, đúng không? Các tích riêng phần cần được tạo ra.
Producing a partial product is not too hard, right? We can produce a partial product pretty easily. But the summation, the consolidation of the partial products, is actually the more challenging part.
Tạo ra một tích riêng phần không quá khó, đúng không? Ta có thể tạo ra một tích riêng phần khá dễ dàng. Nhưng việc cộng, việc gộp các tích riêng phần lại, mới thực sự là phần khó hơn.
I talk about there are two general ways to optimize a multiplier. The first is to reduce the number of partial products. We'll talk about that. That's the Booth encoding.
Tôi nói rằng có hai cách chung để tối ưu một bộ nhân. Cách thứ nhất là giảm số lượng tích riêng phần. Ta sẽ nói về điều đó. Đó là mã hóa Booth.
We'll talk about that more likely in the next lecture.
Nhiều khả năng ta sẽ nói về nó trong bài giảng tiếp theo.
But the second part is to think about the ways to actually reduce the depth of the tree, to actually do a slightly higher rate of reduction, so that we can actually do the partial product summation faster.
Nhưng cách thứ hai là nghĩ về những cách để thực sự giảm độ sâu của cây, để thực hiện tốc độ rút gọn cao hơn một chút, nhờ đó ta có thể cộng các tích riêng phần nhanh hơn.
We'll talk about that optimization, for how we can actually reduce the reduction depth, to actually do those parallel adders a little bit faster. So the idea here is that we need to do...
Ta sẽ nói về tối ưu hóa đó, về cách ta có thể giảm độ sâu rút gọn, để các bộ cộng song song đó chạy nhanh hơn một chút. Vậy ý tưởng ở đây là ta cần làm...
We basically need to do a lot of summation here, right? We produce this and all of those actually need to be accumulated, right? To actually get to the partial sum, right?
Về cơ bản ta cần thực hiện rất nhiều phép cộng ở đây, đúng không? Ta tạo ra cái này và tất cả chúng đều cần được cộng dồn, đúng không? Để có được tổng riêng phần, đúng không?
The idea, One thing we want to do is, actually, can we make the summation happen a little bit faster, right? So that we can produce the final result a little bit faster.
Ý tưởng, một điều ta muốn làm là, liệu ta có thể làm cho phép cộng diễn ra nhanh hơn một chút không? Để ta có thể tạo ra kết quả cuối cùng nhanh hơn một chút.
So, again, all we are doing is a lot of addition, right? How can we actually do the additions faster? There is an interesting idea, what people call CSA, or carry save addition.
Vậy, một lần nữa, tất cả những gì ta làm là rất nhiều phép cộng, đúng không? Làm sao ta có thể thực hiện các phép cộng nhanh hơn? Có một ý tưởng thú vị, mà người ta gọi là CSA, hay cộng lưu nhớ (carry save addition).
Again, we'll never talk about addition optimization, adder optimization, just figuring out a way to actually work around the carry propagation, right?
Một lần nữa, ta sẽ không bàn về tối ưu hóa phép cộng, tối ưu bộ cộng, mà chỉ tìm cách để né việc lan truyền nhớ, đúng không?
So, anything that we can basically reduce the carry propagation could actually help.
Vì vậy, bất cứ điều gì giúp ta giảm lan truyền nhớ đều có thể có ích.
What we really observed here is that, when we think about reduction or, like, the consolidation here, basically taking two values, producing the sum, and then doing that again.
Điều ta thực sự quan sát được ở đây là, khi ta nghĩ về việc rút gọn hay việc gộp ở đây, về cơ bản là lấy hai giá trị, tạo ra tổng, rồi lại làm như vậy lần nữa.
We'll keep doing that. What is the idea here? You think about addition, the critical path is always the carry, right?
Ta sẽ tiếp tục làm vậy. Ý tưởng ở đây là gì? Bạn nghĩ về phép cộng, đường tới hạn luôn là bit nhớ, đúng không?
But if we think about the traditional, we have input A, B, and the carry in, we produce sum and the carry out, right? So that's what we think about for adder here, right?
Nhưng nếu nghĩ theo cách truyền thống, ta có đầu vào A, B, và nhớ vào, ta tạo ra tổng và nhớ ra, đúng không? Đó là cách ta nghĩ về bộ cộng ở đây, đúng không?
So here, carry out is actually always propagated here. But the idea here is that for carry save addition, especially in the multiplication case, we're just saving a lot.
Vậy ở đây, nhớ ra luôn được lan truyền đi. Nhưng ý tưởng ở đây là với cộng lưu nhớ, đặc biệt trong trường hợp phép nhân, ta chỉ đang lưu lại rất nhiều.
We're trying to sum a lot of partial products together, right? We don't exactly need to propagate the carry.
Ta đang cố cộng rất nhiều tích riêng phần lại với nhau, đúng không? Ta không nhất thiết phải lan truyền bit nhớ.
Every step, we can really just save the carry as another operand.
Ở mỗi bước, ta thực sự có thể lưu bit nhớ lại như một toán hạng khác.
And then propagate the carry directly for multi-bit summation, instead of propagating or rippling through the carries to the output directly. So, basically, once we are using the integer example here, right?
Và sau đó lan truyền nhớ trực tiếp cho phép cộng nhiều bit, thay vì lan truyền hay đẩy tuần tự các bit nhớ qua đến đầu ra. Về cơ bản, khi ta dùng ví dụ với số nguyên ở đây, đúng không?
So we're actually adding the two values together, instead of producing the sum directly, where we actually ripple through the carry.
Ta đang cộng hai giá trị với nhau, thay vì tạo ra tổng trực tiếp, tức là phải lan truyền tuần tự qua bit nhớ.
What if we just save, we actually produce two things, the carry and sum individually.
Nếu ta chỉ lưu lại thì sao, ta tạo ra hai thứ, là bit nhớ và tổng một cách riêng rẽ.
Where sum is literally just summing each individual position of A and B, but we don't actually do the propagate or ripple. The carry, we just save carry directly.
Trong đó tổng đơn giản chỉ là cộng từng vị trí riêng lẻ của A và B, nhưng ta không thực hiện việc lan truyền hay đẩy tuần tự. Còn bit nhớ, ta chỉ lưu trực tiếp bit nhớ.
So here, everything is basically bitwise. We're basically looking at the bit and then producing carry and sum, but we never actually ripple through the carry across the bit position.
Vậy ở đây, mọi thứ về cơ bản đều theo từng bit. Ta xét từng bit rồi tạo ra bit nhớ và tổng, nhưng không bao giờ lan truyền bit nhớ qua các vị trí bit.
We just say whether this actually produces a carry, whether this bit position actually produces carry or not, right?
Ta chỉ xác định xem vị trí này có tạo ra bit nhớ hay không, vị trí bit này có tạo ra bit nhớ hay không, đúng không?
And then finally, we only do this actually carry propagate addition, or just the addition that we have seen before, where we ripple through the carry in the final stage when we actually need to produce a single output.
Và cuối cùng, ta mới thực hiện phép cộng lan truyền nhớ này, tức là phép cộng mà ta đã thấy trước đây, trong đó ta lan truyền bit nhớ ở giai đoạn cuối khi ta thật sự cần tạo ra một đầu ra duy nhất.
Right, so here in this example, even we are actually producing the carry, we just label this. We are producing a carry, but we don't need to actually consolidate into our sum.
Vậy, trong ví dụ này, dù ta đang tạo ra bit nhớ, ta chỉ gán nhãn cho nó. Ta tạo ra bit nhớ, nhưng không cần gộp nó vào tổng.
We always just actually have two, we have the, what is the carry produced by this bit pattern and what is the sum produced by the bit pattern.
Ta luôn có hai thứ, ta có bit nhớ do mẫu bit này tạo ra và tổng do mẫu bit này tạo ra.
We actually just propagate two in the addition. And then we actually get to the final result here.
Ta chỉ truyền đi hai giá trị trong phép cộng. Rồi cuối cùng ta có kết quả ở đây.
So this is basically what people generally use the carry save addition, so that they don't actually propagate the carries and they just actually grab the carry directly, save the carries directly.
Đây về cơ bản là lý do người ta thường dùng phép cộng lưu nhớ, để không phải lan truyền các bit nhớ mà chỉ lấy bit nhớ trực tiếp, lưu trực tiếp các bit nhớ.
But it eventually means, it also means that we eventually need to actually propagate to actually produce the carries, the sum here, right?
Nhưng cuối cùng điều đó cũng có nghĩa là, rốt cuộc ta vẫn cần lan truyền để tạo ra các bit nhớ, tức là tổng ở đây, đúng không?
We still need to actually produce the final results through a carry propagate adder, right? So that's basically the idea of doing actually this carry save addition.
Ta vẫn cần tạo ra kết quả cuối cùng thông qua một bộ cộng lan truyền nhớ, đúng không? Đó chính là ý tưởng của phép cộng lưu nhớ này.
We don't actually propagate the carry explicitly, we just save the carry. So we always bring both the carry and sum in our results, and then through the final stage propagation in the end.
Ta không lan truyền bit nhớ một cách tường minh, ta chỉ lưu bit nhớ. Nên ta luôn mang theo cả bit nhớ và tổng trong kết quả, rồi đến giai đoạn cuối mới lan truyền ở cuối.
So that's the idea of doing this kind of carry save addition to reduce this reduction tree, right?
Đó là ý tưởng của việc dùng kiểu cộng lưu nhớ này để thu gọn cây rút gọn này, đúng không?
So instead of actually taking two inputs, produce one, we can actually take in three numbers, and then produce two, right?
Vậy thay vì nhận hai đầu vào và tạo ra một, ta có thể nhận vào ba số rồi tạo ra hai, đúng không?
So just, we already produced both carry and the sum as the two separate input, so that we can actually reduce the depths, Doing the consolidation a little bit faster for the partial product consolidation here.
Tức là ta đã tạo ra cả bit nhớ và tổng như hai đầu vào riêng biệt, để có thể giảm độ sâu, Việc hợp nhất được thực hiện nhanh hơn một chút cho phần hợp nhất các tích riêng ở đây.
Does this make sense? Separating the carry propagation, just to have both carry and sum from the calculation, and doing this carry save addition until the very end.
Mọi người có hiểu không? Tách riêng phần lan truyền nhớ, chỉ để có cả số nhớ và tổng từ phép tính, và thực hiện phép cộng lưu nhớ này cho đến tận bước cuối.
Kind of. Okay. What is the second three adding with? What's that? What is the second three adding with the 0011?
Cũng tạm hiểu. Được rồi. Số ba thứ hai được cộng với cái gì vậy? Đó là gì? Số ba thứ hai được cộng với 0011 là gì?
00, oh, so in this example, we have three numbers, right?
00, ồ, vậy trong ví dụ này, chúng ta có ba số, đúng không?
So that's just the input. Right, I get the top part. I just wonder for the bottom part, who is this three adding with? Oh, who is this three adding with?
Đó chỉ là đầu vào. Vâng, em hiểu phần trên. Em chỉ thắc mắc phần dưới, số ba này được cộng với cái gì? À, số ba này được cộng với cái gì?
The C and X produced from the previous stage.
C và X được tạo ra từ tầng trước.
Oh, I see. I see. Got it. Thank you. Those three numbers are added together.
À, em hiểu rồi. Em hiểu rồi. Cảm ơn thầy. Ba số đó được cộng với nhau.
Oh, so this is the output of this. So this is the output, right?
À, vậy đây là đầu ra của phần này. Vậy đây là đầu ra, đúng không?
So, let's say this is the, let me clean this up.
Vậy, giả sử đây là, để tôi xóa bớt cho gọn.
Okay, so, so this is what we mean by carry save addition. So, what Carol asked is, what is the third? What's this three adding with?
Được rồi, đây chính là điều chúng ta gọi là phép cộng lưu nhớ. Câu Carol hỏi là, số thứ ba là gì? Số ba này được cộng với cái gì?
So, they are adding three is adding with the carry produced by the first edition and the sum produced by the first edition. So, let's say this is carry 0, sum 0.
Vậy, số ba này được cộng với số nhớ do phép cộng đầu tiên tạo ra và tổng do phép cộng đầu tiên tạo ra. Giả sử đây là số nhớ 0, tổng 0.
And then this is carry 1, sum 1. So, this is new carry and sum produced.
Và đây là số nhớ 1, tổng 1. Đây là số nhớ và tổng mới được tạo ra.
Right, so we're adding carry sum. Basically, we're adding three numbers here. We're producing carry and sum, but we just never propagate. We're just adding them directly.
Vậy là chúng ta đang cộng số nhớ và tổng. Về cơ bản, ở đây chúng ta cộng ba số. Chúng ta tạo ra số nhớ và tổng, nhưng không bao giờ lan truyền. Chúng ta chỉ cộng trực tiếp chúng.
Yeah, so the three we add is basically this stage.
Vâng, vậy số ba mà ta cộng về cơ bản chính là tầng này.
Does that answer your question, Carol? Oh, yeah, it's really clear. Thank you. Okay. Thank you. Yeah, so there are two. Steps here or two separate steps here.
Như vậy đã trả lời câu hỏi của em chưa, Carol? Dạ rồi, rất rõ ràng ạ. Cảm ơn thầy. Được rồi. Cảm ơn em. Vâng, vậy có hai bước ở đây, hay hai bước riêng biệt ở đây.
So, this is basically the new carry produced by the previous. Some we're taking carry and carry zero and zero, and then we're having a new three here.
Đây về cơ bản là số nhớ mới được tạo ra từ tầng trước. Tổng thì ta lấy số nhớ, số nhớ 0 và 0, rồi ta có một số ba mới ở đây.
So, you can, like, you will do the sum, right? So, there, like, we have a zero here, Just some, literally, some all the bits together, we get a one.
Vậy bạn sẽ tính tổng, đúng không? Ở đây chúng ta có một số 0, Cứ cộng tất cả các bit lại với nhau, ta được một số 1.
Even the previous stage have a propagate, have a carry, but we actually don't consider that. We just add, like, the bitwise position together.
Dù tầng trước có lan truyền, có số nhớ, nhưng thực ra ta không xét đến nó. Ta chỉ cộng các vị trí bit tương ứng với nhau.
So, yeah, how does this save time? That's so good. So, here, yeah, basically, it saves time because we don't actually do the carry, and then we don't need to do the carry propagation.
Vậy, làm sao cách này tiết kiệm thời gian? Câu hỏi hay quá. Ở đây, về cơ bản, nó tiết kiệm thời gian vì ta không thực sự thực hiện nhớ, và do đó không cần lan truyền nhớ.
Even we still need to do the carry propagation, but this is faster because we literally just do bitwise operation there.
Dù ta vẫn cần lan truyền nhớ, nhưng cách này nhanh hơn vì ở đó ta chỉ thực hiện phép toán theo từng bit.
So, we save the time of doing the propagation in the intermediate stage, but in the final stage, we still need to let it propagate to actually get a final result.
Như vậy ta tiết kiệm thời gian lan truyền ở các tầng trung gian, nhưng ở tầng cuối, ta vẫn cần để nó lan truyền để có được kết quả cuối cùng.
But in the intermediate stage, we just save the carry, treat it as another input, but we don't propagate, and that cuts the critical path.
Nhưng ở giai đoạn trung gian, ta chỉ lưu bit nhớ, coi nó như một đầu vào khác, mà không lan truyền, và điều đó cắt ngắn đường tới hạn.
Yeah. Okay, so that's a carry save. You will see whenever I talk about addition, the key thing is always cut the critical, like, reduce the carry chain, right?
Vâng. Được rồi, đó là carry save. Các em sẽ thấy mỗi khi nói về phép cộng, điều mấu chốt luôn là cắt ngắn đường tới hạn, tức là giảm chuỗi nhớ, đúng không?
So, this cuts the critical path here. So, you will look at the, you will use carry save addition here, right?
Vậy nên cách này cắt ngắn đường tới hạn ở đây. Vậy ở đây các em sẽ dùng phép cộng carry save, đúng không?
So, we can basically get input, right, and then produce all the parallel carry and the sum signal. So, it's never, it's actually get, we always produce the parallel sum of carry signals.
Về cơ bản ta nhận các đầu vào, đúng không, rồi tạo ra song song tất cả các bit nhớ và tín hiệu tổng. Vậy nên nó không bao giờ, thực ra nó nhận được, ta luôn tạo ra song song các tín hiệu tổng và nhớ.
So, we never really propagate, but until the final stage, we still have a carry propagate adder because we actually need to produce the final sum, right?
Do đó ta thực sự không bao giờ lan truyền, nhưng đến giai đoạn cuối ta vẫn có một bộ cộng lan truyền nhớ vì ta thực sự cần tạo ra tổng cuối cùng, đúng không?
So, carry save is fast, right, because we get rid of the carry propagation. We just save the carry for every bit, and that is actually, and keep it as another input, right?
Vậy carry save nhanh, vì ta loại bỏ được việc lan truyền nhớ. Ta chỉ lưu bit nhớ cho từng bit, và thực ra giữ nó như một đầu vào khác, đúng không?
And adders is actually, adders is cheap, right? It's very simple. As long as it's not on the critical path, it doesn't actually, it's not too bad, right?
Và các bộ cộng thì rẻ, đúng không? Rất đơn giản. Miễn là nó không nằm trên đường tới hạn thì cũng không tệ lắm, đúng không?
And then we only actually get the final sum in the, actually propagate the carry in the final stage. That's in the carry, Using a ripple carry adder, carry propagate adder here.
Và ta chỉ lấy tổng cuối cùng ở giai đoạn cuối, tức là chỉ lan truyền nhớ ở giai đoạn cuối. Đó là dùng bộ cộng ripple carry, bộ cộng lan truyền nhớ ở đây.
That's basically one optimization we can do, like, break the carry chain to actually do the reduction actually faster, right? Is it faster than the tree reduction?
Về cơ bản đó là một cách tối ưu ta có thể làm, phá chuỗi nhớ để thực hiện phép rút gọn nhanh hơn, đúng không? Nó có nhanh hơn rút gọn dạng cây không?
Like things like, so it's way easier to implement. So, it basically depends on depth of the tree, right?
Kiểu như, nó dễ cài đặt hơn nhiều. Vậy nó về cơ bản phụ thuộc vào độ sâu của cây, đúng không?
So, because of the final stage, you still need to have a carry propagate adder, and you can basically use all the tree adders that we discussed to design this carry propagate adder, right?
Vì ở giai đoạn cuối, ta vẫn cần một bộ cộng lan truyền nhớ, và ta có thể dùng tất cả các bộ cộng dạng cây mà ta đã thảo luận để thiết kế bộ cộng lan truyền nhớ này, đúng không?
So, this really makes sense if we actually have a lot of partial products that need to accumulate, right? So, then we don't need to actually get to the final sum directly, right?
Vậy điều này thực sự có ý nghĩa nếu ta có nhiều tích riêng cần cộng dồn, đúng không? Khi đó ta không cần phải lấy ngay tổng cuối cùng, đúng không?
But for this, the final addition, you can still use all the different techniques that we discussed to implement the final one. The carry save doesn't work as an independent adder, right?
Nhưng với phép cộng cuối cùng này, các em vẫn có thể dùng tất cả các kỹ thuật khác nhau mà ta đã thảo luận để cài đặt phép cộng cuối. Carry save không hoạt động như một bộ cộng độc lập, đúng không?
Because it doesn't produce the final sum, right? It works, well, we introduced this in multipliers because we have a lot of intermediate results, right?
Vì nó không tạo ra tổng cuối cùng, đúng không? Nó hoạt động, à, ta giới thiệu nó trong các bộ nhân vì ta có nhiều kết quả trung gian, đúng không?
So, this helps, because we don't care about the format of the intermediate result. But once it gets to the final, you will actually just need an adder, right?
Vậy nên cách này có ích, vì ta không quan tâm đến định dạng của kết quả trung gian. Nhưng đến bước cuối, các em thực sự chỉ cần một bộ cộng, đúng không?
This doesn't actually do the job, right? It needs a carry propagate adder to actually do that. But you will have a lot of intermediate stages. This could also be a.
Cái này thực ra không làm được việc đó, đúng không? Cần một bộ cộng lan truyền nhớ để làm việc đó. Nhưng các em sẽ có nhiều giai đoạn trung gian. Cái này cũng có thể là một.
That's why we introduced this here.
Đó là lý do ta giới thiệu nó ở đây.
Yeah, so there are actually a lot of, not a lot, there are also work. So, people call this like 3 to 2 compressor, basically doing this kind of compressor.
Vâng, thực ra còn có khá nhiều, không hẳn nhiều, cũng có những công trình khác. Vì vậy, người ta gọi cái này là bộ nén 3 sang 2, về cơ bản là một dạng bộ nén như thế này.
There's also 4 to 2 compressor. I need to, it's less intuitive to actually walk through the logic, but there's actually a different way to do it.
Cũng có bộ nén 4 sang 2. Em cần, việc đi qua từng phần logic sẽ khó hình dung hơn, nhưng thực ra có một cách khác để làm.
So, when you see people call this compressor, we call it carry save addition, but people call this compressor. This is 3 to 2 compressor.
Vì vậy, khi các em thấy người ta gọi đây là bộ nén, chúng ta gọi nó là phép cộng carry save, nhưng người ta gọi nó là bộ nén. Đây là bộ nén 3 sang 2.
There's also 4 to 2 compressor, basically to get to the final, get the intermediate results. Okay, we'll see, we'll get to carry save circuit. We'll talk about this.
Cũng có bộ nén 4 sang 2, về cơ bản để đi đến kết quả cuối, lấy các kết quả trung gian. Được rồi, chúng ta sẽ đến mạch carry save. Chúng ta sẽ nói về phần này.
This is really part of the building block. We'll talk about how we stitch this together in turn to actually do the final multiplier, right?
Đây thực sự là một phần của khối xây dựng. Chúng ta sẽ nói về cách ghép chúng lại với nhau để tạo ra bộ nhân cuối cùng, đúng không?
This is a building block of the multiplier to actually make things faster. I know it gets to a lot of low level details.
Đây là một khối xây dựng của bộ nhân để làm mọi thứ nhanh hơn. Tôi biết là nó đi vào rất nhiều chi tiết mức thấp.
I also need to actually really think through some of the low level details. So, let's navigate this through together.
Bản thân tôi cũng cần suy nghĩ kỹ một số chi tiết mức thấp này. Vậy nên chúng ta hãy cùng nhau tìm hiểu.
But again, the high level principle is how we actually design those modules and what are the complexity of those modules when it comes to, when you get to arithmetic unit, right?
Nhưng một lần nữa, nguyên lý ở mức cao là chúng ta thiết kế các mô-đun này như thế nào và độ phức tạp của các mô-đun này là bao nhiêu khi nói đến khi các em đến với khối số học, đúng không?
So, reach out to the staff, reach out to me during the discussions, office hours, if you have any questions, especially on the conceptual understanding.
Vì vậy, hãy liên hệ với đội ngũ giảng dạy, liên hệ với tôi trong các buổi thảo luận, giờ hỏi bài, nếu các em có bất kỳ câu hỏi nào, đặc biệt là về việc hiểu khái niệm.
We'll continue our discussion on multipliers this week and see how we actually build multipliers using those building blocks. Okay, good seeing you on Thursday.
Tuần này chúng ta sẽ tiếp tục thảo luận về bộ nhân và xem cách chúng ta xây dựng bộ nhân bằng các khối xây dựng này. Được rồi, hẹn gặp lại các em vào thứ Năm.
Đă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.