Video
Đăng bởi Ban biên tập OpenER ·
Tác giả giữ toàn bộ bản quyền (All Rights Reserved) — không phải giấy phép mở. Bạn vẫn xem và học miễn phí trên OpenER; muốn tái sử dụng cần xin phép tác giả.
Okay, well, good morning everyone, great to see you again and welcome to EECS 151/251A, Introduction to Digital Design and Integrated Circuits. We are going to start our work towards the end of the semester.
Chào buổi sáng mọi người, rất vui được gặp lại các bạn và chào mừng đến với EECS 151/251A, Nhập môn Thiết kế số và Mạch tích hợp. Chúng ta sẽ bắt đầu hướng tới phần cuối của học kỳ.
As I mentioned, three modules: Microarchitecture and Verilog, CMOS module and Digital Building Blocks. We have covered a lot of combinational blocks, adders and multipliers.
Như tôi đã nói, có ba mô-đun: Vi kiến trúc và Verilog, mô-đun CMOS và mô-đun Các khối xây dựng số. Chúng ta đã học nhiều khối tổ hợp, bộ cộng và bộ nhân.
We'll wrap up some of the discussion on multipliers today and then we're going to start the sequential logic.
Hôm nay chúng ta sẽ kết thúc phần thảo luận về bộ nhân rồi bắt đầu sang logic tuần tự.
We'll actually talk about how we build flip-flops and especially how that actually affects the timing of our circuit behavior.
Chúng ta sẽ nói về cách xây dựng flip-flop, và đặc biệt là điều đó ảnh hưởng thế nào đến thời gian hoạt động của mạch.
And we'll also, after flip-flops, we'll cover actually SRAM, another very important sequential building block in our modern circuits.
Sau flip-flop, chúng ta cũng sẽ học về SRAM, một khối tuần tự rất quan trọng khác trong các mạch hiện đại.
So we'll get to how we actually do design those sequential building blocks this and next week before the end of the semester.
Vậy chúng ta sẽ tìm hiểu cách thiết kế các khối tuần tự đó trong tuần này và tuần sau, trước khi kết thúc học kỳ.
Some interesting things to discuss, I have, I look for a lot of things, I think like what would be a good topic to discuss, and then I realized Supercomputing is actually happening this week.
Có vài điều thú vị để thảo luận. Tôi đã tìm rất nhiều thứ, tôi nghĩ xem chủ đề nào sẽ hay để bàn, rồi tôi nhận ra Supercomputing đang diễn ra trong tuần này.
That's basically the leading conference, both academic and for both academia and the industry.
Về cơ bản đó là hội nghị hàng đầu, cả về học thuật lẫn đối với giới học thuật và ngành công nghiệp.
It's a pretty big conference where different companies, different researchers, they actually come together, talk about what their thoughts on building the future generation of supercomputers, right?
Đó là một hội nghị khá lớn, nơi các công ty và các nhà nghiên cứu khác nhau cùng tụ họp, trao đổi ý tưởng của họ về việc xây dựng thế hệ siêu máy tính tương lai, đúng không?
And generally, depends on the area, every year if there's also a Turing Award winner in that particular area, they will also invite the Turing Award winner to give a Turing Award lecture.
Và nói chung, tùy lĩnh vực, hằng năm nếu có người đoạt giải Turing trong lĩnh vực đó, họ cũng sẽ mời người đó giảng bài giảng nhận giải Turing.
For folks who have taken 152/252A before, you folks may have watched the Hennessy and Patterson Turing Award lecture at ISCA, right, a couple years ago. It's generally a very good lecture to watch.
Những bạn đã học 152/252A có thể đã xem bài giảng nhận giải Turing của Hennessy và Patterson tại ISCA, cách đây vài năm. Nhìn chung đó là một bài giảng rất đáng xem.
It shows basically the history of this area and things to look for moving forward, what are the new challenges.
Nó trình bày lịch sử của lĩnh vực này và những điều cần hướng tới, những thách thức mới là gì.
And in Supercomputing this year, Jack Dongarra, who won the Turing Award last year, He's a leading researcher in high-performance computing.
Và tại Supercomputing năm nay, Jack Dongarra, người đoạt giải Turing năm ngoái, là nhà nghiên cứu hàng đầu về tính toán hiệu năng cao.
He has done a lot of interesting work in really thinking about how we actually fully utilize high-performance computing and build highly efficient linear algebra libraries, setting up benchmarks, and setting up really a competition.
Ông đã có nhiều công trình thú vị khi suy nghĩ về việc làm thế nào để tận dụng triệt để tính toán hiệu năng cao và xây dựng các thư viện đại số tuyến tính hiệu quả cao, thiết lập benchmark, và tổ chức cả một cuộc cạnh tranh.
The Top500 supercomputer list was also part of his effort to actually compare different supercomputers using the same metric, right?
Danh sách siêu máy tính Top500 cũng nằm trong nỗ lực của ông nhằm so sánh các siêu máy tính khác nhau bằng cùng một thước đo, đúng không?
So this is, although this is supercomputing, not directly in hardware, but generally any kind of system researcher also always need to actually interact with hardware very closely.
Vậy dù đây là siêu máy tính, không trực tiếp về phần cứng, nhưng nói chung bất kỳ nhà nghiên cứu hệ thống nào cũng luôn phải làm việc rất sát với phần cứng.
I just watched his Turing lecture earlier this morning before the lecture today. I really like it. I think it offers you a very interesting history of the way we approach high-performance computing.
Sáng nay, trước giờ học, tôi vừa xem bài giảng Turing của ông ấy. Tôi rất thích. Tôi nghĩ nó cho bạn thấy một lịch sử rất thú vị về cách chúng ta tiếp cận tính toán hiệu năng cao.
And you look at his takeaways. Most of the takeaways are very tightly coupled with hardware. You will see actually the area of thinking about high-performance system really coupled with hardware.
Và hãy xem những điều rút ra của ông ấy. Hầu hết các điểm rút ra đều gắn rất chặt với phần cứng. Thật ra các bạn sẽ thấy lĩnh vực nghiên cứu về các hệ thống hiệu năng cao gắn rất chặt với phần cứng.
We never have new hardware, right? Thinking from scalar to vector to a matrix to distributed, all of those have a very substantial impact on the way we think about software.
Chúng ta đâu bao giờ có phần cứng mới, đúng không? Việc nghĩ từ số vô hướng đến vectơ, đến ma trận, rồi đến tính toán phân tán, tất cả đều có tác động rất lớn đến cách chúng ta nghĩ về phần mềm.
And a lot of Jack's contribution is really thinking about how we can develop reusable library to make it easier and portable interface, right?
Và nhiều đóng góp của Jack là nghĩ xem làm sao phát triển được thư viện có thể tái sử dụng để có giao diện dễ dùng và khả chuyển, đúng không?
MPI interface to make it easier for other programmers to use this kind of more advanced computing substrate. So highly recommend it. It's a great way to see the history of high-performance computing.
Giao diện MPI giúp các lập trình viên khác dễ dàng hơn trong việc sử dụng nền tảng tính toán tiên tiến hơn này. Vì vậy tôi rất khuyến khích các bạn xem. Đó là một cách tuyệt vời để xem lịch sử của tính toán hiệu năng cao.
Also some of the open questions moving forward. And during part of Q&A, he actually talked about some of the exciting opportunities in really thinking about hardware-software co-design, especially with domain-specific hardware.
Cùng với một số câu hỏi còn bỏ ngỏ trong tương lai. Và trong phần hỏi đáp, ông ấy đã nói về một số cơ hội thú vị trong việc nghĩ về đồng thiết kế phần cứng và phần mềm, đặc biệt với phần cứng chuyên dụng theo miền ứng dụng.
So it's interesting to see the echo from, like, very recent Turing Award winners where Hennessy and Patterson talk about the golden age of computer architecture with this surge of specialized computers.
Nên thật thú vị khi thấy sự đồng điệu với những người đoạt giải Turing gần đây, khi Hennessy và Patterson nói về thời kỳ hoàng kim của kiến trúc máy tính với sự bùng nổ của các máy tính chuyên dụng.
And then Jack, actually, don't care, actually talk about how we can actually better use them.
Và rồi Jack thì, thật ra, không quan tâm, mà nói về cách chúng ta có thể tận dụng chúng tốt hơn.
So it's a very interesting talk and I highly recommend it if you folks are interested to learn a little bit more history about high-performance computing.
Đó là một bài nói rất thú vị và tôi rất khuyến khích nếu các bạn muốn tìm hiểu thêm một chút về lịch sử của tính toán hiệu năng cao.
Okay, with that, a quick recap of the topics we covered today. Last time, we started the multiplier discussion. We mentioned like two things.
Được rồi, bây giờ ta nhắc lại nhanh những chủ đề đã học hôm nay. Lần trước, chúng ta bắt đầu bàn về bộ nhân. Ta đã nói đến hai việc.
We need to generate the partial product, each individual element here. It's pretty easy. Basically, AND gate.
Cần tạo ra các tích riêng phần, từng phần tử riêng lẻ ở đây. Việc này khá dễ. Về cơ bản là cổng AND.
And then we need to actually add them together, accumulate all the partial products together. And in this process, we talk about how we can actually use a carry-save adder.
Và sau đó ta cần cộng chúng lại với nhau, cộng dồn tất cả các tích riêng phần. Trong quá trình này, ta đã nói về cách dùng bộ cộng carry-save.
So instead of doing the carry propagation, we just send both the carry and the sum to the next level and then build a Wallace tree adder. So we can do this accumulation faster.
Thay vì thực hiện lan truyền nhớ, ta gửi cả carry và tổng sang tầng tiếp theo rồi xây dựng bộ cộng cây Wallace. Nhờ vậy ta cộng dồn nhanh hơn.
We also talk about Booth encoding last time.
Lần trước ta cũng đã nói về mã hóa Booth.
We can actually make a more efficient way of representing this and then with higher radix so that we can actually cut the number of partial products that we actually need to generate.
Ta có thể có một cách hiệu quả hơn để biểu diễn, và với cơ số cao hơn thì ta có thể giảm số lượng tích riêng phần mà ta thực sự cần tạo ra.
So those are the two common optimizations in really thinking about how we design a highly efficient multiplier.
Đó là hai tối ưu hóa phổ biến khi suy nghĩ về cách thiết kế một bộ nhân hiệu quả cao.
And today, I'm going to wrap up some of the discussion we didn't finish last time, really actually how we do signed multiplication. So far, we haven't actually, mostly just assumed unsigned numbers.
Và hôm nay, tôi sẽ kết thúc phần thảo luận còn dở từ lần trước, cụ thể là cách thực hiện phép nhân có dấu. Cho đến giờ, hầu như ta chỉ giả sử các số không dấu.
We just add everything together. But things will be slightly different. You will see actually the majority of the structure still stays the same.
Ta chỉ cộng mọi thứ lại với nhau. Nhưng sẽ có chút khác biệt. Các bạn sẽ thấy phần lớn cấu trúc vẫn giữ nguyên.
But we do need to change something because we actually need to handle the sign bit for every one of the multiplicand and the multiplier. So I get to the signed multiplication.
Nhưng ta cần thay đổi một số thứ vì ta phải xử lý bit dấu cho từng bit của số bị nhân và số nhân. Vậy tôi sẽ chuyển sang phép nhân có dấu.
So when we actually do those two's complement number representations, the highest bit, actually a sign bit. For the sign bit, it actually has a negative weight.
Khi chúng ta biểu diễn số theo bù hai, bit cao nhất thực chất là bit dấu. Bit dấu có trọng số âm.
Meaning when we actually add everything together, we actually need to subtract whatever the value the sign bit represents here to actually get the right value.
Nghĩa là khi cộng tất cả lại với nhau, chúng ta cần trừ đi giá trị mà bit dấu biểu diễn ở đây để có được giá trị đúng.
So that's how we actually use two's complement to actually represent negative value. So the signed bit actually need to be taken care of when we're actually doing the multiplication.
Đó là cách chúng ta dùng bù hai để biểu diễn giá trị âm. Vì vậy cần phải xử lý bit dấu khi thực hiện phép nhân.
So we'll see, actually, when we do the multiplication, the majority of things actually stay the same.
Chúng ta sẽ thấy, khi thực hiện phép nhân, phần lớn mọi thứ vẫn giữ nguyên.
We do need to sign extends our partial products, because each partial product need to be a signed value instead of unsigned.
Chúng ta cần mở rộng dấu cho các tích riêng, vì mỗi tích riêng phải là một giá trị có dấu thay vì không dấu.
And similarly, similar to the way we actually treat the signed bits, we also need to subtract the final partial product to actually accommodate that effect, to actually get the multiplication to be done actually correctly.
Và tương tự cách chúng ta xử lý các bit dấu, chúng ta cũng cần trừ tích riêng cuối cùng để bù cho ảnh hưởng đó, để phép nhân cho ra kết quả đúng.
Let's take a look at the example, how those two actually things, two parts actually happened when we do signed multiplier.
Hãy xem một ví dụ về việc hai điều đó diễn ra như thế nào khi chúng ta nhân có dấu.
So let's say we actually need to multiply two negative numbers, negative three and negative two. So here, negative three and negative two, x and y.
Giả sử chúng ta cần nhân hai số âm, âm ba và âm hai. Đây, âm ba và âm hai, x và y.
So with first of the two's complement representation, the signed bit here is one. So it's a sign, it's a negative value. So because of negative three and negative two, we just do our multiplication.
Trước hết, với biểu diễn bù hai, bit dấu ở đây là một. Tức là bit dấu, đây là một giá trị âm. Vì là âm ba và âm hai, chúng ta cứ thực hiện phép nhân.
So majority of the computation actually stays the same. We basically remember what we did before. We grab each bit of the multiplier and then end with each bit of the multiplicate.
Phần lớn phép tính vẫn giữ nguyên. Hãy nhớ lại những gì chúng ta đã làm trước đây. Chúng ta lấy từng bit của số nhân rồi AND với từng bit của số bị nhân.
So we still do that. We'll see. We still do that for the black three bits here. But remember what we talked before? We do two things differently.
Chúng ta vẫn làm như vậy. Chúng ta sẽ thấy. Chúng ta vẫn làm như vậy với ba bit màu đen ở đây. Nhưng hãy nhớ những gì chúng ta đã nói trước đó? Chúng ta làm hai điều khác đi.
The first, we need to sign extend because we're doing signed multiplication here. So for each of the partial product, we sign extend because the first bit here is actually a signed bit.
Thứ nhất, chúng ta cần mở rộng dấu vì đây là phép nhân có dấu. Với mỗi tích riêng, chúng ta mở rộng dấu vì bit đầu tiên ở đây thực chất là bit dấu.
It's not a regular bit. So we actually sign extend it. It actually doesn't change the value, stay the same, but we sign extend it to the bit width that we have in the end.
Nó không phải là một bit thông thường. Vì vậy chúng ta mở rộng dấu cho nó. Việc này không làm thay đổi giá trị, giá trị vẫn như cũ, nhưng chúng ta mở rộng dấu tới độ rộng bit mà chúng ta có ở kết quả cuối.
And finally, for the last one, We actually need to subtract because this actually represents a negative. Similar to what we did before, this actually represents a negative value here with two's complement.
Và cuối cùng, với tích riêng cuối, chúng ta cần phải trừ vì nó biểu diễn một giá trị âm. Tương tự những gì chúng ta đã làm trước đây, nó biểu diễn một giá trị âm ở đây theo bù hai.
So we actually subtract the signed bits. Basically, the signed bits of the multiplier actually need to be subtracted. That's basically all we need to do to actually do signed multiplication.
Vì vậy chúng ta trừ đi các bit dấu. Về cơ bản, các bit dấu của số nhân cần được trừ đi. Về cơ bản, đó là tất cả những gì ta cần làm để thực hiện phép nhân có dấu.
And then once we have this here, right, with that, everything actually stays the same. We just do the partial product accumulation, and then we have our final result, right?
Và khi đã có phần này rồi, đúng không, thì mọi thứ còn lại vẫn giữ nguyên. Ta chỉ cần cộng dồn các tích riêng phần, và thế là ta có kết quả cuối cùng, đúng không?
So we have negative three multiplied with negative two, and then we end up with a positive number. We get a six here by doing these steps, right? So you'll see two steps.
Vậy ta có âm ba nhân với âm hai, và kết quả là một số dương. Ta được sáu sau các bước này, đúng không? Như vậy bạn sẽ thấy có hai bước.
First, sign extend, so all the partial products will be sign extended to capture that.
Thứ nhất, mở rộng dấu, tức là tất cả các tích riêng phần sẽ được mở rộng dấu để biểu diễn đúng điều đó.
And then finally, the final product with a signed bit from the multiplier needs to be actually subtracted from the partial product, right, instead of added.
Và cuối cùng, tích riêng phần cuối cùng, ứng với bit dấu của số nhân, cần được trừ đi khỏi tổng các tích riêng phần, thay vì được cộng vào.
That's basically the step that we're doing for a signed multiplier design, right? Make sense, what we're doing here? Okay, great.
Về cơ bản, đó là bước ta thực hiện trong thiết kế bộ nhân có dấu, đúng không? Những gì ta đang làm ở đây có dễ hiểu không? Được rồi, tốt.
So this is how we do that, actually, following with paper and pencil, right, how we do that. How we actually turn this into hardware, right?
Vậy đây là cách ta làm, khi làm trên giấy bằng bút chì, đúng không, ta làm như thế nào. Còn làm sao để biến điều này thành phần cứng, đúng không?
How we turn this into the digital building blocks that we have seen before. With that, let's take a look at the array multiplier that we have seen before, right?
Làm sao để biến nó thành các khối xây dựng số mà ta đã thấy trước đây. Với điều đó, hãy xem lại bộ nhân dạng mảng mà ta đã thấy trước đây, đúng không?
So here, this is a more generalized representation of the steps that we mentioned before. Again, similarly, we sign extend, right?
Ở đây, đây là cách biểu diễn tổng quát hơn của các bước mà ta vừa nói. Một lần nữa, tương tự, ta mở rộng dấu, đúng không?
So all the red parts are basically sign extension, right, for the partial product. And then we subtract the final product that is actually contributed by the signed bit of the multiplier, right?
Vậy tất cả các phần màu đỏ về cơ bản là phần mở rộng dấu của các tích riêng phần. Và sau đó ta trừ tích cuối cùng do bit dấu của số nhân tạo ra, đúng không?
So that's basically the two things that we do, and then everything else stays the same, right? You will see how this actually turns into hardware.
Đó về cơ bản là hai việc ta làm, còn mọi thứ khác vẫn giữ nguyên, đúng không? Bạn sẽ thấy điều này được chuyển thành phần cứng như thế nào.
We basically need to support those two functionalities that we mentioned before, right? First, Sign extension, right? We need to actually extend those bits that we need for accumulation later, right?
Về cơ bản ta cần hỗ trợ hai chức năng mà ta đã nhắc đến trước đó, đúng không? Thứ nhất, mở rộng dấu, đúng không? Ta cần mở rộng những bit mà ta cần cho việc cộng dồn sau đó, đúng không?
So those are basically all those purple, pink wires here. For example, like this, like when it started from here, right? So this is basically x3, y0, right?
Đó chính là tất cả các dây màu tím, màu hồng ở đây. Ví dụ như thế này, như khi nó bắt đầu từ đây, đúng không? Đây về cơ bản là x3, y0, đúng không?
So x3, y0 is what we see here. This gets extended, right, to all the higher order bits so that we can actually capture that, right?
Vậy x3, y0 là cái ta thấy ở đây. Nó được mở rộng đến tất cả các bit bậc cao hơn để ta có thể biểu diễn đúng giá trị đó, đúng không?
So this is basically how we do sign extension, right? So that's the first step. We do that every step here.
Đó về cơ bản là cách ta mở rộng dấu, đúng không? Đó là bước thứ nhất. Ta làm điều đó ở mỗi bước ở đây.
The second thing is that we also need to actually do the subtraction, right, for the final partial product.
Điều thứ hai là ta cũng cần thực hiện phép trừ, đúng không, cho tích riêng phần cuối cùng.
The last row, instead of adding them together, we actually subtract them, right, to actually consider the sign bit.
Ở hàng cuối, thay vì cộng chúng lại với nhau, ta thực hiện trừ, đúng không, để tính đến bit dấu.
But here, one trick that we're using with bit manipulation is that we actually subtract a number, right? It's actually the equivalent.
Nhưng ở đây, một mẹo mà ta dùng với thao tác trên bit là khi ta trừ một số, đúng không?
You would just do a bitwise not, invert that number plus one, right, with two's complement representation, right?
Nó thực ra tương đương với việc bạn chỉ cần thực hiện phép not theo bit, đảo số đó rồi cộng một, đúng không, với biểu diễn bù hai.
So we can actually do that to actually turn this into basically what we used to do, addition we had before, right? But instead of using the original value, we actually use the inverted value.
Vậy thực ra chúng ta có thể làm như vậy để biến cái này thành về cơ bản là phép cộng mà trước đây chúng ta đã dùng, đúng không? Nhưng thay vì dùng giá trị ban đầu, ta dùng giá trị đã đảo bit.
We have the bubble there, right, because this is a not b, right? This is not b here. We have the not operator here, right? And then we also need to add one here, right?
Ở đây có một cái bubble, đúng không, vì đây là not b. Đây là not b. Ở đây ta có toán tử not, đúng không? Và sau đó ta cũng cần cộng thêm một ở đây, đúng không?
So that's basically those two are the second step we need to do, right? We do the sign extension. We get those pink full adder, right, so that we can still account for those.
Vậy về cơ bản hai việc đó là bước thứ hai chúng ta cần làm. Ta thực hiện mở rộng dấu. Ta có những bộ cộng đầy đủ màu hồng, để vẫn có thể xử lý những phần đó.
And then we do this. We convert this subtraction into addition, right, by flip the bit patterns and add one here. So we see the majority of the structure stays the same, right?
Và sau đó ta làm như thế này. Ta chuyển phép trừ này thành phép cộng, bằng cách đảo các mẫu bit và cộng thêm một ở đây. Như vậy ta thấy phần lớn cấu trúc vẫn giữ nguyên, đúng không?
We're just doing the bit level manipulation. We do need a couple of the pink adders, full adders added to actually handle the sign bit, but the majority of the structure stays the same, right?
Ta chỉ đang thao tác ở mức bit. Ta cần thêm một vài bộ cộng màu hồng, tức là các bộ cộng đầy đủ, để xử lý bit dấu, nhưng phần lớn cấu trúc vẫn giữ nguyên, đúng không?
So that's how we actually do signed multiplication, Following the same pattern we observed when we actually do bitwise example with paper and pencil.
Đó là cách ta thực hiện phép nhân có dấu, theo cùng mẫu mà ta đã quan sát khi làm ví dụ theo bit bằng giấy và bút.
Makes sense? High level? Okay. So one thing you do realize when you actually go through the course is really, I guess, the excitement or the audacity of hardware designers.
Hiểu chứ? Ở mức tổng quát. Được rồi. Một điều bạn sẽ nhận ra khi học hết khóa này là sự hứng khởi, hay có thể nói là sự táo bạo của những người thiết kế phần cứng.
Whenever they see any kind of overheads, they want to cut them, right? Whenever there's any fat, any bloat, they shouldn't be there. This is really concerning, right? Hardware designers are very detail-oriented, right?
Hễ thấy bất kỳ chi phí phụ nào là họ muốn cắt bỏ, đúng không? Hễ có chỗ nào thừa, cồng kềnh, thì không nên có ở đó. Điều này thật sự đáng lo, đúng không? Người thiết kế phần cứng rất chú trọng chi tiết, đúng không?
So when the hardware designers see this, all those pink boxes here are pretty annoying, right? Those are basically things that we didn't need before if we just do the unsigned multiplication.
Vì vậy khi họ nhìn thấy cái này, tất cả những ô màu hồng ở đây khá khó chịu, đúng không? Về cơ bản đó là những thứ mà ta không cần trước đây nếu chỉ làm phép nhân không dấu.
All of a sudden, we actually need to put more full adders just to support all the different signed bits, right? So those are annoying.
Đột nhiên ta phải thêm nhiều bộ cộng đầy đủ hơn chỉ để hỗ trợ các bit dấu khác nhau, đúng không? Thế nên những cái đó thật phiền.
Then the hardware designer really asks, how can we actually get rid of those, right?
Rồi người thiết kế phần cứng sẽ hỏi, làm sao để loại bỏ chúng, đúng không?
How can we actually have the same regular, I guess, array or like parallelogram structure that we have seen before without adding all those pink full adders, right?
Làm sao để vẫn có cấu trúc mảng đều đặn, hay cấu trúc hình bình hành như đã thấy trước đây mà không phải thêm những bộ cộng đầy đủ màu hồng này?
So that's basically the next optimization people like to do with signed multiplication, or Baugh-Wooley multiplier.
Đó chính là bước tối ưu tiếp theo mà người ta thích làm với phép nhân có dấu, hay bộ nhân Baugh-Wooley.
That's really thinking about how we can actually get rid of some of the logic that we didn't want or we didn't need when we actually do the unsigned multiplication here.
Về cơ bản là suy nghĩ xem làm sao để loại bỏ một số phần logic mà ta không muốn hoặc không cần khi thực hiện phép nhân không dấu ở đây.
So, okay, so first, how can we do that? What are the tricks people applied here to actually get rid of some of the overhead, right?
Vậy, đầu tiên, ta làm điều đó thế nào? Người ta đã áp dụng những mẹo nào để loại bỏ bớt chi phí phụ này?
So let's see what are the patterns that we can observe, right? So first, this is what we have seen before, right? We have those partial products sign extended, right?
Hãy xem ta có thể quan sát được những mẫu nào. Đầu tiên, đây là cái mà ta đã thấy trước đây, đúng không? Chúng ta có các tích riêng được mở rộng dấu, đúng không?
From the high-order bits, and then we do this subtraction here, right? So this is a pattern that we have seen before to support signed multiplication, right? This is our baseline, right?
Từ các bit bậc cao, rồi ta thực hiện phép trừ ở đây, đúng không? Đây là một mẫu mà chúng ta đã thấy trước đây để hỗ trợ phép nhân có dấu, đúng không? Đây là phương án cơ sở của chúng ta, đúng không?
So here, as I mentioned earlier, We don't want to actually add all those sign-extended bits together. Those are basically additional bits that we added, right?
Vậy ở đây, như tôi đã nói trước đó, chúng ta không muốn cộng tất cả các bit mở rộng dấu này lại với nhau. Về cơ bản đó là những bit bổ sung mà ta đã thêm vào, đúng không?
We want to see whether there are ways that we can actually get rid of those, right? Whether we can actually consolidate those so that they have a more regular structure, right?
Chúng ta muốn xem liệu có cách nào để loại bỏ chúng không, đúng không? Liệu ta có thể gộp chúng lại để chúng có cấu trúc đều đặn hơn không, đúng không?
So what can we do to do that? How can we actually get rid of that?
Vậy ta có thể làm gì để đạt được điều đó? Làm thế nào để loại bỏ chúng?
One trick we can do is that we can always add more bits or add ones as long as we actually subtract some later, right? We are actually fine, we'll be fine, right?
Một mẹo là ta luôn có thể thêm các bit hoặc thêm các số một, miễn là sau đó ta trừ đi lượng tương ứng, đúng không? Như vậy là ổn, sẽ không sao cả, đúng không?
So one thing that during this step, we also converted this with, like, using the subtract b is not b plus one, right?
Một điều là trong bước này, chúng ta cũng đã chuyển đổi cái này, kiểu như dùng phép trừ b là not b cộng một, đúng không?
So we already applied that. This is what we saw last time earlier. So this part is taken care of. Oh, I have this here already, right? So this part is taken care of.
Chúng ta đã áp dụng điều đó rồi. Đây là điều ta đã thấy ở buổi trước. Vậy phần này đã được xử lý. À, tôi đã có cái này ở đây rồi, đúng không? Vậy phần này đã được xử lý.
So now we are interested in how we can actually get rid of this partial product, right? One thing we can do is, like, let's add a constant.
Bây giờ chúng ta quan tâm đến cách loại bỏ tích riêng này, đúng không? Một việc ta có thể làm là thêm một hằng số.
We'll do a transformation in the next step, right? But what we can do is basically add one here for the sign bit, right? The first of the sign bit, right?
Ta sẽ biến đổi ở bước tiếp theo, đúng không? Nhưng về cơ bản ta có thể thêm một ở đây cho bit dấu, đúng không? Bit dấu đầu tiên, đúng không?
All of those are basically sign bit. We add one here, but of course we want to subtract those ones. So this is an equivalent transformation. We're not changing anything, right?
Tất cả những bit này về cơ bản đều là bit dấu. Ta thêm một ở đây, nhưng tất nhiên ta cũng muốn trừ đi những số một đó. Đây là một phép biến đổi tương đương. Ta không thay đổi gì cả, đúng không?
Anything stays the same. What this ends up doing, you will look at this pattern here for the sign bit.
Mọi thứ vẫn giữ nguyên. Kết quả của việc này là, các bạn hãy nhìn mẫu này cho bit dấu.
What we are basically doing is, basically, the sign bit we have before, like we extended sign extension and we add a one here, right?
Về cơ bản, những gì ta đang làm là, bit dấu mà ta có trước đó, tức là ta mở rộng dấu và thêm một số một ở đây, đúng không?
We add a one here and all of those are, all of the sign bits are the same, right?
Ta thêm một ở đây và tất cả các bit dấu đều giống nhau, đúng không?
So you will do a sign, like you will do this, basically a sequence of identical values and then add them, Add one to it.
Vậy ta sẽ làm như thế này, về cơ bản là một dãy các giá trị giống hệt nhau rồi cộng chúng lại, cộng thêm một.
What would be the result of this equation? You will have a sequence of identical values and add one to it. One or zero? Well, let's say if s is zero, right?
Kết quả của phép tính này sẽ là gì? Ta có một dãy giá trị giống nhau và cộng thêm một. Là một hay không? Giả sử s bằng không, đúng không?
Let's say if s is just a bunch of zeros, we add one here, we will get one, right? With the s, we basically get the inverted s here, right?
Giả sử s chỉ là một loạt các số không, ta cộng một ở đây, thì ta sẽ được một, đúng không? Với s, về cơ bản ta nhận được s đảo ở đây, đúng không?
You will add one to this.
Ta sẽ cộng một vào cái này.
It's like multiply by negative one.
Giống như nhân với âm một.
Why don't we want to do something like flip it and add one to it? I will get a one, right? Yeah, well, if you have negative one, right?
Tại sao ta không làm kiểu đảo nó rồi cộng một? Tôi sẽ được một, đúng không? Vâng, nếu bạn có âm một, đúng không?
You're basically this, and s is one, right? If you have negative one, you add one to it, you also flip it, it becomes zero. If s is one, right?
Về cơ bản là thế này, và s bằng một, đúng không? Nếu bạn có âm một, bạn cộng thêm một vào nó, thì nó cũng bị đảo, thành không. Nếu s bằng một, đúng không?
So you basically always get the flipped value of s when you actually add one to a sequence of bits here.
Vậy là về cơ bản bạn luôn nhận được giá trị đảo của s khi bạn cộng một vào một dãy bit như thế này.
So basically by adding this one, you can actually flip the value, flip the sign bit, and all the extension bits basically go away, right?
Vậy nên về cơ bản, bằng cách cộng thêm số một này, bạn có thể đảo giá trị, đảo bit dấu, và tất cả các bit mở rộng về cơ bản biến mất, đúng không?
You will get the results directly by doing this flipping. This looks nice, right? Because we didn't want to do all those additions, right? But by adding this, this actually doesn't change the result.
Bạn sẽ có kết quả trực tiếp bằng cách đảo này. Trông khá gọn, đúng không? Vì chúng ta không muốn thực hiện tất cả những phép cộng đó, đúng không? Nhưng việc cộng thêm số này thực ra không làm thay đổi kết quả.
We still subtract all those ones later, right? We get rid of all this flow that we have seen before, all those triangle regions of the full adders there.
Sau đó chúng ta vẫn trừ đi tất cả các số một đó, đúng không? Chúng ta loại bỏ toàn bộ luồng này mà ta đã thấy trước đây, tất cả những vùng hình tam giác của các bộ cộng đầy đủ ở đó.
So this basically gets to a much easier or much simpler thing we can do. We can basically compute this using the array multiplier that we have seen before.
Như vậy, về cơ bản ta có một cách làm dễ hơn, đơn giản hơn nhiều. Chúng ta có thể tính phép này bằng bộ nhân dạng mảng mà ta đã thấy trước đây.
We have two ones here, right? We can also consolidate, we can also carry all the constants together, right? So we can actually do this pretty easily with a constant.
Ở đây chúng ta có hai số một, đúng không? Chúng ta cũng có thể gộp lại, cũng có thể gộp tất cả các hằng số với nhau, đúng không? Vì vậy chúng ta có thể làm điều này khá dễ dàng với một hằng số.
So then we basically have this array multiplier shape that we have seen before, right? So this is what we want.
Như vậy là chúng ta có hình dạng bộ nhân dạng mảng này mà ta đã thấy trước đây, đúng không? Đây chính là điều chúng ta muốn.
We don't want to have all this, and then we want to get the array multiplier that we have seen before. I think this is actually to be here, right?
Chúng ta không muốn có tất cả những thứ này, và chúng ta muốn có bộ nhân dạng mảng mà ta đã thấy trước đây. Tôi nghĩ chỗ này thực ra phải nằm ở đây, đúng không?
So we can actually get the array multiplier that we have seen before. So this is basically how we actually do that, do two's complement with signed multiplier. So we actually execute this directly.
Vậy là chúng ta có thể thu được bộ nhân dạng mảng mà ta đã thấy trước đây. Về cơ bản, đây là cách chúng ta thực hiện phép nhân có dấu với số bù hai. Chúng ta thực hiện trực tiếp điều này.
We will get our signed multiplier, signed multiplication design, right? So the majority of the structure stay roughly the same.
Chúng ta sẽ có bộ nhân có dấu, thiết kế phép nhân có dấu, đúng không? Phần lớn cấu trúc vẫn gần như giữ nguyên.
We still have our array multiplier design. We do need to add this one here.
Chúng ta vẫn có thiết kế bộ nhân dạng mảng. Chúng ta cần thêm số một này vào đây.
We do need to actually invert those values carefully instead of actually just getting those value, which is not hard to do, right? We just add this bubbles here, right?
Chúng ta cần đảo cẩn thận các giá trị này thay vì chỉ lấy các giá trị đó như cũ, việc này không khó, đúng không? Chúng ta chỉ thêm các vòng tròn đảo ở đây, đúng không?
So we basically have a very similar structure, but we can actually do signed multiplication using this array multiplier here.
Vậy là ta có một cấu trúc rất giống trước, nhưng có thể thực hiện phép nhân có dấu bằng bộ nhân dạng mảng này.
So this makes sense, how we do signed multiplication using a similar array. Again, the two things we do is we first need to do the sign extension, right?
Như vậy là hợp lý, đó là cách ta nhân có dấu bằng một mảng tương tự. Một lần nữa, hai việc chúng ta làm là trước hết cần mở rộng dấu, đúng không?
And then we actually, we used to actually need to subtract the final partial product, right? So that's the first thing and second thing.
Và sau đó, trước đây ta cần trừ tích riêng cuối cùng, đúng không? Đó là việc thứ nhất và việc thứ hai.
And then we, this optimization we discussed before is basically how we get rid of that triangle region, right? All the full adders that we didn't want to add in the design.
Và rồi, phép tối ưu mà chúng ta đã thảo luận trước đó về cơ bản là cách để loại bỏ vùng hình tam giác đó, đúng không? Tất cả các bộ cộng đầy đủ mà chúng ta không muốn đưa vào thiết kế.
Okay, a lot of bitwise manipulation, a lot of design details here.
Được rồi, có rất nhiều thao tác trên bit, rất nhiều chi tiết thiết kế ở đây.
Okay, before I move to flip-flops, any thoughts, comments on adders, multipliers, or the arithmetic, combinational logic in general?
Được rồi, trước khi chuyển sang flip-flop, có ý kiến hay nhận xét nào về bộ cộng, bộ nhân không? hay về logic tổ hợp số học nói chung không?
Well, professor, shouldn't the third line say x3, y2, and then x2, y2, x1, y2, x0, y2?
Thưa thầy, dòng thứ ba không phải nên là x3, y2, rồi x2, y2, x1, y2, x0, y2 sao ạ?
So I'm just making an annotation on Zoom right now to see what it should look like. Oh, yeah, yeah, yeah. Same for the next slide.
Em đang chú thích trên Zoom để xem nó nên trông như thế nào. À vâng, đúng rồi. Slide tiếp theo cũng vậy.
Yeah, you're right. Let me see.
Ừ, em nói đúng. Để thầy xem.
So same here, y2, x0, y2.
Ở đây cũng vậy, y2, x0, y2.
So we have x0, y0, x1, but x0, y2.
Vậy ta có x0, y0, x1, nhưng x0, y2.
Yeah, you're right. We got shifted. I'll update the slide later, but this should be one, and this should be x0, y2.
Ừ, em nói đúng. Nó bị lệch mất. Lát nữa thầy sẽ sửa slide, nhưng chỗ này phải là một, và chỗ này phải là x0, y2.
Yeah, good catch. I'll update the slides afterward. Thank you.
Ừ, em phát hiện tốt lắm. Sau này thầy sẽ cập nhật slide. Cảm ơn em.
Okay, so that's our assigned multiplication. So that question.
Được rồi, đó là phép nhân được giao. Còn câu hỏi này.
Yeah, so generally, that's a good question. So actually, for most of the digital design, this is actually taken care of by the tools, right?
Vâng, nhìn chung đây là một câu hỏi hay. Thực ra với hầu hết thiết kế số, việc này đều do các công cụ lo, đúng không?
So we actually, very rarely, we actually write structural adders manually, right? So very, well, basically, the different tools, they are doing the internal, what people call design space, design space exploration.
Nên thực sự rất hiếm khi ta tự viết thủ công các bộ cộng ở mức cấu trúc. Về cơ bản, các công cụ khác nhau sẽ tự thực hiện bên trong cái mà người ta gọi là khám phá không gian thiết kế (design space exploration).
Basically, if the frequency is not too tight, that default will actually just generate a default ripple-carry adder, right?
Về cơ bản, nếu yêu cầu tần số không quá khắt khe, thì mặc định nó sẽ sinh ra một bộ cộng ripple-carry, đúng không?
And especially for FPGA, because we actually have dedicated ripple-carry adder paths, so that's actually a pretty fast design because it's already hardened, especially for lower bit weights.
Và đặc biệt với FPGA, vì ta có sẵn các đường ripple-carry chuyên dụng, nên đó là một thiết kế khá nhanh vì nó đã được cứng hóa, đặc biệt với số bit nhỏ.
But you will actually want to actually do more optimization when you start doing the tools that will actually do the design space exploration to see how things.
Nhưng bạn sẽ muốn tối ưu hơn nữa khi bạn bắt đầu dùng các công cụ thực hiện khám phá không gian thiết kế để xem mọi thứ ra sao.
That's basically to apply to the majority of the general digital design.
Điều đó về cơ bản áp dụng cho phần lớn thiết kế số thông thường.
For the high performance product, we briefly talked about NVIDIA's design, NVIDIA's adder design, where they are actually using the machine learning to actually learn the prefix tree pattern.
Với các sản phẩm hiệu năng cao, chúng ta đã nói sơ qua về thiết kế bộ cộng của NVIDIA, trong đó họ dùng học máy để học mẫu cây prefix.
They will actually design a particular tree there.
Họ sẽ thiết kế một cây cụ thể ở đó.
So for those, which also applies to a lot of machine learning accelerator, where adder and multiplier is actually the key path, we do see some of the manual design, at least we go into the internal to see how that works.
Vì vậy với những trường hợp này, cũng áp dụng cho nhiều bộ tăng tốc học máy, nơi bộ cộng và bộ nhân là đường then chốt, ta thấy có một số thiết kế thủ công, ít nhất là ta đi sâu vào bên trong để xem nó hoạt động thế nào.
But generally, the tool actually do the design space exploration and will actually generate different adders with different. If you have a very relaxed clock period, we'll just generate a ripple-carry adder.
Nhưng nhìn chung, công cụ sẽ khám phá không gian thiết kế và sinh ra các bộ cộng khác nhau với các. Nếu chu kỳ xung nhịp rất thoải mái, nó sẽ chỉ sinh ra bộ cộng ripple-carry.
If you actually keep pushing that, you will actually do harder, but we'll also have a bigger area, right? So there's always this trade-off of area and performance there, yeah.
Nếu bạn cứ đẩy tiếp, nó sẽ cố gắng hơn, nhưng diện tích cũng sẽ lớn hơn, đúng không? Nên luôn có sự đánh đổi giữa diện tích và hiệu năng ở đây.
Yeah, I think generally we'll see, we'll also see some of the later part of the design, including what we talked about. I got this question a lot, right? For digital designers, right?
Vâng, tôi nghĩ nhìn chung ta sẽ thấy, ta cũng sẽ thấy một số phần sau của thiết kế, bao gồm những gì ta đã nói. Tôi hay gặp câu hỏi này, đúng không? Với các nhà thiết kế số.
Because we're most time doing very long, right? Why do we actually need to understand those low levels? Well, at the same time, well, it's true that tools, today's tools are actually very powerful.
Vì phần lớn thời gian ta làm những việc rất dài, đúng không? Vậy tại sao chúng ta thực sự cần hiểu những mức thấp đó? Thì đúng là các công cụ, các công cụ ngày nay thực sự rất mạnh.
They're doing a lot of optimization internally, but as a designer, it's still very useful to understand what the tools are doing, what kind of trade-offs the tools are actually exploring, so that you can actually reason about and understanding the trade-off, right?
Chúng thực hiện rất nhiều tối ưu hóa bên trong, nhưng là một nhà thiết kế, hiểu các công cụ đang làm gì vẫn rất hữu ích, các công cụ đang khám phá những đánh đổi nào, để bạn có thể lập luận và hiểu được sự đánh đổi đó, đúng không?
Why the area is all of a sudden bigger, right? Because we actually tighten the clock period a lot. So that kind of principle, that kind of integration is very important for digital design.
Tại sao diện tích đột nhiên lớn hơn, đúng không? Bởi vì chúng ta đã siết chu kỳ xung nhịp lại rất nhiều. Nên nguyên tắc như vậy, kiểu tích hợp như vậy rất quan trọng đối với thiết kế số.
Okay, good question. So we talked a lot about combinational logic. Now we're actually going to transition to our sequential logic and see how we actually design some a little bit more the sequential elements.
Được rồi, câu hỏi hay. Chúng ta đã nói nhiều về logic tổ hợp. Giờ chúng ta sẽ chuyển sang logic tuần tự và xem cách thiết kế một số phần tử tuần tự phức tạp hơn một chút.
We'll start from flip-flops, we'll also get to SRAMs either later this week or earlier next week. Ruben?
Chúng ta sẽ bắt đầu từ flip-flop, rồi cũng sẽ đến SRAM vào cuối tuần này hoặc đầu tuần sau. Ruben?
For the, the blocks, which part do you mean?
Về các khối, ý bạn là phần nào?
Oh, it's a single bit. I see, it's a single bit. So the red bits are the signed bits.
À, đó là một bit đơn. Tôi hiểu rồi, là một bit đơn. Các bit màu đỏ là các bit dấu.
So it's basically this. So the red bits are signed bits, the rest of the bits are basically, or this is MSB basically. Yeah, so a single bit, yeah.
Về cơ bản là như thế này. Các bit màu đỏ là bit dấu, các bit còn lại về cơ bản là, hoặc đây về cơ bản là MSB. Vâng, là một bit đơn.
Okay, so that's the two-signed multiplier, and then let's get to flip-flops. Okay, whenever we get to the sequential logic, right, we show this kind of diagram, right?
Được rồi, đó là bộ nhân có dấu bù hai, và giờ chúng ta chuyển sang flip-flop. Được rồi, mỗi khi nói đến logic tuần tự, chúng ta đều vẽ sơ đồ kiểu này, đúng không?
Because sequential logic basically the core part of computation is still combinational logic, but we do have registers or sequential elements before and after so that we can actually register value.
Bởi vì với logic tuần tự, về cơ bản phần cốt lõi của tính toán vẫn là logic tổ hợp, nhưng chúng ta có các thanh ghi hay phần tử tuần tự ở phía trước và phía sau để có thể ghi nhận giá trị.
We can actually store the space, right? We have input in going through a register, and then we do some computation, and then we get the value out, right?
Chúng ta có thể lưu trạng thái, đúng không? Ta có đầu vào đi qua một thanh ghi, rồi thực hiện một số tính toán, và sau đó nhận được giá trị đầu ra, đúng không?
When we talk about sequential logic, generally we'll talk about SRAMs separately, but for a general register, there are two ways of storing sequential logic. The first part is latch.
Khi nói về logic tuần tự, nhìn chung chúng ta sẽ nói riêng về SRAM, nhưng với một thanh ghi thông thường, có hai cách để lưu trữ trong logic tuần tự. Cách thứ nhất là latch.
We have already seen this, you folks probably also see that when you actually design your hardware: basic latches are transparent high or low, right?
Chúng ta đã thấy cái này rồi, các bạn có lẽ cũng đã thấy khi thiết kế phần cứng của mình: các latch cơ bản là trong suốt ở mức cao hoặc mức thấp, đúng không?
We have an equivalent Verilog, right? We actually want to do that.
Chúng ta có đoạn Verilog tương đương, đúng không? Chúng ta muốn làm như vậy.
So instead of the posedge that we use generally, and also strongly recommend you folks to write, for latches it's basically just either clock is high or low, right?
Thay vì posedge mà chúng ta thường dùng, và cũng rất khuyến khích các bạn viết như vậy, với latch thì về cơ bản chỉ là xung nhịp ở mức cao hoặc mức thấp, đúng không?
So it's transparent high or low, right? If the clock is high, we let the value pass through, right? The input, this is the input, q is the output, right?
Tức là trong suốt ở mức cao hoặc mức thấp, đúng không? Nếu xung nhịp ở mức cao, ta cho giá trị đi qua, đúng không? Đầu vào, đây là đầu vào, còn q là đầu ra, đúng không?
Generally we use d to represent input, we use q to represent output, right? If the clock is high, we basically let the value pass through, right?
Nói chung chúng ta dùng d để biểu diễn đầu vào, dùng q để biểu diễn đầu ra, đúng không? Nếu xung clock ở mức cao, về cơ bản chúng ta cho giá trị đi qua, đúng không?
So that's basically transparent high, or there's also transparent low latches, where instead of clock we have clock bar here, right?
Đó chính là transparent high, hoặc cũng có các latch transparent low, trong đó thay vì clock thì ở đây ta có clock bar, đúng không?
So this is instead of edge trigger, this is basically whether the clock is high or low, right?
Vậy nên thay vì kích theo cạnh, ở đây chỉ xét xung clock đang ở mức cao hay mức thấp, đúng không?
In our design, okay, our design we typically use flip-flops, right? So it's basically what we've mentioned also before, it's edge triggered, so we have the clock, right?
Trong thiết kế của chúng ta, được chứ, thiết kế của chúng ta thường dùng flip-flop, đúng không? Như đã nói trước đây, nó được kích theo cạnh, vậy là chúng ta có xung clock, đúng không?
So we are actually observing the rising edge, positive edge, or the falling edge, or negative edge of the clock, right? The data is actually registered during the transition of the clock, right?
Tức là ta quan sát cạnh lên, cạnh dương, hoặc cạnh xuống, cạnh âm của xung clock, đúng không? Dữ liệu thực sự được ghi vào thanh ghi trong lúc xung clock chuyển trạng thái, đúng không?
Again, we have input from the d port and output to the q port, right? When it comes to flip-flops, we always talk about timing, right?
Một lần nữa, ta có đầu vào từ cổng d và đầu ra tới cổng q, đúng không? Khi nói đến flip-flop, chúng ta luôn nói về định thời, đúng không?
We briefly discussed this at the very beginning, we talked about different design metrics, but we'll see a little bit more different contributing factors of flip-flop timing actually as we're designing the sequential elements, right?
Chúng ta đã thảo luận ngắn gọn điều này ngay từ đầu, khi nói về các chỉ số thiết kế khác nhau, nhưng ta sẽ thấy rõ hơn một chút các yếu tố khác nhau góp phần vào định thời của flip-flop khi chúng ta thiết kế các phần tử tuần tự, đúng không?
So generally, different components here, we care about what we call setup time, where we'll see a definition earlier, But this is basically how long, how early the input needs to actually be settled, actually be stable before the clock joins, right?
Nói chung, với các thành phần khác nhau ở đây, chúng ta quan tâm đến cái gọi là thời gian thiết lập (setup time), mà ta đã thấy định nghĩa trước đó. Về cơ bản đó là khoảng thời gian, đầu vào cần ổn định sớm đến mức nào, tức là phải ổn định trước khi xung clock tới, đúng không?
So the input needs to be ready, so once the clock starts, we can actually sample this value once the clock actually triggered, right? So there is setup time.
Vậy đầu vào cần sẵn sàng, để khi xung clock bắt đầu, chúng ta có thể lấy mẫu giá trị này ngay khi clock kích, đúng không? Vậy là có thời gian thiết lập.
The input needs to be actually ready before the clock, right? So that's what we call the setup time, right?
Đầu vào cần sẵn sàng trước xung clock, đúng không? Đó là cái ta gọi là thời gian thiết lập, đúng không?
It's between input and the clock, and the input needs to be ready before the clock, right? We also talk about the hold time, right?
Nó nằm giữa đầu vào và xung clock, và đầu vào cần sẵn sàng trước xung clock, đúng không? Chúng ta cũng nói về thời gian giữ (hold time), đúng không?
Or hold time, we'll see another example that maybe makes better sense for the next, for the next clock cycle.
Với thời gian giữ, ta sẽ xem một ví dụ khác có thể dễ hiểu hơn, cho chu kỳ clock tiếp theo.
The hold time is basically the data needs to actually be held stable, because the transition doesn't happen all of a sudden, right? We'll talk about this: actually it takes time during the transition.
Thời gian giữ về cơ bản là dữ liệu cần được giữ ổn định, vì quá trình chuyển trạng thái không xảy ra đột ngột, đúng không? Ta sẽ nói về điều này: thực tế quá trình chuyển trạng thái cần thời gian.
It's an RC circuit, it takes time during the transition, so the input needs to be held long enough, which is the hold time, so that we can actually correctly get to the output.
Nó là một mạch RC, quá trình chuyển trạng thái cần thời gian, nên đầu vào cần được giữ đủ lâu, đó là thời gian giữ, để chúng ta có thể lấy được đầu ra một cách chính xác.
Here is our output, right?
Đây là đầu ra của chúng ta, đúng không?
So the input needs to be actually also stable for a period of time after the clock, so that we can actually get the output, the output Q actually correctly, right?
Vậy đầu vào cũng cần phải ổn định trong một khoảng thời gian sau xung clock, để chúng ta có thể lấy được đầu ra, đầu ra Q, một cách chính xác, đúng không?
So those are very important. So whenever we introduce a register or introduce a stage, it's not free, right? We need to actually meet the setup and hold time requirements.
Vì vậy những điều này rất quan trọng. Nên mỗi khi đưa vào một thanh ghi hay một tầng, nó không miễn phí, đúng không? Chúng ta cần đáp ứng các yêu cầu về thời gian thiết lập và thời gian giữ.
All of those actually introduce other delay components in our circuit. So the setup and hold time is between the data, between the input and clock, right?
Tất cả những thứ đó thực ra đều đưa thêm các thành phần trễ khác vào mạch của chúng ta. Vậy thời gian setup và hold là giữa dữ liệu, tức là giữa đầu vào và xung clock, đúng không?
Between input and the clock. There is also another pair, which is between clock and output, right?
Giữa đầu vào và xung clock. Còn có một cặp khác nữa, là giữa clock và đầu ra, đúng không?
Once the clock is triggered, how long until the output is actually ready, how much longer we need to wait until we can start consuming the output?
Khi clock được kích hoạt, bao lâu sau thì đầu ra thực sự sẵn sàng, chúng ta cần chờ thêm bao lâu nữa thì mới có thể bắt đầu dùng đầu ra?
So that's what we generally call clock-to-Q delay, right? Clock-to-Q delay is between clock and output, Right? So three pairs, or three different clock components, talking about two pairs of relationships.
Đó chính là cái mà ta thường gọi là trễ clock-to-Q, đúng không? Trễ clock-to-Q là giữa clock và đầu ra, đúng không? Vậy là ba thành phần, hay ba thành phần thời gian khác nhau của clock, nói về hai cặp quan hệ.
The first is between input and clock, right? So how much longer earlier the input needs to be ready before the clock triggers, so that's the setup, right?
Cặp đầu tiên là giữa đầu vào và clock, đúng không? Tức là đầu vào cần sẵn sàng sớm hơn bao lâu trước khi clock kích hoạt, đó là setup, đúng không?
How much longer the input needs to actually hold, stay the same, before actually we can actually update the value, that's basically the hold value, so we can actually capture the value directly.
Đầu vào cần được giữ trong bao lâu nữa, giữ nguyên không đổi, trước khi ta thực sự có thể cập nhật giá trị, đó chính là thời gian hold, để chúng ta có thể chốt được giá trị một cách trực tiếp.
And then another pair is between clock and output, right?
Và cặp còn lại là giữa clock và đầu ra, đúng không?
Clock-to-queue delay, how much longer we need to wait so we can actually start consuming the value, so that the value is actually ready from the output, right?
Trễ clock-to-Q, tức là ta cần chờ thêm bao lâu để có thể bắt đầu dùng giá trị, để giá trị đó thực sự sẵn sàng ở đầu ra, đúng không?
So it's input and a clock pair, and output and the clock pair, so that's basically the different timing relationship we actually care about. Always think about different transitions, right?
Vậy có cặp đầu vào và clock, và cặp đầu ra và clock, đó chính là các quan hệ thời gian khác nhau mà chúng ta quan tâm. Hãy luôn nghĩ đến các chuyển tiếp khác nhau, đúng không?
We'll see how we actually build flip-flops either later today or this Thursday, right? And we can see there are different transistors involved, that's why it actually takes time to propagate the signal, right?
Chúng ta sẽ xem cách xây dựng flip-flop hoặc là trong buổi hôm nay hoặc là vào thứ Năm này, được chứ? Và ta sẽ thấy có nhiều transistor khác nhau tham gia, đó là lý do tại sao việc lan truyền tín hiệu thực sự mất thời gian, đúng không?
So just a quick recap, we talked about the different timing components, we mentioned that here, I also have them right up here, so that you can also review that later, right?
Vậy xin nhắc lại nhanh, chúng ta đã nói về các thành phần thời gian khác nhau, chúng ta đã đề cập ở đây, tôi cũng để chúng ngay trên này, để các bạn có thể xem lại sau, đúng không?
So again, setup and hold time is between input D and the clock, and the clock-to-queue is basically Q and the clock, right?
Một lần nữa, thời gian setup và hold là giữa đầu vào D và clock, còn clock-to-Q thì là giữa Q và clock, đúng không?
So it's two different pairs, input-to-clock, input and clock, and the output and clock, right?
Vậy là hai cặp khác nhau, đầu vào với clock, đầu vào và clock, rồi đầu ra và clock, đúng không?
Setup is before the clock arrives, how long, like, my data need to be ready so that we can actually capture the data.
Setup là trước khi clock đến, trong bao lâu, tức là dữ liệu của tôi cần sẵn sàng trong bao lâu để chúng ta có thể chốt được dữ liệu.
Hold time is actually after the clock arrives, we actually also need to hold our data so that the signal can actually propagate, right? So between input and clock.
Thời gian hold là sau khi clock đến, chúng ta cũng cần giữ dữ liệu của mình để tín hiệu có thể lan truyền, đúng không? Vậy là giữa đầu vào và clock.
This actually contributes, that's what we mean earlier, right? Whenever we add actually a register, it's not free, it's actually adding more related components in our circuit, so we actually think about our timing.
Điều này góp thêm độ trễ, đó là ý tôi nói lúc nãy, đúng không? Mỗi khi thêm một thanh ghi, nó không miễn phí, nó thêm các thành phần liên quan vào mạch của chúng ta, nên ta cần suy nghĩ về thời gian của thiết kế.
So far before, we mostly talked about the combinational logic, right? So now we also see the sequential logic, register also contributes to the timing discussion.
Từ trước đến giờ, chúng ta chủ yếu nói về logic tổ hợp, đúng không? Còn bây giờ chúng ta cũng thấy logic tuần tự, thanh ghi cũng đóng góp vào phần thảo luận về thời gian.
So now you will actually look at our design, right? We talked about, question?
Vậy bây giờ các bạn sẽ nhìn vào thiết kế của chúng ta, đúng không? Chúng ta đã nói về, bạn có câu hỏi không?
Yes, generally, you want the data to hold long enough so that you can propagate, right? So you can actually propagate to the output, right?
Vâng, nói chung là, bạn muốn dữ liệu được giữ đủ lâu để có thể lan truyền, đúng không? Để dữ liệu thực sự lan truyền được tới đầu ra, đúng không?
So that's why we actually want to hold the data from the input.
Đó là lý do chúng ta muốn giữ dữ liệu từ đầu vào.
Yeah, so we'll actually see a flip-flop design later, you will actually see a flip-flop is actually two stages.
Vâng, lát nữa chúng ta sẽ thấy thiết kế flip-flop, các bạn sẽ thấy một flip-flop thực ra gồm hai tầng.
So there is one stage where we basically register the input, and after that the input can change, but we're actually using the next stage to propagate.
Có một tầng mà ở đó chúng ta về cơ bản đăng ký (lưu) đầu vào, và sau đó đầu vào có thể thay đổi, nhưng chúng ta dùng tầng tiếp theo để lan truyền.
So a flip-flop is actually two, so we're actually using a pair of latches to build flip-flops, right? So a flip-flop actually propagates through two stages. Yeah, so that's the clock-to-Q delay here, good question.
Vậy một flip-flop thực ra gồm hai, tức là chúng ta dùng một cặp latch để xây dựng flip-flop, đúng không? Vậy một flip-flop lan truyền dữ liệu qua hai tầng. Vâng, đó chính là độ trễ clock-to-Q ở đây, câu hỏi hay.
So with those different timing considerations, so now you will actually look at different clock periods, right? So far we mostly, okay, a frequency, right?
Với những yếu tố thời gian khác nhau đó, bây giờ các bạn sẽ xem xét các chu kỳ xung nhịp khác nhau, đúng không? Cho đến giờ chủ yếu, được rồi, là tần số, đúng không?
So frequency, like how much combinational logic we actually add to our design, but you will actually look into things that actually happen during our clock period, right?
Tức là tần số, ví dụ như chúng ta thêm bao nhiêu logic tổ hợp vào thiết kế, nhưng các bạn sẽ xem xét những điều xảy ra trong một chu kỳ xung nhịp của chúng ta, đúng không?
So this is our clock period here, right? So first, like the data needs to be stable actually, so that we can actually sample the data for the next cycle, right?
Đây là chu kỳ xung nhịp của chúng ta, đúng không? Trước hết, dữ liệu cần phải ổn định, để chúng ta có thể lấy mẫu dữ liệu cho chu kỳ tiếp theo, đúng không?
So the data still needs to hold there so that we can make sure that we can actually sample before it actually changes.
Vậy dữ liệu vẫn cần được giữ ở đó để chúng ta chắc chắn là có thể lấy mẫu trước khi nó thay đổi.
So we need to have hold time here, and we also need, before the next clock edge, we also need to actually, the data needs to arrive early, right?
Vì vậy chúng ta cần có thời gian giữ (hold time) ở đây, và chúng ta cũng cần, trước cạnh xung nhịp tiếp theo, dữ liệu cũng phải đến sớm, đúng không?
It cannot just arrive right before the clock, then we may actually not be able to capture that data.
Nó không thể đến ngay sát trước xung nhịp, vì khi đó chúng ta có thể không bắt được dữ liệu đó.
So we also need to actually have some time here, meet the setup time requirements so that we can actually correctly capture the data, Right? So that already eats into our clock period, right?
Vì vậy chúng ta cũng cần có một khoảng thời gian ở đây, đáp ứng yêu cầu về thời gian thiết lập (setup time) để có thể bắt dữ liệu một cách chính xác, đúng không? Như vậy là đã chiếm bớt một phần chu kỳ xung nhịp của chúng ta, đúng không?
Different clock, different delay distribution, right? So then this is actually the, what things in the middle is actually the different combinational logic that we consider, right?
Xung nhịp khác nhau, phân bố độ trễ khác nhau, đúng không? Vậy đây chính là, những thứ ở giữa chính là các logic tổ hợp mà chúng ta xét, đúng không?
The combinational logics that actually take time, that will be the core part, right?
Các logic tổ hợp tốn thời gian, đó sẽ là phần cốt lõi, đúng không?
And in real design, it's actually very rare we do this so tight with just actually everything just fit perfectly, because there are like a lot of variations, like the guest lecture we also talk about, right?
Và trong thiết kế thực tế, rất hiếm khi chúng ta làm sát như vậy, mọi thứ vừa khít hoàn hảo, vì có rất nhiều biến thiên, như bài giảng của khách mời cũng đã nói, đúng không?
There are like a lot of variations. We need to actually have some buffers in our design so that we can actually handle different scenarios, different design variation.
Có rất nhiều biến thiên. Chúng ta cần có một số khoảng đệm trong thiết kế để có thể xử lý các kịch bản khác nhau, các biến thiên thiết kế khác nhau.
So in reality, the real switching time is actually even more cramped.
Vì vậy trong thực tế, thời gian chuyển mạch thực sự còn bị bó hẹp hơn nữa.
It's actually a small part of the design where we also need to actually provision enough slack so that we have a lot, a little bit, our hardware is actually a little bit more resilient under different consideration, right?
Nó chỉ là một phần nhỏ của thiết kế, và chúng ta còn cần phải dự trù thêm đủ độ dư thời gian (slack), để chúng ta có nhiều, hay một chút, để phần cứng của mình có khả năng chịu đựng tốt hơn một chút trong các điều kiện khác nhau, đúng không?
So, so far, we mostly talk about the combinational logic part.
Vậy nên đến giờ, chúng ta chủ yếu nói về phần logic tổ hợp.
We'll see some of the different latency contribution of the combinational logic to the overall clock period, but all of those different setup time, hold time, and also keeping your design having some slack, also eat into actually the achievable frequency that we can get, right?
Chúng ta sẽ thấy một số thành phần độ trễ khác nhau của logic tổ hợp đóng góp vào chu kỳ xung nhịp tổng thể, nhưng tất cả những thứ như thời gian thiết lập (setup time), thời gian giữ (hold time), và cả việc giữ cho thiết kế có một chút slack, cũng lấy đi một phần tần số tối đa mà chúng ta có thể đạt được, đúng không?
So all of the delay consideration actually need to be considered when we actually think about the full pipeline, the full design here.
Vì vậy tất cả các yếu tố về độ trễ này đều cần được tính đến khi chúng ta xét toàn bộ đường ống, toàn bộ thiết kế ở đây.
So we'll actually see how that's, again, into how we actually calculate what are the requirements for the clock period later, but before that, questions?
Chúng ta sẽ thấy lại điều đó khi tính toán các yêu cầu đối với chu kỳ xung nhịp ở phần sau, nhưng trước đó, có câu hỏi nào không?
So just to clarify this, early slack and mid slack are different from your hold time and setup time, which are physical characteristics of your topology and your technology.
Để làm rõ điều này, early slack và late slack khác với thời gian giữ và thời gian thiết lập của bạn, vốn là các đặc tính vật lý của cấu trúc mạch và công nghệ của bạn.
And they exist to account for variations of things like the clock, the temperature. Right, right.
Và chúng tồn tại để tính đến các biến thiên như xung nhịp, nhiệt độ. Đúng, đúng.
So this is on top of that, when you read your timing report, you generally, you have some slack there in your design.
Vậy đây là phần cộng thêm lên trên đó; khi đọc báo cáo định thời, nhìn chung bạn có một chút slack trong thiết kế của mình.
So those are basically, Already consider that there's slack in the design part. Then what is the symmetry of this diagram?
Về cơ bản những giá trị đó đã tính đến việc có slack trong thiết kế rồi. Vậy tính đối xứng của sơ đồ này là gì?
How do early slack and mid slack typically compare over time? You mean symmetry in terms of which one is longer or shorter? That's the, I mean, it depends.
Thông thường early slack và late slack so với nhau theo thời gian như thế nào? Ý bạn là tính đối xứng xét về cái nào dài hơn hay ngắn hơn? Ý tôi là, điều đó còn tùy.
It depends on the slack part. And it's really hard to actually even say what is early slack, what is, like, you just want to add some buffers in your design, right?
Nó tùy vào phần slack. Và thực sự rất khó để nói đâu là early slack, đâu là late slack, bạn chỉ muốn thêm một số buffer vào thiết kế thôi, đúng không?
So is there just a, I actually don't know, like, early slack and late slack, just really some buffers.
Nên thật ra tôi cũng không biết nữa, early slack và late slack, thực chất chỉ là một số buffer.
And you really, you don't design this way, just that you want to make sure you have some slack overall compared to your combinational logic. Setup time and hold time is more technology dependent.
Và bạn thực sự không thiết kế theo cách đó, mà chỉ muốn đảm bảo rằng bạn có một chút slack tổng thể so với logic tổ hợp của mình. Còn thời gian thiết lập và thời gian giữ thì phụ thuộc vào công nghệ nhiều hơn.
Yeah, that's a good question. Yeah, everything here is combinational, right?
Vâng, đó là một câu hỏi hay. Vâng, mọi thứ ở đây đều là tổ hợp, đúng không?
I think this is just an illustration. This is just a solution. Yeah, that's what I mean. Like, it's hard to have to even separate early slack and the lax.
Tôi nghĩ đây chỉ là một hình minh họa. Đây chỉ là một lời giải. Vâng, ý tôi là vậy. Chẳng hạn, rất khó để tách riêng early slack và late slack.
Whenever the data is ready, you just start propagating there, right? Yeah.
Khi nào dữ liệu sẵn sàng thì bạn bắt đầu lan truyền ở đó, đúng không? Vâng.
Oh, why do we need to keep the whole time?
À, tại sao chúng ta cần giữ trong suốt khoảng thời gian đó?
Oh, I see.
À, tôi hiểu rồi.
So you're asking why this need to be stable for, so you will have, so the whole time here is to make sure, yeah, so the whole time is to make sure we can actually propagate to the next stage here,
Vậy bạn đang hỏi tại sao tín hiệu này cần ổn định trong, vậy thì, toàn bộ khoảng thời gian ở đây là để đảm bảo, vâng, toàn bộ khoảng thời gian này là để đảm bảo chúng ta thực sự có thể lan truyền sang tầng tiếp theo ở đây,
right? So whole time is between input and output, so between input and the clock, right? So this is basically, and this is the v and the q, right?
đúng không? Vậy toàn bộ khoảng thời gian này nằm giữa đầu vào và đầu ra, tức là giữa đầu vào và xung clock, đúng không? Đây về cơ bản là v và q, đúng không?
So this is basically before, we don't want to change this input, right? We want this input to stay, like, stable long enough before we actually overwrite this input here.
Về cơ bản là trước đó, chúng ta không muốn thay đổi đầu vào này, đúng không? Chúng ta muốn đầu vào này giữ ổn định đủ lâu trước khi ta thực sự ghi đè lên đầu vào này.
Is that what you're wondering, or?
Bạn đang thắc mắc điều đó phải không, hay là?
I think we'll actually, it will be clear when we actually see a little later example.
Tôi nghĩ nó sẽ rõ hơn khi chúng ta xem một ví dụ sau đây một chút.
This is actually not overwrite ourselves, so that we actually, for the next stage, it actually captures the right data. Let's look at the example. I think it will be clear later.
Thực ra là để không tự ghi đè lên chính mình, để ở tầng tiếp theo, nó thực sự bắt được đúng dữ liệu. Hãy xem ví dụ. Tôi nghĩ sau đó sẽ rõ.
Mm-hmm. Yeah, so this is an illustration, so hold time actually doesn't directly contribute to the clock here. We'll actually see another example.
Ừm. Vâng, đây là một hình minh họa, nên thời gian giữ (hold time) thực ra không đóng góp trực tiếp vào chu kỳ clock ở đây. Chúng ta sẽ xem một ví dụ khác.
I think this illustration may be a little bit confusing, just in terms of how... Let's see another example in a minute.
Tôi nghĩ hình minh họa này có thể hơi gây nhầm lẫn, xét về cách... Lát nữa ta sẽ xem một ví dụ khác.
I think that will be actually a little bit easier, but this is just an illustration of all of the different factors that actually contribute to the overall delay.
Tôi nghĩ ví dụ đó sẽ dễ hiểu hơn một chút, còn đây chỉ là hình minh họa tất cả các yếu tố khác nhau đóng góp vào độ trễ tổng thể.
Okay, so we'll see another example later. I guess some announcements here. So, plan this week.
Được rồi, lát nữa chúng ta sẽ xem một ví dụ khác. Tôi xin thông báo vài điều. Kế hoạch của tuần này.
At this point, I think we are, the GSIs or the TAs are announcing their plans, I think, day by day. There's just a lot of uncertainty here.
Hiện tại, tôi nghĩ các GSI hay các trợ giảng đang thông báo kế hoạch của họ, tôi nghĩ là từng ngày một. Có rất nhiều điều chưa chắc chắn.
I personally also don't have a lot of visibility in terms of how the negotiation is going. So the GSIs are making their decisions on whether they want to hold discussions, office hours and labs.
Cá nhân tôi cũng không nắm được nhiều thông tin về việc đàm phán đang diễn ra thế nào. Các GSI tự quyết định xem có tổ chức buổi thảo luận, giờ hỗ trợ và buổi thực hành hay không.
So the course calendar is the best place to check the information. Everything will be updated. The GSIs, they are trying their best. It's also a very challenging time for them.
Vì vậy lịch học của môn là nơi tốt nhất để xem thông tin. Mọi thứ sẽ được cập nhật. Các GSI đang cố gắng hết sức. Đây cũng là một giai đoạn rất khó khăn với họ.
I don't think we can predict what's going to happen in the future. So they will announce their plan at least 24 hours before their session. So keep an eye on the calendar.
Tôi nghĩ chúng ta không thể dự đoán điều gì sẽ xảy ra trong tương lai. Họ sẽ thông báo kế hoạch ít nhất 24 giờ trước buổi học của mình. Vì vậy hãy theo dõi lịch.
We do, at least I personally do, recommend all of us, I recommend or respect each individual's decision. They are making their individual decisions. There's a lot of uncertainty here.
Ít nhất là cá nhân tôi, tôi đề nghị tất cả chúng ta hãy tôn trọng quyết định của từng người. Họ đang tự đưa ra quyết định của mình. Có rất nhiều điều chưa chắc chắn.
We should just give them enough trust and freedom so that we respect the ways they like to spend their time, given all of this going on.
Chúng ta nên dành cho họ đủ sự tin tưởng và tự do để tôn trọng cách họ muốn sử dụng thời gian của mình, trong bối cảnh tất cả những chuyện này đang diễn ra.
Project timeline, I think we don't, just overall timeline of the semester, we only have one more homework left. We'll release before Thanksgiving and it will be more like a two-week homework.
Về tiến độ dự án, tôi nghĩ là, nói chung về tiến độ của cả học kỳ, chúng ta chỉ còn một bài tập về nhà nữa. Chúng tôi sẽ đăng trước Lễ Tạ ơn và đó sẽ giống bài tập về nhà kéo dài hai tuần.
So it'll be due in two weeks. And really the hard timeline is on the project end. We do have a project deadline this Friday. I thought a lot on this.
Vì vậy hạn nộp là hai tuần nữa. Và thời hạn thực sự gấp là ở phần dự án. Chúng ta có hạn nộp dự án vào thứ Sáu này. Tôi đã suy nghĩ nhiều về việc này.
I guess I don't have a lot of folks to talk about these days. So I thought a lot on this.
Tôi đoán dạo này tôi cũng không có nhiều người để trò chuyện về chuyện này. Nên tôi đã suy nghĩ rất nhiều về điều này.
I don't want to change the deadline, because the deadline is set so that you folks can be productive to finish your project on time.
Tôi không muốn thay đổi hạn nộp, vì hạn nộp được đặt ra để các bạn có thể làm việc hiệu quả và hoàn thành dự án đúng hạn.
So we'll stay, keep this deadline, but understand there'll be not enough staff support. So we'll be making this deadline a soft deadline. So you will not get penalized if you miss this deadline.
Vì vậy chúng ta sẽ giữ nguyên hạn nộp này, nhưng xin hiểu rằng sẽ không đủ nhân sự hỗ trợ. Vì thế chúng tôi sẽ biến đây thành một hạn nộp mềm. Các bạn sẽ không bị phạt nếu lỡ hạn nộp này.
But from a project timeline point of view, we still strongly recommend, if you can, in your capacity, to actually shoot for the deadline and try to finish checkpoint two, because that's really the majority.
Nhưng xét về tiến độ của dự án, chúng tôi vẫn rất khuyến khích, nếu trong khả năng của các bạn, hãy cố gắng đạt hạn nộp và hoàn thành checkpoint hai, vì đó thực sự là phần chiếm đa số.
That's really the meat of the project. You will get checkpoint two. You'll be fine. Checkpoint three and four will be a lot lighter. It's more just really thinking about optimizing.
Đó thực sự là phần cốt lõi của dự án. Các bạn sẽ làm được checkpoint hai. Sẽ ổn thôi. Checkpoint ba và bốn sẽ nhẹ hơn nhiều. Chủ yếu chỉ là suy nghĩ về việc tối ưu hóa.
Checkpoint two is very important. So that's why I still like to just set the deadline there.
Checkpoint hai rất quan trọng. Vì vậy tôi vẫn muốn đặt hạn nộp ở đó.
So you folks are aware this is the deadline to hit, but it will also be a soft deadline. So there will be no penalty if you actually couldn't make the deadline.
Để các bạn biết đây là mốc cần đạt, nhưng nó cũng là một hạn nộp mềm. Nên sẽ không bị phạt nếu các bạn không kịp hạn nộp.
And for checkoff, instead of doing in-person checkoff, we're also doing Gradescope checkoff. So you're basically, there are scripts we can run.
Còn về phần checkoff, thay vì checkoff trực tiếp, chúng ta cũng sẽ checkoff qua Gradescope. Tức là có những script mà chúng ta có thể chạy.
So you basically run the script and submit the screenshot, and that will account for checkoff. There's really no reason to actually work around the checkoff.
Các bạn chỉ cần chạy script rồi nộp ảnh chụp màn hình, và như vậy được tính là đã checkoff. Thực sự không có lý do gì để lách phần checkoff.
There's no reason to fake a screenshot, because you still need to check your functionality for the final checkoff. There's really zero motivation to do any of that.
Không có lý do gì để làm giả ảnh chụp màn hình, vì các bạn vẫn cần kiểm tra chức năng cho lần checkoff cuối cùng. Thực sự không có động cơ nào để làm vậy.
You want to make sure your things actually do work. So there's no reason to fake it.
Các bạn muốn đảm bảo sản phẩm của mình thật sự chạy đúng. Nên không có lý do gì để làm giả.
So it's a Gradescope checkoff so that you don't actually have to show up in person to do the checkoff. We do have a short homework, homework eight, due this week.
Checkoff qua Gradescope là để các bạn không phải đến tận nơi để checkoff. Chúng ta có một bài tập về nhà ngắn, bài tập về nhà tám, hạn nộp trong tuần này.
This is really just help you to review some material. It will be a pretty short homework. For the gray scope checkoff, do you do it with one partner? Only one partner.
Bài này chỉ giúp các bạn ôn lại một số nội dung. Đó sẽ là một bài tập khá ngắn. Với checkoff qua Gradescope, làm cùng một bạn đồng đội phải không? Chỉ một bạn thôi.
So in the checkoff, it will ask you your team number, your name, and your partner's name. So only one of you need to do the submission.
Trong phần checkoff, hệ thống sẽ hỏi số nhóm của các bạn, tên của bạn và tên của đồng đội. Vì vậy chỉ cần một người trong hai bạn nộp bài.
Any other questions about the logistics of the class?
Còn câu hỏi nào khác về vấn đề tổ chức lớp học không?
Homework seven, the past homework, right? You folks already have the slip days, right? That's where the slip days... Yeah, yeah, yeah. Use your slip day. There are no more homework left.
Bài tập về nhà bảy, bài vừa rồi, đúng không? Các bạn đã có slip day rồi, đúng không? Đó là chỗ dùng slip day... Vâng, vâng. Cứ dùng slip day của các bạn. Không còn bài tập về nhà nào nữa.
Don't need to actually save your slip days. There's no more homework left. I don't like using it. You like me for the final homework? You need to use it.
Không cần phải để dành slip day. Không còn bài tập về nhà nào nữa. Tôi không thích dùng nó. Bạn thích tôi cho bài tập cuối à? Bạn cần dùng nó.
So don't save your slip days. Well, just keep doing what you're doing. And homework is really just, it's still very valuable to finish the homework.
Vì vậy đừng để dành slip day. Cứ tiếp tục làm những gì các bạn đang làm. Và bài tập về nhà thì vẫn rất có giá trị, nên hãy hoàn thành nó.
And even with slip days, with everything, it's just will be a very, very small part of the grade. So just keep doing what you are doing and finish the homework.
Và ngay cả khi tính cả ngày trễ hạn, tính cả mọi thứ, thì nó cũng chỉ chiếm một phần rất, rất nhỏ trong điểm số. Nên cứ tiếp tục làm như các bạn đang làm và hoàn thành bài tập về nhà.
And no reason to save your slip days. Yeah. Slip days have seven days. Everyone has seven days for homework only, that is separated from the lab slip days.
Và không có lý do gì để để dành ngày trễ hạn cả. Vâng. Ngày trễ hạn có bảy ngày. Mỗi người có bảy ngày chỉ dành cho bài tập về nhà, tách biệt với ngày trễ hạn của bài thực hành.
Any other logistic-related questions for folks online?
Còn câu hỏi nào khác liên quan đến tổ chức từ các bạn học trực tuyến không?
Yes, so negotiation is still ongoing. I personally have very little visibility in terms of what's going on. So again, as I mentioned, we'll just announce day by day.
Vâng, việc thương lượng vẫn đang tiếp diễn. Cá nhân tôi biết rất ít về những gì đang diễn ra. Nên như tôi đã nói, chúng tôi sẽ thông báo từng ngày.
Okay, so I guess we already had a lot of discussions on the timing from the illustration, but let's look at a more concrete example to see how that actually affects the timing behavior, especially with cycle time here.
Được rồi, tôi nghĩ chúng ta đã thảo luận khá nhiều về thời gian qua hình minh họa, nhưng hãy xem một ví dụ cụ thể hơn để thấy điều đó thực sự ảnh hưởng thế nào đến hành vi thời gian, đặc biệt là chu kỳ xung nhịp ở đây.
So we mentioned this is our sequential logic. We have our flip-flop here, edge trigger. We have our clock. And then in the middle, we have some combinational logic here.
Chúng ta đã nói đây là mạch logic tuần tự. Ở đây có flip-flop kích theo cạnh. Chúng ta có xung nhịp. Và ở giữa, chúng ta có một khối logic tổ hợp.
So the before is a little bit cartoon illustration, but let's look at things more specifically. What are the different factors that contribute to the delay?
Hình trước đó hơi mang tính minh họa sơ lược, nhưng hãy xem xét cụ thể hơn. Những yếu tố nào góp phần tạo ra độ trễ?
We talked about clock to Q, clock to Q delay. And then between input and clock, we have setup time and hold time. Setup time and hold time.
Chúng ta đã nói về clock to Q, độ trễ clock to Q. Và giữa đầu vào và xung nhịp, chúng ta có thời gian setup và thời gian hold. Thời gian setup và thời gian hold.
For the logic, combinational logic, we have the logic propagation time. And there could be branches in our logic. Some paths are faster, some paths are slower.
Với logic tổ hợp, chúng ta có thời gian lan truyền của logic. Và trong logic có thể có các nhánh. Có đường nhanh hơn, có đường chậm hơn.
We typically just here take the extreme cases: a minimum delay from the combinational logic and also the maximum delay from the combinational logic. So we look at the cycle time.
Ở đây thường ta chỉ lấy các trường hợp cực trị: độ trễ nhỏ nhất của logic tổ hợp và cả độ trễ lớn nhất của logic tổ hợp. Vậy ta xét chu kỳ xung nhịp.
So we always mentioned the critical path. So before, we always say critical path is basically mostly focusing on the logic. It's the longest path in our combinational logic.
Chúng ta luôn nhắc đến đường tới hạn. Trước đây ta luôn nói đường tới hạn chủ yếu tập trung vào phần logic. Đó là đường dài nhất trong logic tổ hợp.
But when we actually have our registers here, we look at things actually going on during a time period here. So it's not just a logic time. There's also delays related to register transfer.
Nhưng khi thực sự có các thanh ghi ở đây, ta xem xét những gì diễn ra trong một khoảng thời gian. Vậy nó không chỉ là thời gian của logic. Còn có các độ trễ liên quan đến việc chuyển dữ liệu giữa các thanh ghi.
So register transfer here. So that's what we discussed here, the logic, the time part.
Tức là chuyển thanh ghi ở đây. Đó là những gì chúng ta đã bàn ở đây: phần logic, phần thời gian.
So first, we need to actually have, once the clock triggered, we need to make sure the data is propagated to the Q, to the output. So that's our clock to Q delay.
Đầu tiên, khi xung nhịp kích hoạt, ta cần đảm bảo dữ liệu được lan truyền tới Q, tới đầu ra. Đó là độ trễ clock to Q.
So the output is updated with the new value. After that, we need to propagate. So that's the first part. After that, we need to propagate through our combinational logic.
Tức là đầu ra được cập nhật giá trị mới. Sau đó, ta cần lan truyền. Đó là phần đầu tiên. Sau đó, ta cần lan truyền qua logic tổ hợp.
Again, for this, we're looking at the longest, the max time. We're looking at the longest time because this will be our critical path.
Một lần nữa, ở đây ta xét thời gian dài nhất, tức là lớn nhất. Ta xét thời gian dài nhất vì đó sẽ là đường tới hạn của chúng ta.
Once we get to the end of our combinational logic, we mentioned our data also needs to be stable for a while before the next clock triggers.
Khi đã tới cuối khối logic tổ hợp, chúng ta đã nói là dữ liệu cũng cần phải ổn định trong một khoảng thời gian trước khi xung clock tiếp theo kích hoạt.
So this is our setup time, the third part. So the data, the input needs to be actually stable actually before the clock arrives.
Đây là thời gian thiết lập (setup time), thành phần thứ ba. Vậy dữ liệu, đầu vào thực sự cần phải ổn định trước khi xung clock đến.
So those three components: clock to Q delays, the longest path of our combinational logic, and the setup time For the next clock edge, that basically contributes to the longest path or critical path.
Vậy ba thành phần này: độ trễ clock đến Q, đường đi dài nhất của logic tổ hợp, và thời gian thiết lập cho cạnh clock kế tiếp, về cơ bản đóng góp vào đường đi dài nhất, hay đường tới hạn.
And that actually determines our clock period. So that's basically the different components. You will actually look at the timing. Instead of looking at the cartoon, look at actually the timing transitions.
Và điều đó quyết định chu kỳ clock của chúng ta. Đó về cơ bản là các thành phần khác nhau. Các em sẽ xem xét giản đồ thời gian. Thay vì nhìn hình minh họa, hãy nhìn các chuyển tiếp thời gian thực tế.
So this actually, our minimum cycle time, is actually set by the longest logical path. Does this make sense? All the different things here?
Vậy thời gian chu kỳ tối thiểu của chúng ta được quyết định bởi đường logic dài nhất. Các em hiểu chưa? Tất cả những phần khác nhau ở đây?
How would the whole time after you change the minimum clock period? Don't we need, like, all the values that have been set up for a while?
Thời gian giữ (hold) ảnh hưởng thế nào đến chu kỳ clock tối thiểu? Chẳng phải mọi giá trị cần được thiết lập trước một lúc sao?
Hold stays after the clock. We'll actually see hold time there. That's also related to some kind of, to some other part of, so here.
Thời gian giữ là phần ở lại sau xung clock. Chúng ta sẽ xem thời gian giữ ở đó. Cái đó cũng liên quan đến một phần khác, ở đây.
Yeah, you would have to use the hold time, but the argument has to be very small. Well, one thing here is that, okay, so we say setup time here is important.
Vâng, em sẽ phải dùng thời gian giữ, nhưng giá trị đó phải rất nhỏ. Một điều ở đây là, được rồi, ta nói thời gian thiết lập ở đây rất quan trọng.
We need to consider that. If we actually didn't consider setup time, we have a setup time violation, that we actually didn't budget enough clock period for the setup time constraints.
Chúng ta cần tính đến nó. Nếu ta không xét đến thời gian thiết lập, ta sẽ bị vi phạm thời gian thiết lập, tức là ta đã không dành đủ chu kỳ clock cho các ràng buộc về thời gian thiết lập.
What would happen, and how can we actually fix it? We just forgot about setup time when we actually think about clock period. There'll be garbage in the flip-flop, right?
Điều gì sẽ xảy ra, và làm sao để sửa? Giả sử ta quên thời gian thiết lập khi tính chu kỳ clock. Sẽ có dữ liệu rác trong flip-flop, đúng không?
Because it doesn't meet the setup time requirement, right? Is my chip dead? Is there anything I can do about it?
Vì nó không đáp ứng yêu cầu thời gian thiết lập, đúng không? Chip của tôi hỏng rồi sao? Tôi có thể làm gì không?
Increase the clock, you mean running the clock? Increase the clock period, right? So just running it slower, right? So the setup time is annoying, but it's fixable, right?
Tăng clock, ý em là chạy clock? Tăng chu kỳ clock, đúng không? Tức là chạy chậm hơn, đúng không? Vậy thời gian thiết lập thì phiền, nhưng sửa được, đúng không?
So even if the chip is like, oh, I just forgot about it, you can always run it slower, right? So run it slower, like frequency slower. The period is actually longer, right?
Ngay cả khi chip bị kiểu như, ồ, tôi quên mất nó, ta luôn có thể chạy nó chậm hơn, đúng không? Chạy chậm hơn, tức là tần số thấp hơn. Chu kỳ dài hơn, đúng không?
So you can always actually, then your circuit will meet the setup time. So it does actually affect the critical path, the frequency that you can run, but it's generally fixable.
Vậy ta luôn có thể làm thế, và mạch sẽ đáp ứng thời gian thiết lập. Nó có ảnh hưởng đến đường tới hạn, tức tần số mà ta có thể chạy, nhưng nhìn chung sửa được.
You just run it at a slower clock. We also discussed earlier, right? So this is really thinking about cycle time, right? But how about hold time, right?
Chỉ cần chạy với clock chậm hơn. Chúng ta cũng đã thảo luận trước đó, đúng không? Vậy đây thực sự là nghĩ về thời gian chu kỳ, đúng không? Còn thời gian giữ thì sao?
What are different factors actually contribute hold time here, right? So here we basically want to say, well, data actually need to actually hold long enough, right? Before we actually overwrite.
Những yếu tố nào đóng góp vào thời gian giữ ở đây? Ở đây về cơ bản ta muốn nói rằng, dữ liệu cần được giữ đủ lâu, đúng không? Trước khi nó bị ghi đè.
Before we actually overwrite this data, right?
Trước khi chúng ta ghi đè dữ liệu này, đúng không?
So here, so we have our clock to queue delay here, and then, so here the whole time, so we have our clock to queue delay here, right?
Vậy ở đây, chúng ta có độ trễ clock-to-Q ở đây, và sau đó, ở đây toàn bộ thời gian, chúng ta có độ trễ clock-to-Q, đúng không?
So instead of looking at the max time, we're actually looking at the mean time, right? Because it's actually faster time.
Vì vậy thay vì xét thời gian lớn nhất, chúng ta thực ra đang xét thời gian nhỏ nhất, đúng không? Bởi vì đó là thời gian nhanh hơn.
What we want to do is that we want to keep this input actually long enough before we overwrite it, because this need to actually hold long enough so that the queue, the output can actually sample its data, right?
Điều chúng ta muốn là giữ đầu vào này đủ lâu trước khi ghi đè lên nó, bởi vì nó cần được giữ đủ lâu để Q, đầu ra, có thể lấy mẫu dữ liệu của nó, đúng không?
So this is, this data need to be actually valid long enough so that we can actually sample this data correctly, right? What actually will affect whether this data will be valid or not?
Vậy dữ liệu này cần phải hợp lệ đủ lâu để chúng ta có thể lấy mẫu dữ liệu này một cách chính xác, đúng không? Điều gì sẽ ảnh hưởng đến việc dữ liệu này có hợp lệ hay không?
We are actually overwrite this data during the clock transition in the current stage, right?
Chúng ta ghi đè dữ liệu này trong lúc xung nhịp chuyển trạng thái ở tầng hiện tại, đúng không?
So this data need to hold long enough to meet actually the whole time requirement, but at the same time we are also overwriting this data.
Vậy dữ liệu này cần được giữ đủ lâu để đáp ứng yêu cầu về thời gian giữ, nhưng đồng thời chúng ta cũng đang ghi đè dữ liệu này.
And the fast, the latency of overwriting this data is basically we get the clock to queue, we get the fastest fast that could actually potentially overwrite the data.
Và độ nhanh, độ trễ của việc ghi đè dữ liệu này về cơ bản là clock-to-Q, tức là con đường nhanh nhất có thể ghi đè dữ liệu.
You will overwrite this data too quickly, the next stage may not be able to actually sample this data. Make sense? Make sense here, right?
Nếu bạn ghi đè dữ liệu này quá nhanh, tầng tiếp theo có thể không lấy mẫu được dữ liệu này. Hiểu chưa? Chỗ này hiểu chưa?
So we want to keep this data long enough for the whole time so that we can actually sample it, but at the same time there is a race going on because we are actually also overwrite this data, right?
Vậy chúng ta muốn giữ dữ liệu này đủ lâu trong thời gian giữ để có thể lấy mẫu nó, nhưng đồng thời có một cuộc đua đang diễn ra vì chúng ta cũng đang ghi đè dữ liệu này, đúng không?
The latency for us to actually overwrite this data is basically clock to queue and the minimum combinational logic here. So that's basically the path that we are actually overwrite this data here, Right?
Độ trễ để chúng ta ghi đè dữ liệu này về cơ bản là clock-to-Q cộng với logic tổ hợp tối thiểu ở đây. Đó chính là đường mà chúng ta ghi đè dữ liệu này, đúng không?
So we actually want to make sure this path is long enough so it doesn't actually violate our hold time requirements, so that this value can actually stay stable long enough so that our queue can actually sample it without being overwritten by the current computation here.
Vì vậy chúng ta muốn đảm bảo đường này đủ dài để không vi phạm yêu cầu về thời gian giữ, để giá trị này có thể giữ ổn định đủ lâu để Q của chúng ta có thể lấy mẫu nó mà không bị ghi đè bởi phép tính hiện tại ở đây.
Does it make sense? Questions?
Hiểu chưa? Có câu hỏi nào không?
So with that, this clock to queue delay, this logic propagation, the fastest path with the minimum logic actually need to run long enough so that we don't actually violate the hold time constraints here.
Vậy, độ trễ clock-to-Q này, sự lan truyền logic này, đường nhanh nhất với logic tối thiểu cần chạy đủ lâu để chúng ta không vi phạm các ràng buộc về thời gian giữ ở đây.
Make sense? How do we fix this? Yeah, so how do we fix it? Before we fix the clock to queue delay, we want to slow it. So what about this?
Hiểu chưa? Làm sao để sửa điều này? Vâng, vậy làm sao để sửa? Trước khi sửa độ trễ clock-to-Q, ta muốn làm chậm nó. Vậy còn cách này thì sao?
How do we fix it, remember? To make the shortest path longer. How do we, it's already, like, overwrite the buffer. Right, that's pre-silicon, right, before you tape out.
Làm sao để sửa, nhớ không? Làm cho đường ngắn nhất dài hơn. Làm sao, nó vốn đã như là ghi đè lên buffer rồi. Đúng, đó là trước khi chế tạo silicon, tức là trước khi tape out.
Yes, before you tape out, you can always actually add, that's basically the most useful tricks, just keep adding buffers. What's your name, Brian? Cecil. Okay, Cecil.
Đúng, trước khi tape out, bạn luôn có thể thêm vào, đó là mẹo hữu ích nhất, cứ thêm buffer. Bạn tên gì, Brian? Cecil. Được, Cecil.
You can try weird corners, but it doesn't, well, you're basically playing with different hold times, but you may or may not actually fix it.
Bạn có thể thử các corner kỳ lạ, nhưng nó không, thực ra là bạn chỉ đang thử với các thời gian giữ khác nhau, và có thể bạn sẽ sửa được hoặc không.
Basically, if you ignore hold time, your chip is dead. There's not a lot of things you can do.
Về cơ bản, nếu bạn bỏ qua thời gian giữ, con chip của bạn coi như chết. Bạn không làm được nhiều thứ đâu.
There's just not a lot of things you can do if you don't catch a short path. Like, adding buffer is a very common way, just, like, adding, make your path longer.
Nếu bạn không phát hiện ra một đường ngắn thì thực sự không làm được nhiều. Chẳng hạn, thêm buffer là cách rất phổ biến, tức là làm cho đường đi của bạn dài hơn.
I was, like, talking to some other faculties, and they were actually talking about one of the chips.
Tôi vừa nói chuyện với một số giảng viên khác, và họ đang nói về một con chip.
It's just clearly, the chip is not back yet, but they think this chip is not going to work, just by inspection, looking at the circuits.
Rõ ràng là con chip đó chưa được sản xuất xong trả về, nhưng họ nghĩ con chip này sẽ không hoạt động, chỉ bằng cách quan sát, nhìn vào các mạch.
They're just, like, all the short paths, they are very short. It's not going to actually meet the hold. You know which chip I'm talking about? Never mind, never mind.
Tất cả các đường ngắn của nó đều rất ngắn. Nó sẽ không đạt được thời gian giữ. Các bạn biết tôi đang nói về chip nào không? Thôi, bỏ qua, bỏ qua.
There's, yeah, so this is basically something very hard to fix. It will actually, yeah, there will be violations. We'll actually report it. That is whether you actually fix it or not.
Vâng, nên đây là thứ rất khó sửa. Sẽ có các vi phạm, và chúng ta sẽ báo cáo chúng. Việc đó xảy ra dù bạn có sửa hay không.
Yeah, so you will actually need to fix all the violations. We would love to change the flip-flops and make it, like, faster or slower. You mean post-tape-out? Post-tape-out?
Vâng, vì vậy bạn sẽ thực sự cần sửa tất cả các vi phạm. Chúng ta rất muốn thay đổi các flip-flop để làm cho chúng nhanh hơn hoặc chậm hơn. Ý bạn là sau tape-out à? Sau tape-out?
Okay, so that's post-tape-out. But I mean, flip-flops, like, bi-stable inverters, they're made out of, like, two latches. Two latches, a pair of latches.
Được, vậy đó là sau tape-out. Nhưng ý tôi là, flip-flop, tức là các bộ đảo lưỡng ổn, chúng được tạo thành từ hai latch. Hai latch, một cặp latch.
We'll actually talk about how we actually design them.
Chúng ta sẽ nói về cách thiết kế chúng.
Basically, I test that by sizing it up or down. Yeah, we can do that before tape-out. Yeah, just basically before tape-out, yeah.
Về cơ bản, tôi kiểm tra điều đó bằng cách tăng hoặc giảm kích thước. Vâng, chúng ta có thể làm điều đó trước tape-out. Vâng, về cơ bản là trước tape-out.
So anything, this is basically, basically we can actually redesign, redesign this, right? The easiest way is basically what we mentioned, adding buffers, making your critical path longer, right?
Vậy nên về cơ bản chúng ta có thể thiết kế lại, thiết kế lại cái này, đúng không? Cách dễ nhất về cơ bản là điều chúng ta đã nói, thêm buffer, làm cho đường tới hạn của bạn dài hơn, đúng không?
But we can also design different size to register. That's another way to do that.
Nhưng chúng ta cũng có thể thiết kế thanh ghi với kích thước khác. Đó là một cách khác.
But everything here is, you can do this pre-tape-out to fix hold-time violation, but if actually it's not fixed, like, after tape-out, there's just unfortunately not much we can do.
Nhưng tất cả những điều này, bạn có thể làm trước tape-out để sửa vi phạm thời gian giữ, còn nếu thực tế nó không được sửa, thì sau tape-out, tiếc là chúng ta không làm được nhiều.
Yeah.
Vâng.
Oh, for the hold time?
À, về thời gian giữ à?
Right, so we'll see, actually, flip-flop architecture consists of two stages. There are basically two stages of latches, generally, for a very common flip-flop design, right?
Vâng, chúng ta sẽ thấy kiến trúc flip-flop gồm hai tầng. Nói chung có hai tầng latch, đối với một thiết kế flip-flop rất phổ biến, đúng không?
So you basically need to hold long enough so that the first stage signals can be actually propagated, so you can actually sample that directly. So it's eventually a signal propagation problem.
Vậy về cơ bản bạn cần giữ đủ lâu để tín hiệu của tầng đầu có thể được lan truyền, và nhờ đó bạn có thể lấy mẫu trực tiếp. Vậy rốt cuộc đây là bài toán lan truyền tín hiệu.
You need to actually make sure it's being propagated, so the first stage to actually sample.
Bạn cần đảm bảo tín hiệu được lan truyền, để tầng đầu có thể lấy mẫu.
Yeah, it will be basically run even slower, yeah. It will be even actually harder to, yeah. So hold time is actually very hard. People try to debug central.
Vâng, về cơ bản nó sẽ chạy còn chậm hơn nữa. Nó sẽ còn khó hơn nữa, vâng. Vậy thời gian giữ thực sự rất khó. Mọi người cố gỡ lỗi phần trung tâm.
So clock-to-q is actually generally longer than that, especially with flip-flop timing, because actually clock-to-q is from clock to the final output. We'll see, actually, the flip-flop later is actually two stages, right?
Vì vậy clock-to-q nhìn chung thường dài hơn thế, đặc biệt là với định thời của flip-flop, vì clock-to-q tính từ xung clock cho đến đầu ra cuối cùng. Sau này chúng ta sẽ thấy flip-flop thực ra gồm hai tầng, đúng không?
So you actually need to basically propagate through both stages, while the hold time is actually for the first stage. Basically, we can actually sample the data. We can actually get the data, yeah.
Vì vậy tín hiệu cần lan truyền qua cả hai tầng, trong khi thời gian giữ (hold time) chỉ liên quan đến tầng đầu tiên. Về cơ bản, đó là lúc ta có thể lấy mẫu dữ liệu. Ta có thể nhận được dữ liệu, vâng.
Is that physically for the flip-flops? I don't think so, because it's actually to propagate through basically the entire flip-flops.
Điều đó có đúng về mặt vật lý với các flip-flop không? Em không nghĩ vậy, vì nó phải lan truyền qua toàn bộ flip-flop.
So the flip-flop, the clock-to-q delay is the longest, but hold time, we need to actually make sure the data is long enough to propagate through the first stage.
Vậy với flip-flop, độ trễ clock-to-q là dài nhất, còn với thời gian giữ, ta cần đảm bảo dữ liệu đủ dài để lan truyền qua tầng đầu tiên.
Okay, so those are the two timing constraints we discussed.
Được rồi, đó là hai ràng buộc định thời mà ta đã thảo luận.
Setup time, that actually affects the clock cycle, so that's why what we saw is more like an illustration, but this is really how setup time actually affects clock period.
Thời gian thiết lập (setup time) ảnh hưởng đến chu kỳ clock, nên những gì ta thấy trước đó giống một minh họa hơn, nhưng đây mới thực sự là cách setup time ảnh hưởng đến chu kỳ clock.
And then for the hold time, right, so we actually need to make sure this data is stable so that we can actually sample this data correctly, and that we want to make sure the logic actually runs long enough.
Còn với thời gian giữ thì, ta cần đảm bảo dữ liệu này ổn định để có thể lấy mẫu dữ liệu này một cách chính xác, và ta muốn đảm bảo phần logic chạy đủ lâu.
So far, we have been actually mostly assuming very ideal scenarios. We have a guest lecture earlier, and we also talked about a lot of uncertainties, right.
Cho đến giờ, ta chủ yếu giả định những tình huống rất lý tưởng. Trước đó ta có một bài giảng của khách mời, và ta cũng đã nói về rất nhiều yếu tố không chắc chắn, đúng không.
Clock distribution is actually pretty complex and can also go pretty big, right, with all the different clock trees actually to actually get to all the different registers, right.
Phân phối clock khá phức tạp và cũng có thể rất lớn, đúng không, với đủ loại cây clock khác nhau để đến được tất cả các thanh ghi khác nhau.
There are all the different noise and all the variations actually in space and time, right.
Có đủ loại nhiễu và mọi biến thiên theo không gian và thời gian.
Whether it is actually very hard to assume all the clocks actually arrive at the same time, especially if the different registers are actually spatially distributed, and there's all the different noise side effects.
Rất khó để giả định rằng tất cả các xung clock đến cùng một lúc, đặc biệt nếu các thanh ghi khác nhau phân bố rải rác trong không gian, và còn có đủ loại tác dụng phụ do nhiễu.
They all contribute to clock uncertainty, right.
Tất cả đều góp phần vào độ bất định của clock, đúng không.
So far, we still assume the ideal scenario, But when we actually budget the design, we also actually need to consider the clock uncertainty that also exists in our design, right.
Cho đến giờ, ta vẫn giả định tình huống lý tưởng, nhưng khi lập ngân sách cho thiết kế, ta cũng cần xét đến độ bất định của clock vốn tồn tại trong thiết kế của ta.
You may hear those terminologies. People talk about this before. Those are basically described different implications of clock uncertainty.
Có thể bạn đã nghe những thuật ngữ này. Trước đây mọi người đã nói về điều này. Chúng mô tả những hệ quả khác nhau của độ bất định của clock.
There are two key ones. One is a skew. One is jitter. They are basically talking about different variations. One is a spatial variation.
Có hai loại chính. Một là skew. Hai là jitter. Chúng nói về những biến thiên khác nhau. Một là biến thiên theo không gian.
It's basically between different clock, clock one and the clock two. So one is spatial. They are between different clocks. One is temporal.
Đó là giữa các clock khác nhau, clock một và clock hai. Vậy một loại là theo không gian, giữa các clock khác nhau. Loại kia là theo thời gian.
For the same clock, how they actually differs over time, right. So what do we mean by that? So let's take a look at skew first, right. So we mentioned there are two clocks.
Với cùng một clock, nó khác nhau thế nào theo thời gian. Vậy ý ta là gì? Hãy xem skew trước. Vậy là ở đây chúng ta có hai xung nhịp.
You can also think about like two registers, right. So we have clock coming in, right.
Bạn cũng có thể hình dung đó là hai thanh ghi. Ta có xung nhịp đi vào.
So at a high level, it looks like they are actually connected together, but they are actually clock one, clock two, right. And between those two, there could be skew.
Nhìn ở mức tổng quát thì có vẻ như chúng được nối chung với nhau, nhưng thực ra chúng là xung nhịp một và xung nhịp hai. Và giữa hai xung nhịp này có thể có độ lệch (skew).
There could be actually differences, right. One clock can arrive earlier or later from the other clock because they are located in different parts of the chip.
Tức là có thể có sự khác biệt. Một xung nhịp có thể đến sớm hơn hoặc muộn hơn xung nhịp kia vì chúng nằm ở những vùng khác nhau trên chip.
There are different designs, different things connected to them. So it's actually very hard to actually make sure they show up the same time, right.
Mỗi vùng có thiết kế khác nhau, các thành phần nối vào cũng khác nhau. Vì vậy rất khó để đảm bảo chúng xuất hiện cùng một lúc.
So this spatial variation between different clocks are basically what people call clock skew, right. So we'll talk a little bit, we'll see a little bit more how it actually affected.
Sự biến thiên theo không gian giữa các xung nhịp này chính là cái mà người ta gọi là clock skew. Ta sẽ nói thêm và xem nó ảnh hưởng như thế nào.
But one thing is that clock skew can actually be either positive or negative, right.
Nhưng có một điều là clock skew có thể dương hoặc âm, đúng không.
This is also the part I always get very confused, but you just, basically they're describing which one is actually faster and earlier, right.
Đây cũng là phần mà tôi luôn thấy rất dễ nhầm, nhưng về cơ bản chúng chỉ mô tả xung nhịp nào nhanh hơn, đến sớm hơn.
Especially in this relationship where we have some combinational logic from the first register to the second register, right. So positive is the receiving clock is actually later.
Đặc biệt là trong mối quan hệ này, khi ta có một khối logic tổ hợp đi từ thanh ghi thứ nhất đến thanh ghi thứ hai. Skew dương là khi xung nhịp bên nhận đến muộn hơn.
It's basically clock two is actually arrives later than the first one. This is what we call receiving, Right. This is what we call launching, right? You don't need to remember this.
Tức là xung nhịp hai đến muộn hơn xung nhịp thứ nhất. Đây là cái ta gọi là bên nhận (receiving). Còn đây là bên phát (launching). Bạn không cần nhớ điều này.
This is just a convention people use. And when you see actually positive and negative clock skew, it's basically describing which one is earlier or later, right?
Đây chỉ là một quy ước mà mọi người dùng. Và khi bạn thấy clock skew dương và âm, nó chỉ mô tả xung nhịp nào đến sớm hơn hay muộn hơn.
So this positive skew is basically, we'll see the implication of the positive skew later. It actually can be a good thing. So it's basically, this is actually later than the launching clock.
Vậy skew dương về cơ bản là, ta sẽ xem tác động của skew dương sau. Nó thực ra có thể là điều tốt. Tức là xung nhịp này đến muộn hơn xung nhịp phát.
A negative skew is actually earlier than the launching clock, right? So this is a spatial variation. This is terminology people use. There's another terminology that is also talking about a non-ideality.
Skew âm là khi nó đến sớm hơn xung nhịp phát. Đây là sự biến thiên theo không gian. Đây là thuật ngữ mọi người dùng. Còn một thuật ngữ khác cũng nói về một điểm không lý tưởng.
That's basically jitter, right? So you folks may also have heard about this in your labs, right? So this is basically for each of the clocks, for the individual clock.
Đó là jitter. Có thể các bạn cũng đã nghe về nó trong các buổi thí nghiệm. Cái này áp dụng cho từng xung nhịp, cho một xung nhịp riêng lẻ.
Basically with different edges of the clock, there could also be noise, because all the signals are toggling.
Với các sườn khác nhau của xung nhịp, cũng có thể có nhiễu, vì tất cả các tín hiệu đều đang chuyển mức.
There are different toggling patterns that would also affect how fast the clock actually arrives at a particular position, right? So this is basically a temporal variation that differs cycle to cycle, right?
Các kiểu chuyển mức khác nhau cũng ảnh hưởng đến việc xung nhịp đến một vị trí nhất định nhanh hay chậm. Vậy đây là sự biến thiên theo thời gian, khác nhau từ chu kỳ này sang chu kỳ khác.
So different clock within an individual clock, there could actually be variations cycle by cycle. So those are basically the two non-idealities people use to describe the clock distribution.
Tức là trong một xung nhịp riêng lẻ, cũng có thể có biến thiên theo từng chu kỳ. Đó là hai điểm không lý tưởng mà người ta dùng để mô tả việc phân phối xung nhịp.
We'll see how they actually impact the delay constraint that we discussed earlier.
Ta sẽ xem chúng tác động thế nào đến ràng buộc về độ trễ mà chúng ta đã thảo luận trước đó.
Okay, one thing, yeah, so the key thing is, why do people get confused about the spatial one? Clock skew is spatial. There are multiple clocks, describing their relationship.
Được rồi, có một điều, điểm mấu chốt là, tại sao mọi người hay nhầm lẫn về yếu tố không gian? Clock skew mang tính không gian. Có nhiều xung clock, và nó mô tả mối quan hệ giữa chúng.
Jitter is temporal, right? For some clock, how they get here early or later. So those are the two non-idealities that we have in the design, right.
Jitter mang tính thời gian, đúng không? Với một xung clock, nó đến sớm hơn hay muộn hơn. Đó là hai yếu tố không lý tưởng mà chúng ta có trong thiết kế.
So let's take a look at how that actually affects the timing constraint that we have in our discussion here. So we still have this pattern.
Vậy hãy xem chúng ảnh hưởng thế nào đến ràng buộc về thời gian mà chúng ta đang thảo luận ở đây. Chúng ta vẫn có mô hình này.
So we have two clocks, clock two, clock one, right? So everything stays the same, right? So we talk about the setup time constraint, right?
Có hai xung clock, clock hai và clock một, đúng không? Mọi thứ vẫn giữ nguyên, đúng không? Chúng ta nói về ràng buộc thời gian thiết lập (setup time), đúng không?
The first part Before this part is what's added here, right.
Phần đầu, phần trước phần này là phần được thêm vào ở đây.
So basically, the clock period here, between this register and this register, needs to be long enough so that our signal can propagate from clock to Q, go through the combinational logic, and then meet the setup time requirement.
Về cơ bản, chu kỳ clock ở đây, giữa thanh ghi này và thanh ghi này, phải đủ dài để tín hiệu của chúng ta có thể lan truyền từ clock đến Q, đi qua logic tổ hợp, rồi thỏa mãn yêu cầu về thời gian thiết lập.
So that's what we have with our setup constraint here, right. So now what we also need to consider is that those two clocks may not be synchronized, right.
Đó là ràng buộc setup của chúng ta ở đây. Điều chúng ta cũng cần xét đến bây giờ là hai xung clock này có thể không đồng bộ, đúng không?
One clock can actually arrive earlier or later than the original clock, which can actually also affect the time, which also means we actually need to, like, budget that when we actually set up our minimum cycle time, right.
Một xung clock có thể đến sớm hơn hoặc muộn hơn xung clock gốc, điều này cũng có thể ảnh hưởng đến thời gian, nghĩa là chúng ta cũng cần dự trù khoản đó khi xác định chu kỳ nhỏ nhất của mình.
So you will actually have our clock skew considered, right. So we mentioned earlier, this clock can actually show up, the clock two can show up earlier or later than the clock one, right.
Như vậy chúng ta sẽ tính đến clock skew. Như đã nói trước đó, xung clock này có thể xuất hiện, clock hai có thể xuất hiện sớm hơn hoặc muộn hơn clock một.
So you will say clock two actually shows up later than clock one. So basically, this triggers first, and then after a while, this actually gets triggered.
Giả sử clock hai xuất hiện muộn hơn clock một. Về cơ bản, cái này kích hoạt trước, rồi sau một lúc thì cái này mới được kích hoạt.
Is that a good thing or bad thing for our clock period, for our minimum clock cycle? Ethan?
Điều đó tốt hay xấu đối với chu kỳ clock, đối với chu kỳ clock nhỏ nhất của chúng ta? Ethan?
Because, yes, because we have a little bit more slack, right.
Bởi vì, đúng, vì chúng ta có thêm một chút slack.
So we don't actually need that urgent, right, because the clock actually positively contributes to our calculation, right. So that could be a good thing.
Nên chúng ta không cần gấp như vậy, vì xung clock đóng góp tích cực vào phép tính của chúng ta. Vậy đó có thể là điều tốt.
But one thing we should be concerned about is, what if clock two actually arrives earlier, right.
Nhưng một điều chúng ta nên lo ngại là, nếu clock hai đến sớm hơn thì sao?
So we have clock one, but clock two actually will arrive earlier than that, which means, how would that actually affect our cycle time if clock two actually arrived earlier?
Chúng ta có clock một, nhưng clock hai lại đến sớm hơn nó, điều đó nghĩa là, nó ảnh hưởng thế nào đến thời gian chu kỳ nếu clock hai đến sớm hơn?
Thanks, Scott.
Cảm ơn Scott.
Not good, right. So it means our budget is actually tighter, right. So things are actually naturally tighter, because now we actually need to consider the receiving one could actually receive earlier, right.
Không tốt, đúng không. Nghĩa là ngân sách thời gian của chúng ta chặt hơn. Mọi thứ đương nhiên chặt hơn, vì bây giờ chúng ta cần tính đến việc phía nhận có thể nhận sớm hơn.
So we actually need to relax our design, don't run so fast, right. Consider that there are variations, and some part of the variation would actually hurt, Right, among the slack you have, right.
Vì vậy chúng ta cần nới lỏng thiết kế, đừng chạy nhanh quá. Hãy tính đến việc có các biến thiên, và một phần của sự biến thiên đó thực sự sẽ gây bất lợi, đúng không, nằm trong phần slack mà bạn có.
So you actually will run it actually slower. So that could always affect the minimum clock cycle here.
Vì vậy thực tế bạn sẽ phải chạy chậm hơn. Nên điều đó luôn có thể ảnh hưởng đến chu kỳ xung nhịp tối thiểu ở đây.
When trying to calculate the speed of other devices, it's a jitter of other devices.
Khi tính tốc độ của các thiết bị khác, thì đó là jitter của các thiết bị khác.
You mean the jitter of the other clock here? When you say devices, you mean registers here?
Ý bạn là jitter của xung nhịp khác ở đây phải không? Khi bạn nói thiết bị, ý bạn là các thanh ghi ở đây phải không?
So generally, when we say actually jitter, it's actually applied to the all clock. We're actually talking about distribution of the jitter, right.
Nói chung, khi chúng ta nói jitter, nó được áp dụng cho toàn bộ xung nhịp. Chúng ta đang nói về phân bố của jitter, đúng không.
It will be basically across all clock, what are the distribution of the jitters, and then we actually consider that when we actually do our calculation here.
Về cơ bản, trên toàn bộ xung nhịp, phân bố của jitter là gì, rồi chúng ta xét điều đó khi thực hiện phép tính ở đây.
Okay, so we're assuming that all of us have the same patterns of jitters and the worst-case scenarios, yeah. So generally, we consider the worst-case scenarios, yeah.
Được rồi, vậy ta giả sử tất cả đều có cùng một dạng jitter và các trường hợp xấu nhất, vâng. Nói chung, chúng ta xét các trường hợp xấu nhất, vâng.
I don't know if we're going to get a slide, but does octave skew also lead to potential overvaluing? Yeah, so that's a good question, right.
Tôi không biết là ta có slide hay không, nhưng liệu clock skew có dẫn đến việc đánh giá quá mức tiềm ẩn không? Vâng, đó là một câu hỏi hay.
So far, we also only talk about setup time, right. So how about hold time, how that actually affects hold time, right. Again, hold time is basically we don't want to overwrite our data, right.
Từ đầu đến giờ, chúng ta mới chỉ nói về setup time, đúng không. Vậy còn hold time thì sao, nó ảnh hưởng đến hold time như thế nào. Một lần nữa, hold time về cơ bản là ta không muốn ghi đè dữ liệu của mình.
So we don't want to contaminate our data, right.
Tức là ta không muốn làm hỏng dữ liệu của mình.
So before, always that is that our clock to queue and the logic propagation actually need to long enough so that this data can actually propagate it, right, so that it can actually propagate it to the output, right.
Vậy trước đây, luôn là thời gian clock-to-Q cộng với độ trễ lan truyền của logic cần đủ dài để dữ liệu có thể lan truyền, để nó có thể lan truyền tới đầu ra.
So this need to actually long enough than what we talk about the whole time, right. So now with a clock uncertainty with both skews and the jitter, right.
Vì vậy nó cần đủ dài hơn hold time mà ta đã nói suốt nãy giờ. Còn bây giờ, với độ bất định của xung nhịp gồm cả skew và jitter.
So this basically means it's actually even harder to meet the whole time violation, right.
Điều này về cơ bản có nghĩa là còn khó hơn nữa để đáp ứng, tránh vi phạm hold time.
So you basically need to not only consider this, this like you need to actually long enough to make sure the data is actually hold here, right.
Vậy bạn không chỉ cần xét điều này, tức là bạn cần có độ trễ đủ dài để đảm bảo dữ liệu được giữ ổn định ở đây.
You also need to consider there's also uncertainty with a clock, you actually don't know when the clock actually will show up, Right.
Bạn còn cần xét đến độ bất định của xung nhịp, bạn không biết chính xác khi nào xung nhịp sẽ đến.
So in the worst-case scenario, we actually also consider all of this, which actually makes it even harder to meet the hold time violation, because you have to meet the hold time constraint, because actually the logic needs to actually run long enough to cover all the, not only the combinational logic latency, but also non-ideality in the design.
Vì vậy trong trường hợp xấu nhất, chúng ta cũng xét tất cả những điều này, khiến việc đáp ứng, tránh vi phạm hold time càng khó hơn, vì bạn phải thỏa mãn ràng buộc hold time, bởi logic cần chạy đủ lâu để bao trùm tất cả, không chỉ độ trễ của logic tổ hợp, mà còn cả các yếu tố phi lý tưởng trong thiết kế.
Make sense? So there also, this will actually affect both our setup time and hold time violation, and we actually need to consider that in our design.
Hiểu chưa? Vậy điều này cũng sẽ ảnh hưởng đến cả vi phạm setup time và hold time của chúng ta, và ta cần xét điều đó trong thiết kế của mình.
Okay, so we talk about this critical path, right. So combinational logic, this is still very important, right. Let's take a look at what is a critical path actually when we analyze our circuit.
Được rồi, vậy chúng ta nói về đường tới hạn. Logic tổ hợp, điều này vẫn rất quan trọng. Hãy xem đường tới hạn thực sự là gì khi chúng ta phân tích mạch.
Let's say we ignore our registers for now. Let's look at this, it's internal bubbles, right, and then we have this circuit like in the middle between the registers, right.
Giả sử bây giờ ta bỏ qua các thanh ghi. Hãy nhìn vào đây, các khối bên trong của nó, và rồi chúng ta có mạch này nằm ở giữa các thanh ghi, đúng không.
What is a critical path for this design? We have a lot of bubbles here, right. What is a critical path?
Đường tới hạn của thiết kế này là gì? Ở đây có rất nhiều khối, đúng không. Đường tới hạn là gì?
Let's have like one minute, think about it, feel free to discuss with your neighbors what's a critical path in this logic.
Các em có khoảng một phút để suy nghĩ, cứ thoải mái trao đổi với các bạn bên cạnh xem đường tới hạn trong mạch logic này là gì.
Oh yes, instantaneous. Yeah, just consider the bubble delays, ignore the mux delays for this one.
À vâng, tức thời. Đúng rồi, chỉ cần xét độ trễ của các khối thôi, bỏ qua độ trễ của các bộ dồn kênh trong bài này.
Okay, let's see. We have inputs coming in and outputs going out, and we have some bubble, like cloud or circuits here, going through to muxes.
Được rồi, cùng xem nào. Chúng ta có các đầu vào đi vào và các đầu ra đi ra, và có vài khối, kiểu như đám mây hay mạch ở đây, đi qua các bộ dồn kênh.
Any guesses what's the critical path? 300, why?
Ai đoán xem đường tới hạn là bao nhiêu? 300, tại sao?
Mm-hmm. I see, so Ruben thinks this should be 300 because we have an inverter here. It's always inverted, right, so it's always a different pair.
Ừm. Tôi hiểu rồi, vậy Ruben cho rằng đáp án là 300 vì ở đây có một cổng đảo. Nó luôn bị đảo, đúng không, nên luôn là một cặp khác nhau.
Other ideas and other thoughts, remember? I have this question, like the inverter. The inverter input, you mean s?
Còn ý kiến hay suy nghĩ nào khác không, nhớ nhé? Em có câu hỏi về cổng đảo này. Đầu vào của cổng đảo, ý em là s à?
Let's say initially that's zero, so the 200 ones pass through, but then later the s. I see, let's say s is the output from the register, there's no changes.
Giả sử ban đầu nó bằng không, thì đường 200 đi qua, nhưng sau đó s thay đổi. Tôi hiểu, giả sử s là đầu ra từ thanh ghi, không có thay đổi nào.
I think it's supposed to be a trick question, but your books make it too easy. Ruben is right.
Tôi nghĩ đây vốn là câu hỏi mẹo, nhưng sách của các em làm nó quá dễ. Ruben đúng rồi.
So the trick here is basically to recognize that we're having the same signal controlling the muxes, right? So it's not always...
Vậy mẹo ở đây về cơ bản là nhận ra rằng cùng một tín hiệu đang điều khiển các bộ dồn kênh, đúng không? Nên không phải lúc nào cũng...
although if you just look at this, the longest path is 400 nanoseconds, but it actually never happens, right?
mặc dù nếu chỉ nhìn thế này, đường dài nhất là 400 nano giây, nhưng thực tế nó không bao giờ xảy ra, đúng không?
So that's actually what people call a false path, because actually that condition will actually never match, right? So the trick part is that it's not that tricky.
Đó chính là cái mà người ta gọi là đường giả (false path), vì điều kiện đó thực ra sẽ không bao giờ xảy ra, đúng không? Nên phần mẹo là nó không hề khó đến vậy.
I think, remember, you're overthinking it. It's not that tricky. Maybe I should make it even trickier. That's the trick part. You folks already get it, right?
Nhớ nhé, các em đang nghĩ quá phức tạp. Nó không khó đến thế. Có lẽ tôi nên làm nó khó hơn nữa. Đó mới là phần mẹo. Các em đã hiểu rồi, đúng không?
So it's 300, because exactly what Ruben said, right? If you look at the pairs, right, it's this path never happened, 200 and 200, that basically never happens.
Vậy đáp án là 300, đúng như Ruben đã nói, đúng không? Nếu nhìn vào các cặp, đường này không bao giờ xảy ra, 200 và 200, về cơ bản là không bao giờ xảy ra.
Okay, well, so today we talked about the multiplier. We also get to the timing.
Được rồi, hôm nay chúng ta đã nói về bộ nhân. Chúng ta cũng đã bàn về thời gian (timing).
As I already hinted earlier, we will get to the internal design, how we design latches and flip-flops using the transistors we covered before.
Như tôi đã gợi ý trước đó, chúng ta sẽ đi vào thiết kế bên trong, cách thiết kế latch và flip-flop bằng các transistor mà chúng ta đã học trước đây.
We'll do that this Thursday, so it's great to see you all here. I'll pause today, but we'll continue our discussion on sequential logic, first with flip-flops and then with next week.
Chúng ta sẽ làm việc đó vào thứ Năm này, rất vui được gặp các em ở đây. Hôm nay tôi xin dừng ở đây, nhưng chúng ta sẽ tiếp tục thảo luận về logic tuần tự, trước tiên với flip-flop rồi đến tuần sau.
Good seeing you. I'll see you Thursday.
Rất vui được gặp các em. Hẹn gặp lại 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.