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ả.
All right, let's get started.
Được rồi, chúng ta bắt đầu thôi.
Okay, so welcome everyone to the second discussion of EECS 151/251A.
Chào mừng các bạn đến với buổi thảo luận thứ hai của EECS 151/251A.
Today we're going to be talking more about Verilog and also simulating Verilog, how to write a really simple testbench.
Hôm nay chúng ta sẽ nói thêm về Verilog và cả việc mô phỏng Verilog, cách viết một testbench thật đơn giản.
So we left off last discussion right before I could get into the blocking versus non-blocking assignment details. So that's where we're going to start today.
Buổi trước chúng ta dừng lại ngay trước khi tôi kịp đi vào chi tiết về phép gán blocking và non-blocking. Vì vậy hôm nay chúng ta sẽ bắt đầu từ đó.
These are two different ways to do procedural assignments, or procedural, just in the context of Verilog, means within an always or initial block.
Đây là hai cách khác nhau để thực hiện phép gán procedural, còn procedural, chỉ xét trong ngữ cảnh Verilog, nghĩa là bên trong một khối always hoặc initial.
So for blocking, we use just the standard equal sign for our assignment.
Với blocking, chúng ta dùng dấu bằng thông thường để gán.
And really what this means is that the first statement here, right, the C equals A or B, is completely evaluated before the subsequent lines are executed.
Và thực chất điều này có nghĩa là câu lệnh đầu tiên ở đây, đúng rồi, C bằng A or B, được đánh giá hoàn toàn trước khi các dòng tiếp theo được thực thi.
So what that means, and this should be pretty natural, like any other programming language that you've used, when you're using this, the blocking assignment, all it means is that C, you know, the first thing that it does when it's evaluating this always block is set C equal to A or B.
Vậy điều đó có nghĩa là, và điều này khá tự nhiên, giống như bất kỳ ngôn ngữ lập trình nào mà các bạn đã dùng, khi bạn dùng phép gán blocking này, thì nó chỉ có nghĩa là C, bạn biết đấy, việc đầu tiên nó làm khi đánh giá khối always này là gán C bằng A or B.
And then in the next statement, it uses this new updated value of C to calculate out.
Và ở câu lệnh tiếp theo, nó dùng giá trị C mới vừa được cập nhật này để tính ra kết quả.
And this is used exclusively, basically exclusively, it is best practice to only use this blocking assignment inside a combinational always block.
Và phép gán này được dùng riêng, về cơ bản là chỉ dùng, thực hành tốt nhất là chỉ dùng phép gán blocking bên trong một khối always tổ hợp.
So you can see we have the at star here that should by now, kind of, everyone should understand that that is being used for combinational logic.
Các bạn thấy ở đây có @ dấu sao, đến giờ mọi người hẳn đã hiểu rằng nó được dùng cho logic tổ hợp.
And we can really easily draw out the circuit that this is emulating.
Và chúng ta có thể dễ dàng vẽ ra mạch mà đoạn mã này mô phỏng.
We have an OR gate here, right, that is A, B input, and then the output goes directly to an AND gate.
Ở đây có một cổng OR, đúng không, với đầu vào A, B, và đầu ra đi thẳng vào một cổng AND.
So right, this is C, the output of the OR gate, and then out is right here.
Vậy đây là C, đầu ra của cổng OR, và out nằm ngay đây.
So you can really think of it as just, right, it kind of flows, all the inputs flow from one side to the output.
Nên bạn có thể hình dung đơn giản là mọi đầu vào chảy từ một phía tới đầu ra.
And that's, this is the operator that you'll always use for combinational logic.
Và đây là toán tử mà bạn sẽ luôn dùng cho logic tổ hợp.
The other operator is non-blocking, and that uses slightly different notation; it looks like the less than or equal to sign. And this is used for sequential logic.
Toán tử còn lại là non-blocking, và nó dùng ký hiệu hơi khác; trông giống dấu nhỏ hơn hoặc bằng. Và nó được dùng cho logic tuần tự.
And the way that it works is, at basically the beginning of the time step, which is defined as the positive edge of the clock for this always block, all the right hand side values, so this and this, are evaluated.
Cách nó hoạt động là, ngay từ đầu bước thời gian, được định nghĩa là sườn dương của xung nhịp đối với khối always này, tất cả các giá trị vế phải, tức là cái này và cái này, được đánh giá.
That is the first thing that happens at the beginning of this time step. And you can imagine that the output of these expressions are kind of saved in these temporary variables.
Đó là việc đầu tiên xảy ra ở đầu bước thời gian này. Và bạn có thể hình dung rằng kết quả của các biểu thức này được lưu vào các biến tạm.
So just imagine this is C, you know, this becomes C temp, and then we also have an out temp here, and saved.
Cứ hình dung đây là C, bạn biết đấy, nó thành C temp, và ở đây còn có out temp nữa, và được lưu lại.
And then essentially what happens is that the assignment of C and out is scheduled for the end of the time step.
Rồi về bản chất, điều xảy ra là phép gán cho C và out được lên lịch vào cuối bước thời gian.
So in contrast to the blocking operator, right, this happens at the end, kind of, the assignment to C here.
Vì vậy, khác với toán tử blocking, việc gán cho C ở đây được thực hiện vào cuối bước thời gian.
And that means that when the right hand side is evaluated here, this C value is the old value. Does that make sense?
Và điều đó có nghĩa là khi vế phải được tính ở đây, giá trị C này là giá trị cũ. Mọi người hiểu chứ?
And this means that we have for our circuit here two registers, because we're using the at posedge clock, right, so that we should be inferring some sort of edge-sensitive sequential element.
Và điều này có nghĩa là mạch của chúng ta ở đây có hai thanh ghi, vì chúng ta dùng at posedge clock, nên sẽ suy ra một phần tử tuần tự nào đó nhạy theo cạnh.
And we have that out, let's say this is out here, right, and then this is C here.
Và ta có out, giả sử đây là out, rồi đây là C.
And the previous value of each of these things is just going to be at the input of the registers. So we have C is out for a...
Và giá trị trước đó của mỗi thứ này sẽ nằm ở đầu vào của các thanh ghi. Vậy C là out với a...
Okay, so we have an OR gate here. And we know that the out is going to loop around like that.
Được rồi, ở đây ta có một cổng OR. Và ta biết out sẽ được nối vòng lại như thế này.
Then we have A, and out is going to be C and B.
Sau đó ta có A, và out sẽ là C và B.
So does this make sense, how I've created this circuit? Anyone have any questions?
Vậy mọi người có hiểu cách tôi tạo ra mạch này không? Có ai có câu hỏi không?
I think we have some examples in the next slide that should really make it clear why we want both blocking and non-blocking assignments.
Tôi nghĩ ở slide tiếp theo có vài ví dụ sẽ làm rõ vì sao chúng ta cần cả phép gán blocking và non-blocking.
But the major takeaway for this is: if you're trying to build combinational logic, use blocking assignments.
Nhưng điều cần nhớ chính là: nếu bạn xây dựng logic tổ hợp, hãy dùng phép gán blocking.
So combinational, use equals; sequential, use non-blocking.
Tức là tổ hợp thì dùng dấu bằng; tuần tự thì dùng non-blocking.
Okay, if you follow this rule, you'll very rarely, you know, get into trouble.
Nếu tuân theo quy tắc này, bạn sẽ rất hiếm khi gặp rắc rối.
Okay, so in this example, what we want to do is build a three-stage pipeline.
Trong ví dụ này, điều chúng ta muốn là xây dựng một đường ống ba tầng.
So that is what's shown here, where on each clock tick D is getting passed to Q1, Q1 is getting passed to Q2, and Q2 is getting passed to Q3.
Đó là những gì được hiển thị ở đây, trong đó ở mỗi xung nhịp, D được chuyển sang Q1, Q1 được chuyển sang Q2, và Q2 được chuyển sang Q3.
So we'll go through all of these Verilog examples of how to implement this and figure out if it's, one, synthesizable, or correct in its synthesizability.
Chúng ta sẽ đi qua tất cả các ví dụ Verilog này về cách hiện thực mạch này và xem xét: thứ nhất, nó có tổng hợp được không, hoặc có đúng về khả năng tổng hợp không.
Does it simulate correctly? And then also, we're gonna have a third point here: is it good practice?
Nó có mô phỏng đúng không? Và ngoài ra còn có điểm thứ ba: đó có phải là thực hành tốt không?
Because as you'll see, Verilog is a very flexible language, and you can do a lot of things with it. But you shouldn't do all of the things that you can do.
Vì như các bạn sẽ thấy, Verilog là một ngôn ngữ rất linh hoạt, và bạn có thể làm rất nhiều thứ với nó. Nhưng bạn không nên làm tất cả những gì mình có thể làm.
There are some kind of programming paradigms that you should always be following or keeping in mind.
Có một số mô hình lập trình mà bạn luôn nên tuân theo hoặc ghi nhớ.
Okay, so starting with candidate one, we can see, all right, we have this at posedge clock, which is a good start, right? Because we want these to be registers in this pipeline.
Được rồi, bắt đầu với phương án một, ta thấy có at posedge clock này, đó là một khởi đầu tốt. Vì chúng ta muốn những thứ này là các thanh ghi trong đường ống.
Then you can see we have blocking assignment operators. So that is not a good sign.
Sau đó bạn thấy ta có các toán tử gán blocking. Đó không phải là dấu hiệu tốt.
And the way we can kind of figure out what circuit this would turn into is just think about the order of execution of these blocking assignments.
Và cách để biết mạch này sẽ trở thành mạch gì là nghĩ về thứ tự thực thi của các phép gán blocking này.
So at first, right at the positive edge of the clock, we have our D here, and it's passed to Q1. That looks right. That looks good.
Đầu tiên, ngay tại cạnh lên của xung nhịp, ta có D ở đây, và nó được truyền sang Q1. Như vậy là đúng. Trông ổn.
But the issue is then that Q1 has been updated with D, right? Because of the blocking operators.
Nhưng vấn đề là lúc này Q1 đã được cập nhật bằng D, đúng không? Vì đây là các toán tử gán blocking.
So Q2, when it's assigned to Q1, is assigned to the new value of Q1, which is D. So that means that Q2 is just the same as Q1.
Vậy nên khi Q2 được gán bằng Q1, nó được gán bằng giá trị mới của Q1, tức là D. Nghĩa là Q2 chỉ giống hệt Q1.
And same exact thing applies for Q3. So what we end up with is just a single register that's passing D all the way to Q3 in a single clock cycle.
Và điều y hệt cũng xảy ra với Q3. Vì vậy rốt cuộc ta chỉ có một thanh ghi duy nhất truyền D thẳng tới Q3 trong một chu kỳ xung nhịp.
So that is not what we want.
Đó không phải điều chúng ta muốn.
All right, so candidate number two.
Được rồi, vậy đến phương án thứ hai.
Let's see, it's the same thing as candidate number one, except for we have now reversed the order in which we're doing the assignment.
Để xem, nó giống phương án thứ nhất, chỉ khác là bây giờ ta đã đảo ngược thứ tự thực hiện phép gán.
We say Q3 is equal to Q2, Q2 is equal to Q1, Q1 is equal to D. So what do you guys think? Do you think this one will work?
Ta viết Q3 bằng Q2, Q2 bằng Q1, Q1 bằng D. Các bạn nghĩ sao? Các bạn nghĩ cái này có chạy được không?
No? Why won't it work? You shook your head.
Không à? Tại sao không được? Bạn vừa lắc đầu.
So, but what is, when Q3 is assigned to Q2, what has Q2 been updated? Or is it still its old value?
Vậy nhưng, khi Q3 được gán bằng Q2, thì Q2 đã được cập nhật chưa? Hay nó vẫn còn giá trị cũ?
It's still the old value. So this is actually the correct behavior. You can think about, like, building this pipeline kind of in reverse, right?
Nó vẫn là giá trị cũ. Vậy nên thực ra đây là hành vi đúng. Bạn có thể hình dung như đang xây dựng đường ống này theo chiều ngược lại, đúng không?
Where we have, sorry, Q3 and Q2, and then building that and building that. So does this make sense to everyone?
Trong đó ta có, xin lỗi, Q3 và Q2, rồi xây cái đó và xây tiếp cái đó. Mọi người đã hiểu chưa?
If you just do the assignment in the reverse order, then you don't end up with this kind of pre-updating and then assigning issue with the blocking operators.
Nếu bạn chỉ cần gán theo thứ tự ngược lại, thì sẽ không gặp vấn đề cập nhật trước rồi mới gán với các toán tử blocking.
Now, so one and two, does it synthesize correctly? Yes. Does it simulate correctly? Yes. But is it good practice? No, no.
Vậy phương án một và hai, có tổng hợp đúng không? Có. Có mô phỏng đúng không? Có. Nhưng đó có phải thói quen tốt không? Không, không.
This is a really good way to get yourself in a lot of trouble, because this is a simple example where we're just trying to build this three-stage pipeline.
Đây đúng là cách rất dễ khiến bạn gặp rắc rối lớn, vì đây chỉ là một ví dụ đơn giản mà ta chỉ đang cố xây dựng đường ống ba tầng này.
But you're going to be building way more complicated things. And if you have to worry about the order in which you're doing your assignments, you're never going to get anywhere.
Nhưng các bạn sẽ xây dựng những thứ phức tạp hơn nhiều. Và nếu bạn phải lo lắng về thứ tự thực hiện các phép gán, bạn sẽ chẳng đi tới đâu cả.
You're just going to be lost the entire time. And even if you do get it working, some small change by someone else could just completely break your design.
Bạn sẽ bị lạc suốt cả quá trình. Và kể cả khi bạn làm cho nó chạy được, một thay đổi nhỏ của người khác cũng có thể phá hỏng hoàn toàn thiết kế của bạn.
So we really do not want to do this. This is not good. These are both not good, even though candidate two does work. Does work. Okay. So candidate three.
Vì vậy chúng ta thực sự không nên làm thế. Như vậy là không tốt. Cả hai đều không tốt, dù phương án hai có chạy được. Có chạy được. Được rồi. Vậy đến phương án ba.
How do people feel about candidate three? Good. Yes. You should all feel very good about candidate number three.
Mọi người thấy phương án ba thế nào? Tốt. Đúng vậy. Các bạn đều nên cảm thấy rất ổn với phương án số ba.
It does all of the things that I told you in the last slide that you should do if you're trying to make a sequential circuit. It uses always @(posedge clock) and strictly non-blocking assignments.
Nó làm tất cả những điều tôi đã nói ở slide trước mà bạn nên làm khi muốn tạo một mạch tuần tự. Nó dùng always @(posedge clock) và chỉ dùng các phép gán non-blocking.
So at the very start of the simulation, all of the right-hand sides are evaluated, and then the assignment is scheduled for the end of the time step.
Vậy ngay từ lúc bắt đầu mô phỏng, tất cả các vế phải đều được tính giá trị, rồi phép gán được lên lịch để thực hiện vào cuối bước thời gian.
So all of these are kind of old values, and then the new values are updated right at the end. Okay. So we've got a star here to say that this is the good one.
Vậy nên tất cả những giá trị này đều là giá trị cũ, còn các giá trị mới chỉ được cập nhật ngay vào cuối bước. Được rồi. Ở đây chúng ta đánh dấu sao để cho biết đây là phương án tốt.
All right. And now we have candidates four through six that use separate always blocks.
Được rồi. Và bây giờ là các phương án từ bốn đến sáu, dùng các khối always riêng biệt.
Now, one of the weird things about Verilog is that these procedural assignments that are in always and initial blocks, there is no defined behavior in the spec as to, like, when an always block should be executed before an initial block, or which always block should be executed before a different always block.
Một điều kỳ lạ của Verilog là các phép gán thủ tục này nằm trong các khối always và initial, và đặc tả không quy định hành vi nào về việc khi nào một khối always được thực thi trước một khối initial, hay khối always nào được thực thi trước một khối always khác.
And so you always have to think about that. When you see these things, you have to assume that they could happen in any order, and then that would be okay.
Vì vậy lúc nào bạn cũng phải nghĩ đến điều đó. Khi bạn thấy những thứ này, bạn phải giả định rằng chúng có thể xảy ra theo thứ tự bất kỳ, và vẫn phải đúng.
So the first, the candidate four and five, right? And the only difference there is the same as one and two, where we have the ordering different.
Vậy phương án bốn và năm, đúng không? Và khác biệt duy nhất ở đó giống như giữa một và hai, tức là thứ tự được đảo lại.
It actually doesn't matter in what order we're assigning, because we don't know which always block is going to be executed first. So these are really exactly the same.
Thực ra thứ tự mà chúng ta gán không quan trọng, vì chúng ta không biết khối always nào sẽ được thực thi trước. Nên hai phương án này thực chất hoàn toàn giống nhau.
And again, using the blocking behavior, right? We can never guarantee that this is never going to work or that this is always going to work, right?
Và một lần nữa, chúng dùng hành vi blocking, đúng không? Chúng ta không bao giờ đảm bảo được rằng nó chắc chắn không chạy được hay chắc chắn luôn chạy được, đúng không?
In some scenarios, In some simulators, right, it may work correctly, but don't do this. Now for candidate number six, can anyone think of a reason why we wouldn't want to do this?
Trong một số tình huống, với một số trình mô phỏng, nó có thể chạy đúng, nhưng đừng làm như vậy. Còn với phương án số sáu, có ai nghĩ ra lý do vì sao chúng ta sẽ không muốn làm thế này không?
Could be because, like, it's assigning old values, but the values are just like, in that, in, like, their own individual always blocks. So then it's not like saving the correct values.
Có thể là vì nó gán các giá trị cũ, nhưng các giá trị đó nằm trong từng khối always riêng của chúng. Nên nó sẽ không lưu đúng các giá trị.
Yeah, that's a good thought. It was actually a trick question. This is a totally valid way of doing it.
Ừ, ý đó hay đấy. Thực ra đây là một câu hỏi mẹo. Đây hoàn toàn là một cách làm hợp lệ.
Because all of the always blocks, they could be executed in any order, but there's still this idea of kind of like stages within each single time step.
Vì tất cả các khối always có thể được thực thi theo thứ tự bất kỳ, nhưng vẫn có ý niệm về các giai đoạn trong mỗi bước thời gian.
So the right-hand side of all of these always blocks is going to be executed first, or evaluated first, before any assignment happens.
Vế phải của tất cả các khối always này sẽ được thực thi trước, hay được tính giá trị trước, trước khi bất kỳ phép gán nào xảy ra.
So even if, you know, this one's first and then this one's second and this one's third, it doesn't matter, because the first thing that's going to happen, before any assignment in any of these always blocks happens, is that the right-hand side gets evaluated.
Cho nên dù khối này chạy đầu tiên, rồi khối này thứ hai và khối này thứ ba, cũng không quan trọng, vì điều đầu tiên sẽ xảy ra, trước khi có bất kỳ phép gán nào trong các khối always này, là vế phải được tính giá trị.
So they all share the same flip-flops and clock, basically. So you're defining, they share the same clock. That's correct. But they're all, you're defining three separate flip-flops.
Về cơ bản, tất cả chúng dùng chung các flip-flop và xung clock. Bạn đang định nghĩa, chúng dùng chung xung clock. Đúng vậy. Nhưng bạn đang định nghĩa ba flip-flop riêng biệt.
Yeah, but like the, the flip, like the flip-flop of, like, the first and second block, were like Q1 in the first block and the Q1 in the second block are, it's all the same data, like coming from the same flip-flop, right?
Vâng, nhưng flip-flop của khối thứ nhất và khối thứ hai, Q1 trong khối thứ nhất và Q1 trong khối thứ hai là cùng một dữ liệu, đến từ cùng một flip-flop, đúng không?
Like the new value and the old value are going in the same place, or are they two separate flip-flops? No, you're right. The Q1 refers to the same flip-flop.
Tức là giá trị mới và giá trị cũ đều đi vào cùng một chỗ, hay chúng là hai flip-flop riêng biệt? Không, bạn nói đúng. Q1 ám chỉ cùng một flip-flop.
It's just whether it is the old value, the value kind of right at the start of the time step, or the new value. Yeah.
Vấn đề chỉ là nó là giá trị cũ, tức giá trị ngay tại đầu bước thời gian, hay là giá trị mới. Vâng.
Yes.
Đúng vậy.
So this is a solid way of building this pipeline register, and you will likely do this all the time where you have a bunch of sequential elements in your Design and you don't want to throw them all in a single always block, because then that always block will just be monstrous and it will be hard to read.
Vậy đây là một cách chắc chắn để xây dựng thanh ghi đường ống này, và nhiều khả năng bạn sẽ làm việc này suốt khi trong Design của bạn có một loạt phần tử tuần tự và bạn không muốn nhét tất cả vào một khối always duy nhất, vì khi đó khối always đó sẽ rất khổng lồ và khó đọc.
So maybe you have a couple of related registers. So you throw those in one always block, and then you have some other registers that are related in some way.
Nên có thể bạn có vài thanh ghi liên quan với nhau. Bạn đặt chúng vào một khối always, rồi có những thanh ghi khác liên quan với nhau theo cách nào đó.
And so you'll put those there, and it's just kind of an organizational strategy at that point, figuring out if you want to put more than one register in an always block.
Và bạn sẽ đặt chúng vào chỗ kia, khi đó nó chỉ là một chiến lược tổ chức, tức là quyết định có đặt nhiều hơn một thanh ghi trong một khối always hay không.
Question? So like, would Candidate 4 and Candidate 5 be like, better practice than Candidate 3? Say that again, Candidate?
Có câu hỏi không? Vậy Candidate 4 và Candidate 5 có phải là cách làm tốt hơn Candidate 3 không? Bạn nói lại được không, Candidate nào?
So like, so would it be, so are you, I guess, are you saying that it's a good practice to have... Um, it, it depends.
Ý tôi là, vậy có phải bạn đang nói rằng nên làm theo cách có... Ừm, còn tùy.
I think, I think, yeah, in general, like having more than one always block just to organize things is a good thing, but it really depends on the complexity of the module.
Tôi nghĩ, nhìn chung, có nhiều hơn một khối always để tổ chức mọi thứ là điều tốt, nhưng thực sự còn tùy vào độ phức tạp của module.
If it's this three register pipeline, I would say best practice is to just put it in a single always block.
Nếu là đường ống ba thanh ghi này, tôi cho rằng cách tốt nhất là đặt tất cả vào một khối always duy nhất.
But it really is kind of up to you, like how you think it's, it looks, or like how best, you know, organizational strategy for yourself between these two, right?
Nhưng thực ra là tùy bạn, tùy bạn thấy nó trông thế nào, hay cách nào tốt nhất, chiến lược tổ chức cho riêng bạn giữa hai cách này, đúng không?
Yeah. What's an example of 4 and 5 going wrong? So an example of 4 and 5 going wrong is, so like I said, these always blocks can be executed in any order.
Vâng. Ví dụ nào cho thấy 4 và 5 bị sai? Một ví dụ cho thấy 4 và 5 bị sai là, như tôi đã nói, các khối always này có thể được thực thi theo thứ tự bất kỳ.
The spec doesn't tell us, you know, when, if you write an always block, you know, on line 73, and then you write another one on line 74, that the 73 one will be executed first.
Đặc tả không cho chúng ta biết rằng nếu bạn viết một khối always ở dòng 73, rồi viết một khối khác ở dòng 74, thì khối ở dòng 73 sẽ được thực thi trước.
It says that, that that is not guaranteed. And so for the same reason why Candidate number one doesn't work, Candidate 4 and, and 5 aren't guaranteed to work.
Nó nói rằng điều đó không được đảm bảo. Và vì cùng lý do khiến Candidate số một không hoạt động, Candidate 4 và 5 cũng không được đảm bảo là hoạt động.
So if, if this was executed in order, then it would be the exact same as Candidate number one.
Nếu cái này được thực thi theo thứ tự, thì nó sẽ hoàn toàn giống Candidate số một.
But also on Candidate 5, this could happen first, this could happen second, and this could happen third, and then it would also be the exact same as Candidate number one.
Nhưng với Candidate 5, cái này có thể xảy ra trước, cái này xảy ra thứ hai, và cái này xảy ra thứ ba, và khi đó nó cũng hoàn toàn giống Candidate số một.
Does that make sense? Cool.
Mọi người hiểu chứ? Tốt.
Okay, so moving on to simulating Verilog.
Được rồi, giờ chuyển sang mô phỏng Verilog.
All right, so we're going to use this 32 bit adder as an example. And this is a really simple module.
Được rồi, chúng ta sẽ dùng bộ cộng 32 bit này làm ví dụ. Đây là một module rất đơn giản.
And we've defined it in two separate ways here, just to demonstrate that you can define module IO ports in two separate ways. This is the new way. This is the old way.
Và ở đây chúng ta định nghĩa nó theo hai cách khác nhau, chỉ để minh họa rằng bạn có thể định nghĩa các cổng IO của module theo hai cách. Đây là cách mới. Đây là cách cũ.
You can still do both.
Bạn vẫn có thể dùng cả hai.
And really, the difference just is that the old way requires you to do this kind of pre IO declaration, where you just put all the names in the parentheses after the module name, and then you will later define them here.
Và thực ra, điểm khác biệt chỉ là cách cũ yêu cầu bạn khai báo IO trước kiểu như thế này, tức là bạn chỉ đặt tất cả các tên trong dấu ngoặc đơn sau tên module, rồi sau đó mới định nghĩa chúng ở đây.
Whereas in the new way, you define everything in one shot, one shot definition.
Trong khi với cách mới, bạn định nghĩa mọi thứ trong một lần, định nghĩa một lần.
And the old way, there's really not any good reason to ever use the old way. If you like the old way, then, you know, keep doing it.
Còn cách cũ, thật sự không có lý do chính đáng nào để dùng cách cũ cả. Nếu bạn thích cách cũ thì cứ tiếp tục dùng.
But it does require you to kind of define the IOs twice, right? Since, why they came up with this new way, that's just a little bit more concise.
Nhưng nó buộc bạn phải định nghĩa các IO hai lần, đúng không? Vì thế người ta mới nghĩ ra cách mới này, gọn hơn một chút.
I guess one good reason to keep using the old way would be if you are working inside a code base that uses just the old way, then just for consistency's sake, it would be a good reason to use it.
Tôi nghĩ một lý do chính đáng để tiếp tục dùng cách cũ là nếu bạn đang làm việc trong một cơ sở mã chỉ dùng cách cũ, thì để cho nhất quán, đó sẽ là một lý do hợp lý để dùng nó.
But generally, yeah, just stick with the new way. It's a little neater.
Nhưng nói chung, cứ dùng cách mới. Nó gọn gàng hơn một chút.
Okay, so both of these blocks, right? Pretty simple. It's just a single assign statement, C equals A plus B, C equals A plus B. And this is totally synthesizable.
Được rồi, cả hai khối này khá đơn giản, đúng không? Chỉ là một câu lệnh assign duy nhất, C bằng A cộng B, C bằng A cộng B. Và nó hoàn toàn có thể tổng hợp được.
And at least for me, when I was learning this stuff, this was really kind of the first time I was like, wow, this synthesis is really cool.
Ít nhất với tôi, khi tôi học những thứ này, đây thực sự là lần đầu tiên tôi nghĩ: wow, tổng hợp mạch thật tuyệt.
Because I've just written A plus B, and it will synthesize a complete adder, right? That's pretty amazing. And we don't know what kind of adder it's making.
Vì tôi chỉ viết A cộng B, mà nó sẽ tổng hợp ra một bộ cộng hoàn chỉnh, đúng không? Thật đáng kinh ngạc. Và chúng ta không biết nó tạo ra loại bộ cộng nào.
But, you know, there's some really smart logic inside those synthesis tools that will figure out, you know, what's the best adder for this use case, depending on other things, right?
Nhưng bên trong các công cụ tổng hợp đó có một phần logic rất thông minh sẽ tìm ra bộ cộng nào là tốt nhất cho trường hợp sử dụng này, tùy thuộc vào những yếu tố khác, đúng không?
Like how this is plugged into larger circuits, and the timing constraints and things like that. But really, just with that one line, you can define a full 32 bit adder in hardware.
Chẳng hạn như nó được nối vào các mạch lớn hơn như thế nào, và các ràng buộc về thời gian, những thứ như vậy. Nhưng thực sự, chỉ với một dòng đó, bạn có thể định nghĩa một bộ cộng 32 bit đầy đủ trong phần cứng.
Now, the one thing that you have to be careful of when you're using arithmetic operators is that the output is generally going to be a larger bit width, at least for, you know, multiplication and addition.
Bây giờ, điều bạn phải cẩn thận khi dùng các toán tử số học là đầu ra nói chung sẽ có độ rộng bit lớn hơn, ít nhất là với phép nhân và phép cộng.
Then, let's see if I can't go on the do not disturb.
Để xem tôi bật được chế độ không làm phiền không.
Sorry about that. Generally, the output is going to be a larger bit width than the input operands, right?
Xin lỗi về chuyện đó. Nói chung, đầu ra sẽ có độ rộng bit lớn hơn các toán hạng đầu vào, đúng không?
So, if you have two 32 bit values that you're adding, if both of those values are all ones, right, the maximum value, you'll get a 33 bit output, because that final bit will just carry over.
Vậy nếu bạn cộng hai giá trị 32 bit, nếu cả hai giá trị đó đều toàn bit một, tức là giá trị lớn nhất, bạn sẽ nhận được đầu ra 33 bit, vì bit cuối cùng đó sẽ được nhớ sang.
But if you define the output as 32 bits right here, then the MS bit of the output is just discarded.
Nhưng nếu bạn định nghĩa đầu ra là 32 bit ngay tại đây, thì bit MS của đầu ra sẽ bị loại bỏ.
And it's not, the tools aren't going to tell you, hey, you know, you're discarding the 33rd bit.
Và các công cụ sẽ không báo cho bạn biết, kiểu như, này, bạn đang bỏ bit thứ 33 đấy.
They're just going to let you do this and assume that you know what you're doing, that you don't want that 33rd bit. So you should always be careful of that.
Chúng cứ để bạn làm vậy và cho rằng bạn biết mình đang làm gì, rằng bạn không cần bit thứ 33 đó. Vì vậy bạn lúc nào cũng phải cẩn thận về điều này.
Okay, moving on.
Được rồi, chúng ta tiếp tục.
Alright, so here is a very simple testbench, or kind of a, for a testbench for this adder, where we're defining our inputs into the block, right, as registers,
Đây là một testbench rất đơn giản, hay đại loại là một testbench cho bộ cộng này, trong đó chúng ta định nghĩa các đầu vào của khối, là các thanh ghi,
because we're going to want to assign to them in a procedural block inside our testbench.
vì chúng ta sẽ muốn gán giá trị cho chúng trong một khối thủ tục bên trong testbench.
And then the outputs, you can just define as wire, because all we're going to be doing inside the testbench is just reading those values.
Còn các đầu ra thì bạn chỉ cần định nghĩa là wire, vì tất cả những gì chúng ta làm bên trong testbench chỉ là đọc các giá trị đó.
So in this case, with the adder, right, we just have two inputs, two 32 bit inputs, and then one 32 bit output.
Vậy trong trường hợp bộ cộng này, chúng ta chỉ có hai đầu vào, hai đầu vào 32 bit, và một đầu ra 32 bit.
And then perhaps the most important thing is that we define our module that we want to test.
Rồi có lẽ điều quan trọng nhất là chúng ta khai báo module mà chúng ta muốn kiểm thử.
So what everyone calls this is the, the device under test.
Mọi người gọi nó là device under test.
That is just the, you know, the name that we have settled on as kind of a canonical name for the module that you want to test: device under test.
Đó là cái tên mà chúng ta đã thống nhất dùng như một tên chuẩn cho module bạn muốn kiểm thử: device under test.
And then not shown here is the actual test itself, which we'll show in the next slide.
Còn phần kiểm thử thực sự thì không được hiển thị ở đây, chúng ta sẽ trình bày ở slide tiếp theo.
So this comment will be kind of replaced with all of the testing code that you'll want to do.
Vậy dòng chú thích này sẽ được thay thế bằng toàn bộ mã kiểm thử mà bạn muốn viết.
See, and yeah, I mean, it should be obvious, but you want to test as many circumstances as possible to eliminate the bugs.
Và, điều này hẳn là hiển nhiên, nhưng bạn muốn kiểm thử càng nhiều trường hợp càng tốt để loại bỏ lỗi.
You know, a common question that people have is like, well, you know, maybe not for a 32 bit adder, but if we're working with, like, a four bit adder, why don't we just test every single possible combination of inputs, and then we can completely verify the design?
Một câu hỏi thường gặp là, ví dụ, có thể không phải với bộ cộng 32 bit, nhưng nếu ta làm việc với, chẳng hạn, bộ cộng bốn bit, tại sao ta không kiểm thử mọi tổ hợp đầu vào có thể có, rồi như vậy ta có thể kiểm chứng hoàn toàn thiết kế?
And the answer to that question is, yeah, for a four bit adder, you absolutely should do that. Why not? It's going to take no time at all.
Và câu trả lời cho câu hỏi đó là, đúng vậy, với bộ cộng bốn bit thì chắc chắn bạn nên làm vậy. Sao lại không? Nó sẽ không tốn thời gian chút nào.
But in reality, you're going to be testing things that have huge inputs, and the state space is going to be so large that it would take you forever, like literally forever, to simulate all of the possible inputs.
Nhưng trong thực tế, bạn sẽ kiểm thử những thứ có đầu vào rất lớn, và không gian trạng thái lớn đến mức sẽ mất của bạn mãi mãi, theo đúng nghĩa đen, để mô phỏng tất cả các đầu vào có thể có.
So you'll generally, you know, you'll generally do what's called constrained random testing, where you just send in random inputs, and then you have some other model that's checking the output and making sure that for any random input, you're getting the correct output.
Vì vậy nhìn chung, bạn sẽ làm cái gọi là constrained random testing, tức là bạn đưa vào các đầu vào ngẫu nhiên, và có một mô hình khác kiểm tra đầu ra và đảm bảo rằng với bất kỳ đầu vào ngẫu nhiên nào, bạn đều nhận được đầu ra đúng.
While at the same time, you're making sure that you hit certain corner cases, right? So what would be a corner case for an adder?
Đồng thời, bạn cũng đảm bảo rằng mình chạm tới một số corner case nhất định, đúng không? Vậy corner case của một bộ cộng sẽ là gì?
Like, so one of the cases that would be, like, the one, all ones. Exactly, overflow. Exactly, exactly. So overflow condition, or kind of conversely, what if your input is all zeros?
Chẳng hạn, một trong các trường hợp đó là trường hợp toàn bit một. Chính xác, tràn số. Chính xác, đúng vậy. Vậy là điều kiện tràn số, hoặc ngược lại, điều gì xảy ra nếu đầu vào của bạn toàn là số không?
That should be obvious, that shouldn't be a very hard corner case to pass. But it is, you know, those are kind of the two ends, or two extremes for the adder example.
Cái đó hiển nhiên thôi, đó không phải là trường hợp biên quá khó để vượt qua. Nhưng đúng là, đó là hai đầu mút, hay hai thái cực của ví dụ bộ cộng.
Okay, so moving on. Alright, so one line I didn't talk about in the previous slide was this macro.
Được rồi, chúng ta đi tiếp. Được rồi, có một dòng mà tôi chưa nói đến ở slide trước, đó là macro này.
So when you see this, this is a Verilog macro that is basically just, it's the same as like a C macro, right, where it just replaces the text with some other things.
Khi bạn thấy dòng này, đây là một macro Verilog về cơ bản chỉ là, giống như macro trong C, đúng không, tức là nó chỉ thay thế đoạn văn bản bằng một thứ khác.
In this case, it replaces it with some system functions that are defining the simulation time step. So simulation time step, and simulation time resolution.
Trong trường hợp này, nó thay bằng một số hàm hệ thống dùng để định nghĩa bước thời gian mô phỏng. Tức là bước thời gian mô phỏng và độ phân giải thời gian mô phỏng.
So that's what's shown here. And you may be wondering, well, what is that? What is the time step? What is the resolution? Well, the time step is just defining what pound one means.
Đó là những gì hiển thị ở đây. Và có thể bạn tự hỏi, vậy đó là gì? Bước thời gian là gì? Độ phân giải là gì? Bước thời gian chỉ là định nghĩa #1 có nghĩa là gì.
Because this is how we add in delays to our testbench and to our models is by using that not dollar sign, excuse me, the pound sign, pound sign one.
Vì đây là cách chúng ta thêm độ trễ vào testbench và vào các mô hình của mình, bằng cách dùng ký hiệu không phải đô la, xin lỗi, ký hiệu thăng, thăng một.
We need to define, you know, what is the unit? Is it nanoseconds, picoseconds, microseconds? So that's what this first value is doing. It just defines that pound one.
Chúng ta cần định nghĩa đơn vị là gì. Là nano giây, pico giây hay micro giây? Đó là việc của giá trị đầu tiên này. Nó chỉ định nghĩa #1 đó.
And then the second is giving us the resolution. So we don't have to just have integer values of delays, right?
Còn giá trị thứ hai cho chúng ta độ phân giải. Nên độ trễ không nhất thiết chỉ là các giá trị nguyên, đúng không?
We can have pound zero, or excuse me, pound 0.1, or pound 0.01. And in this case, the 10 picoseconds corresponds to pound 0.01.
Chúng ta có thể có #0, xin lỗi, #0.1 hoặc #0.01. Và trong trường hợp này, 10 pico giây tương ứng với #0.01.
So does that make sense how this translates to 10 picoseconds only when the time step is defined as one nanosecond?
Vậy các bạn có hiểu vì sao nó chuyển thành 10 pico giây chỉ khi bước thời gian được định nghĩa là một nano giây không?
Yeah. If you, if you change 10 picoseconds to something else, like buy or something, would it still be pound 0.01?
Vâng. Nếu đổi 10 pico giây thành giá trị khác, chẳng hạn như thế, thì nó vẫn là #0.01 chứ?
Yeah, so 10 picoseconds would still be pound 0.01. But you could also do a pound 0.005.
Vâng, 10 pico giây vẫn là #0.01. Nhưng bạn cũng có thể làm #0.005.
So yeah, the resolution is just setting the minimum delay. And if you try to do anything smaller, it will just round up to the minimum.
Vậy độ phân giải chỉ đặt ra độ trễ tối thiểu. Và nếu bạn thử đặt bất cứ giá trị nào nhỏ hơn, nó sẽ làm tròn lên mức tối thiểu.
Yeah. Do we really need, like, one tenth of a second or step? Because in a lot of cases, we just, like, always block, you only do it in a clock cycle.
Vâng. Chúng ta có thực sự cần một phần mười giây hay bước như vậy không? Vì trong nhiều trường hợp, chúng ta chỉ dùng always block, và chỉ làm trong một chu kỳ xung nhịp.
So it will be like one nanosecond slash one nanosecond. So yeah, this stuff becomes important when you start thinking about all of that, like physical delays inside the circuit.
Nên nó sẽ là một nano giây trên một nano giây. Vâng, những thứ này trở nên quan trọng khi bạn bắt đầu nghĩ đến tất cả những điều đó, như các độ trễ vật lý bên trong mạch.
So I'm not sure if you're an ASIC or FPGA lab, but I know at least in ASIC, you know, we'll have these delay annotated netlists, where you'll have kind of extracted values from the actual physical implementation of the circuit that will delay the signal by a certain amount of time.
Tôi không chắc các bạn học lab ASIC hay FPGA, nhưng tôi biết ít nhất với ASIC, chúng ta sẽ có các netlist chú thích độ trễ, trong đó bạn sẽ có các giá trị được trích xuất từ hiện thực vật lý thực tế của mạch sẽ làm trễ tín hiệu một khoảng thời gian nhất định.
And it's really important that you get that signal to the register before the setup time. So you don't have any timing violations or anything like that.
Và điều rất quan trọng là bạn phải đưa tín hiệu đó tới thanh ghi trước thời gian setup. Để không có vi phạm định thời nào xảy ra.
And so you can get kind of these arbitrarily small or large delays depending on the physical implementation.
Và như vậy bạn có thể nhận được những độ trễ nhỏ tùy ý hoặc lớn tùy ý, tùy vào cách hiện thực vật lý.
But you're right in that if you're dealing with a circuit that is like basically ideal, right, like wires have zero delay, combinational circuits have zero delay, and you're just going from clock edge to clock edge, then there's really no reason to have any kind of simulation time resolution.
Nhưng bạn nói đúng ở chỗ, nếu bạn đang xử lý một mạch về cơ bản là lý tưởng, tức là dây dẫn có độ trễ bằng không, mạch tổ hợp có độ trễ bằng không, và bạn chỉ đi từ cạnh xung nhịp này sang cạnh xung nhịp kia, thì thật sự không có lý do gì để có độ phân giải thời gian mô phỏng.
You could just, or even a time step for that matter, right, you could just define a clock period as being any arbitrary amount of time, 20 nanoseconds, 10 nanoseconds.
Bạn có thể, hoặc thậm chí là một bước thời gian cũng vậy, bạn có thể định nghĩa chu kỳ xung nhịp là một khoảng thời gian bất kỳ, 20 nanô giây, 10 nanô giây.
It would only be if you have multiple clocks in the design that you would need to set a time step so that you can set their clock periods relative to each other.
Chỉ khi nào thiết kế có nhiều xung nhịp thì bạn mới cần đặt một bước thời gian để có thể đặt chu kỳ xung nhịp của chúng tương đối với nhau.
And then if our resolution is really, really small, like, let's say, it tends to negative, like, seventh of this thing, that wouldn't be slow or inefficient? Absolutely. Yep. Yeah.
Và nếu độ phân giải của mình rất, rất nhỏ, ví dụ như là 10 mũ âm 7 chẳng hạn, thì như vậy chẳng phải sẽ chậm hoặc kém hiệu quả sao? Chính xác. Đúng vậy.
So that's not, that's why, that's why we don't just set this to, like, the smallest value that we can, You want to set it to the smallest value that you can while still guaranteeing, you know, simulation accuracy.
Nên đó là lý do mình không đặt giá trị này là giá trị nhỏ nhất có thể. Bạn muốn đặt nó ở giá trị nhỏ nhất có thể mà vẫn đảm bảo được độ chính xác của mô phỏng.
Okay, any other questions on this slide?
Được rồi, còn câu hỏi nào về slide này không?
All right, moving on. So now we're defining that initial block that I talked about a couple slides ago.
Được rồi, chúng ta tiếp tục. Bây giờ chúng ta định nghĩa khối initial mà tôi đã nói cách đây vài slide.
This is going to be the easiest way for you guys to just test a block, to write a testbench.
Đây sẽ là cách dễ nhất để các bạn kiểm tra một khối, tức là viết một testbench.
And it should be noted, if you don't already know, that an initial block is only executed once, but it doesn't execute in zero time. It will run pretty much the length of the simulation.
Và cần lưu ý, nếu các bạn chưa biết, rằng khối initial chỉ được thực thi một lần, nhưng nó không thực thi trong thời gian bằng không. Nó sẽ chạy gần như suốt thời gian của mô phỏng.
In this case, that's exactly what's happening: in the initial block, we first initialize our inputs right here, this is happening at time equals zero.
Trong trường hợp này, đúng là điều đó đang xảy ra: trong khối initial, đầu tiên ta khởi tạo các đầu vào ở ngay đây, việc này diễn ra tại thời điểm bằng không.
And then we're waiting one time step, right, whatever it is that we defined. And then we'll check our outputs of the block.
Rồi ta chờ một bước thời gian, tức là bất kể ta đã định nghĩa nó là gì. Và sau đó ta sẽ kiểm tra các đầu ra của khối.
So in this case, we just have the two inputs, A, B, and then output C. We check to see if it equals three, right, because we added one, two.
Vậy trong trường hợp này ta chỉ có hai đầu vào A, B, và đầu ra C. Ta kiểm tra xem nó có bằng ba không, vì ta đã cộng một với hai.
And if it's not equal, then we'll call this display function, which will print values for us. So you can think of display as like printf in C or print in Python.
Và nếu không bằng, thì ta sẽ gọi hàm display này, hàm sẽ in các giá trị ra cho chúng ta. Bạn có thể xem display giống như printf trong C hay print trong Python.
It's just a way to print values from a simulation to your terminal. Now, does everyone understand this notation, like the way to define numbers?
Nó chỉ là một cách để in các giá trị từ mô phỏng ra terminal của bạn. Bây giờ, mọi người có hiểu ký hiệu này không, tức là cách định nghĩa các số?
Is that pretty clear? Okay, just making sure. I know it can be confusing. Yeah, yeah, absolutely. Absolutely.
Có rõ không? Được rồi, tôi chỉ muốn chắc chắn thôi. Tôi biết nó có thể gây nhầm lẫn. Vâng, vâng, đúng vậy.
Okay, so what we have here, 32'd3, this guy right here is the number of bits.
Được rồi, vậy ở đây ta có 32'd3, phần này ngay đây là số bit.
Okay, so we're just defining, hey, this value is 32 bits wide. This defines the radix. So for d, that stands for decimal, we're saying this is a decimal number.
Vậy là ta chỉ đang định nghĩa rằng giá trị này rộng 32 bit. Phần này xác định cơ số. Với d, tức là decimal (thập phân), ta đang nói đây là một số thập phân.
But it doesn't matter what radix we define, that first number is always just defining the number of bits. So how large is this number in binary? How many digits in binary is it?
Nhưng dù ta chọn cơ số nào, con số đầu tiên luôn chỉ xác định số bit. Vậy số này lớn cỡ nào trong hệ nhị phân? Nó có bao nhiêu chữ số nhị phân?
And then the final value is just the number itself.
Và cuối cùng, giá trị chính là bản thân con số đó.
So there's other radixes that you can use; most common are hex and binary. So you could define the same number in hex as 32'h...
Ngoài ra còn các cơ số khác bạn có thể dùng; phổ biến nhất là hex và nhị phân. Vậy bạn có thể định nghĩa cùng một số ở dạng hex là 32'h...
or 32'b...
hoặc 32'b...
Is that clear? Cool. Cool. All right. Yes, question. Number of bits? That's a, that's a good question.
Rõ chưa? Tuyệt. Được rồi. Vâng, bạn hỏi đi. Số bit à? Câu hỏi hay đấy.
And no, it cannot. Yeah. So it can't be, it can't be a variable that changes.
Và không, nó không thể. Vâng. Nó không thể là một biến thay đổi được.
Yeah, yeah, no, is the answer to that question.
Vâng, câu trả lời cho câu hỏi đó là không.
All right. Other thing to note is that dollar sign n or pound sign n is used to advance by n time steps.
Được rồi. Một điều khác cần lưu ý là dấu đô la n hay dấu thăng n dùng để tiến lên n bước thời gian.
So you, you can do things other than just one or less than one, as we showed in the, in the other slide. And this definitely can be variable.
Vậy bạn có thể dùng những giá trị khác, không chỉ một hay nhỏ hơn một, như ta đã cho thấy ở slide kia. Và cái này hoàn toàn có thể là biến.
So you can have some kind of changing integer or something that's determining, you know, how much you're delaying. Okay, and we already talked about display for just printing things.
Nên bạn có thể có một số nguyên thay đổi nào đó quyết định bạn trì hoãn bao nhiêu. Được rồi, và ta đã nói về display để in ra giá trị.
And then finally, there is this dollar sign finish function that you're going to need in your testbench. And this is what's actually going to end the simulation.
Và cuối cùng, có hàm dollar sign finish này mà bạn sẽ cần trong testbench. Và chính nó sẽ thực sự kết thúc mô phỏng.
So this is a very common mistake for people who, you know, are writing your first testbench.
Đây là một lỗi rất hay gặp với những người đang viết testbench đầu tiên.
You get everything set up, you have your initial block, and then you run the simulation, and it just hangs, it just sits there and runs forever.
Bạn thiết lập xong mọi thứ, có khối initial, rồi chạy mô phỏng, và nó cứ treo đó, chạy mãi không dừng.
And you know, you only had like two or three things that you were doing, you're wondering how can it take, how can it be this slow?
Trong khi bạn chỉ làm hai ba việc thôi, bạn tự hỏi sao lại có thể chậm thế này?
And it's probably just because you forgot to put the dollar sign finish in there. So always make sure that you add that.
Và nhiều khả năng chỉ vì bạn quên đặt dollar sign finish vào đó. Nên hãy luôn nhớ thêm nó.
Okay. Okay, simulation constructs. At this point, we should be pretty familiar with the posedge negedge notation.
Được rồi. Các cấu trúc mô phỏng. Đến lúc này, ta hẳn đã khá quen với ký hiệu posedge negedge.
But you can also use these things outside of an always block. They also just define events.
Nhưng bạn cũng có thể dùng chúng bên ngoài khối always. Chúng cũng chỉ định nghĩa các sự kiện.
Essentially, that's what this at symbol does, is just saying, wait for event. And the event is defined as pos edge signal.
Về cơ bản, ký hiệu @ này làm đúng việc đó, tức là chờ sự kiện. Và sự kiện được định nghĩa là posedge signal.
So if we have signal here, and we know it's toggling, right, we know that if we start here, the first at pos edge signal is going to take us to here, the first one is going to take us there.
Nếu ta có tín hiệu signal ở đây, và biết nó đang đảo trạng thái, đúng không, nếu ta bắt đầu từ đây, thì posedge signal đầu tiên sẽ đưa ta đến đây, cái đầu tiên sẽ đưa ta đến đó.
And then the second one is going to take us to there.
Và cái thứ hai sẽ đưa ta đến kia.
Yes. So is that the same thing as doing a delay, like an exact delay that takes us to the clock?
Vâng. Vậy điều đó có giống với việc tạo một độ trễ không, kiểu một độ trễ chính xác đưa ta đến cạnh xung clock?
Or do we still have to do like a delay by one to, like, you know, run the circuit? No, no, it is exactly the same.
Hay ta vẫn phải làm kiểu trễ một đơn vị rồi mới chạy mạch? Không, không, nó hoàn toàn giống nhau.
If you know the clock period, you can just specify, like, hey, I know this is, you know, 123. From here, then, yeah, it is the same, that would be the same.
Nếu biết chu kỳ clock, em chỉ cần chỉ định, kiểu như, tôi biết giá trị này là, ví dụ, 123. Từ đó thì đúng, nó sẽ giống nhau.
But in most cases, right, it's gonna be way easier to just say at pos edge signal.
Nhưng trong hầu hết trường hợp, chỉ cần viết at pos edge signal sẽ dễ hơn nhiều.
You want to know when it hits the positive edge, and the clock frequency could be changing all the time, or you could be setting it and you could maybe want it to be 10 nanoseconds in one simulation, then 100 nanoseconds for a different one.
Bạn muốn biết khi nào nó chạm cạnh lên, mà tần số clock có thể thay đổi liên tục, hoặc bạn có thể tự đặt nó và có thể muốn nó là 10 nanosecond trong một lần mô phỏng, rồi 100 nanosecond trong lần khác.
Okay. And I guess that leads very nicely into this next construct. You're generally going to have your block, if it has sequential circuits, and it is going to need a clock input.
Được rồi. Và tôi nghĩ điều đó dẫn rất tự nhiên sang cấu trúc tiếp theo. Thông thường khối của bạn, nếu có mạch tuần tự, sẽ cần một đầu vào clock.
And so you'll have to build that clock input inside your testbench. And that's what's being done here.
Và vì vậy bạn phải tạo đầu vào clock đó bên trong testbench. Đó chính là những gì đang được làm ở đây.
You define a clock as a reg, you initialize it to some value, and then you have this always block that is evaluating every 10 time steps that is just inverting clock.
Bạn khai báo clock là một reg, khởi tạo nó với một giá trị nào đó, rồi có một khối always này, cứ sau mỗi 10 bước thời gian lại được đánh giá, và nó chỉ đảo giá trị clock.
So if it starts at zero, at time 10, let's see, it starts at zero, at time 10 it goes to one, time 20 it goes to zero, so on and so forth.
Vậy nếu bắt đầu từ 0, tại thời điểm 10, để xem, nó bắt đầu từ 0, tại thời điểm 10 nó lên 1, thời điểm 20 nó về 0, cứ thế tiếp tục.
And you get this 20 time steps, period. And you know, this should be pretty self explanatory.
Và bạn có chu kỳ 20 bước thời gian. Và điều này khá dễ hiểu.
I guess the only thing to note is that you're always defining kind of the half clock period here, right?
Tôi nghĩ điều duy nhất cần lưu ý là ở đây bạn luôn định nghĩa nửa chu kỳ clock, đúng không?
So you just have to keep that in mind, that you're defining the half clock period right there.
Vậy bạn chỉ cần nhớ điều đó, rằng ở đó bạn đang định nghĩa nửa chu kỳ clock.
Okay, and there's another very useful construct, this repeat statement, that really just does it. It repeats the statement to the left the number of times that you put in the parentheses.
Được rồi, và còn một cấu trúc rất hữu ích khác, câu lệnh repeat này, thực sự làm đúng việc đó. Nó lặp lại câu lệnh bên trái số lần mà bạn đặt trong dấu ngoặc đơn.
So it will do this, do this 10x.
Vậy nó sẽ làm việc này, làm 10 lần.
So another way to write this top one here would be repeat 10 at posedge signal.
Vì vậy một cách khác để viết dòng trên cùng ở đây sẽ là repeat 10 at posedge signal.
That is exactly the same. Okay. All right, moving on. Okay, so display, we've already talked about this.
Điều đó hoàn toàn giống nhau. Được rồi. Được, tiếp tục nhé. Về display, chúng ta đã nói rồi.
Only thing this slide is trying to introduce is that you can do string formatting, similar to printf in C.
Điều duy nhất slide này muốn giới thiệu là bạn có thể định dạng chuỗi, tương tự printf trong C.
So we have the decimal and binary, and we're using that percent sign to denote when we want to substitute some value into the string.
Ở đây có thập phân và nhị phân, và ta dùng dấu phần trăm để chỉ chỗ ta muốn thay một giá trị nào đó vào chuỗi.
And then obviously the arguments after the string, which is enclosed in the double quotes, are just those substitution values, and they'll get substituted in order that you pass them to the display function.
Và rõ ràng các đối số sau chuỗi, được đặt trong dấu nháy kép, chính là những giá trị thay thế đó, và chúng sẽ được thay thế theo đúng thứ tự mà bạn truyền vào hàm display.
Okay. And yeah, so display can also be used inside RTL as well. This is purely for debugging and simulation.
Được rồi. Và display cũng có thể được dùng bên trong RTL. Nó hoàn toàn chỉ dùng để gỡ lỗi và mô phỏng.
If you pass this to a synthesis tool, it will just optimize it, it just won't even consider it. It won't be synthesized into anything, the display statement itself.
Nếu bạn đưa đoạn này cho một công cụ tổng hợp, nó sẽ tối ưu bỏ đi, thậm chí còn không xét đến. Bản thân câu lệnh display sẽ không được tổng hợp thành bất cứ thứ gì.
There could be other things inside that always block that are synthesizable that do end up being hardware, but the display, for synthesis tools, is just ignored.
Có thể có những thứ khác bên trong khối always đó có thể tổng hợp được và cuối cùng trở thành phần cứng, nhưng display thì các công cụ tổng hợp chỉ bỏ qua.
Okay. Now we have these two dimensional regs, or memory. You can also have two dimensional wires.
Được rồi. Bây giờ ta có các reg hai chiều này, hay còn gọi là bộ nhớ. Bạn cũng có thể có wire hai chiều.
It's just a way of defining like a two dimensional, or multi dimensional variable, where we have, In this case, we're defining a reg memory that is eight elements, eight elements here, and each element is 32 bits wide.
Đó chỉ là một cách định nghĩa một biến hai chiều, hay nhiều chiều, trong đó trong trường hợp này, ta định nghĩa một reg bộ nhớ có tám phần tử, tám phần tử ở đây, và mỗi phần tử rộng 32 bit.
And the way that you would index this is the first index that you pass it is for the element.
Và cách bạn lập chỉ mục là chỉ số đầu tiên mà bạn truyền vào dùng để chọn phần tử.
So that's what's showing here, right, is that if we do mem bracket two, that's just selecting the third 32nd bit element.
Đó là điều đang hiển thị ở đây, nếu ta viết mem ngoặc vuông hai, thì nó chỉ chọn phần tử 32 bit thứ ba.
And you can imagine this like a big memory structure, right, zero all the way to seven here.
Và bạn có thể hình dung nó như một cấu trúc bộ nhớ lớn, từ không cho đến bảy ở đây.
I'm going to get these wrong. But so we would be selecting this guy here, if this is 32 bits in length.
Tôi sẽ vẽ nhầm mất. Nhưng ta sẽ chọn phần tử này ở đây, nếu nó dài 32 bit.
And then this is just showing that you can also do part selects on this dimension, where let's say we just want the lowest byte of the sixth 32 bit element.
Và phần này chỉ cho thấy rằng bạn cũng có thể chọn một phần trên chiều này, chẳng hạn ta chỉ muốn byte thấp nhất của phần tử 32 bit thứ sáu.
We can define that as mem, first index five, and then seven down to zero. So you do it. So this would be 0, 1, 2, 3, 4, 5.
Ta có thể định nghĩa là mem, chỉ số đầu tiên năm, rồi bảy xuống không. Vậy ta đếm: 0, 1, 2, 3, 4, 5.
And it would be like that piece of data right there. Does that make sense?
Và nó sẽ là phần dữ liệu ngay đó. Mọi người hiểu chứ?
Okay. Yeah.
Được rồi. Vâng.
Yeah, so it's a single byte, because seven down to zero is eight bits, which is just a single byte. Yeah. Okay.
Vâng, đó là một byte duy nhất, vì bảy xuống không là tám bit, tức chỉ một byte. Vâng. Được rồi.
So this is actually the last slide. So we may end early. And this is the generate construct.
Đây thực ra là slide cuối cùng. Nên có thể ta sẽ kết thúc sớm. Và đây là cấu trúc generate.
And the generate construct allows you to generate multiple modules inside other modules using this for loop structure.
Cấu trúc generate cho phép bạn sinh ra nhiều module bên trong các module khác bằng cấu trúc vòng lặp for này.
So basically it gives you like a software interface to generating hardware. But it also allows you to do kind of conditional generations.
Về cơ bản, nó cho bạn một giao diện kiểu phần mềm để sinh phần cứng. Nhưng nó cũng cho phép sinh có điều kiện.
So the first one is showing us, if we want to build an adder explicitly out of full adder blocks that we have, then you can use this generate adder, or this generate statement, to generate all the full adders that you need, and then also connect them together.
Ví dụ đầu tiên cho ta thấy, nếu muốn xây dựng một bộ cộng tường minh từ các khối bộ cộng đầy đủ mà ta có, thì bạn có thể dùng generate bộ cộng này, hay câu lệnh generate này, để sinh tất cả các bộ cộng đầy đủ cần thiết, rồi nối chúng lại với nhau.
So you see, we have this variable that's being incremented, you know, and we is being incremented and then being used to kind of assign the carry ins and carry outs properly.
Bạn thấy ta có biến này đang được tăng dần, và nó được tăng lên rồi được dùng để gán đúng các ngõ vào nhớ và ngõ ra nhớ.
But between the different full adders, the only thing is you need this special genvar variable in order to use it inside this generate for statement.
Nhưng giữa các bộ cộng đầy đủ khác nhau, điều duy nhất là bạn cần biến genvar đặc biệt này để dùng bên trong câu lệnh generate for này.
Now, that's only for the for loop, the kind of loop generate construct. For the conditional, you can just use a module parameter like multi option.
Đó chỉ là cho vòng lặp for, tức là cấu trúc generate dạng vòng lặp. Còn với điều kiện, bạn chỉ cần dùng một tham số của module, như multi option.
And then you can do a generate if that option is equal to something, and then, you know, create a multiplier, create an adder, depending on that parameter, or really anything that you want, right?
Rồi bạn có thể viết generate if tùy chọn đó bằng một giá trị nào đó, và sau đó, tạo một bộ nhân, hoặc tạo một bộ cộng, tùy theo tham số đó, hay thực ra là bất cứ thứ gì bạn muốn, đúng không?
It's just giving you this kind of conditional hardware generation tool.
Nó chỉ cung cấp cho bạn công cụ tạo phần cứng có điều kiện thế này.
So does that mean that it's like, all of this if statement is going to be handled, like during synthesizing, not like be part of the code, like a mux or something?
Vậy có nghĩa là toàn bộ câu lệnh if này sẽ được xử lý trong lúc tổng hợp, chứ không phải là một phần của mã, như một mux hay gì đó đúng không?
That's right.
Đúng vậy.
So if this was in an always block, right, then every time it would evaluate it, it would check to see what the mode option is, and then either do a multiplication or addition.
Nếu nó nằm trong một khối always, thì mỗi lần nó đều sẽ đánh giá, nó sẽ kiểm tra xem tùy chọn chế độ là gì, rồi thực hiện phép nhân hoặc phép cộng.
When you use the generate, you can think of it like you instantiate your block, and you say, hey, I want mode option one.
Khi dùng generate, bạn có thể hình dung là bạn khởi tạo khối của mình, và nói rằng, tôi muốn chế độ một.
And that means that that module is now just has a multiplier, it doesn't have a multiplier and an adder, it just has one or the other. Yeah. Yes.
Nghĩa là module đó giờ chỉ có một bộ nhân, nó không có cả bộ nhân lẫn bộ cộng, mà chỉ có một trong hai. Vâng. Đúng vậy.
No, no. So the initialization happens right here. Or I guess like, can you combine like the line one and line two?
Không, không. Phần khởi tạo xảy ra ngay ở đây. Hoặc là, em có thể gộp dòng một và dòng hai không?
I think you can do that. Actually, you can say generate for genvar i equals zero, i less than that, but I can't remember.
Tôi nghĩ là làm được. Thực ra, bạn có thể viết generate for genvar i bằng không, i nhỏ hơn cái kia, nhưng tôi không nhớ rõ.
But I think you give it a try. I think you can do that.
Nhưng tôi nghĩ bạn cứ thử xem. Tôi nghĩ là làm được.
All right. Any other questions? So for the second scenario, if we don't use generate, what would it look like?
Được rồi. Còn câu hỏi nào khác không? Vậy với tình huống thứ hai, nếu không dùng generate thì nó sẽ trông như thế nào?
So first off, you can't use an if statement just like in the middle of a module, right?
Trước hết, bạn không thể dùng câu lệnh if ngay giữa một module, đúng không?
I think even in the later specs, if you do that, it will kind of just assume that you're trying to do a generate statement.
Tôi nghĩ ngay cả ở các đặc tả mới hơn, nếu bạn làm vậy, nó sẽ tự hiểu là bạn đang định viết một câu lệnh generate.
It doesn't require you to use the generate statement at all anymore.
Nó không còn bắt bạn phải dùng câu lệnh generate nữa.
But what we've learned is that if you want to use an if statement, it has to be inside some kind of procedural block, which is either an always or an initial block.
Nhưng điều ta đã học là nếu muốn dùng câu lệnh if, nó phải nằm trong một khối thủ tục nào đó, tức là khối always hoặc khối initial.
So I think in this standard, the 2005 Verilog standard that we're using, if you want to include the generate blocks, you just had if option equals equals one, whatever, it would error and say this is not good Verilog.
Vậy nên tôi nghĩ với chuẩn này, chuẩn Verilog 2005 mà ta đang dùng, nếu bạn muốn đưa vào các khối generate, mà chỉ viết if option bằng bằng một, v.v., thì nó sẽ báo lỗi và nói đây không phải Verilog hợp lệ.
Yes. So I was in a lab yesterday, and I read that there's some restrictions on using always less infinity.
Vâng, mời em. Hôm qua em ở trong phòng thí nghiệm, và em đọc thấy có một số hạn chế khi dùng always vô hạn.
And I guess something I was curious about, like, I think this is really the last question.
Và có một điều em tò mò, em nghĩ đây thực sự là câu hỏi cuối cùng.
So it's like, are there certain instances where we can't, like, model something because we can't share your insight at all?
Đó là, có trường hợp nào mà ta không thể mô hình hóa một thứ gì đó vì ta hoàn toàn không thể chia sẻ hiểu biết của mình không?
Like, or would we always be able to, like, follow those pieces?
Hay là lúc nào ta cũng có thể làm theo những phần đó?
Yeah, I'm not sure. I'm not sure I completely understand. Are you, are you asking if you can put a generate statement inside always blocks? Um, it seems like it's not possible. Yeah, yeah.
Ừm, tôi không chắc. Tôi không chắc là mình hiểu hoàn toàn câu hỏi. Có phải bạn đang hỏi liệu có thể đặt một câu lệnh generate bên trong các khối always không? Ừm, có vẻ là không thể. Vâng, vâng.
It's not allowed. You can generate always blocks. Yeah.
Không được phép. Bạn có thể generate các khối always. Vâng.
So I guess, like, what I guess, would having non-blocking statements always ensure that, um, even though we have to have, like, multiple always blocks in, like, a generate function, like me.
Vậy em nghĩ là, liệu việc dùng các câu lệnh non-blocking có luôn đảm bảo rằng, ừm, dù chúng ta phải có nhiều khối always trong một hàm generate, như của em.
So, oh, this is really hard to say. Yeah, no worries. But so, like, earlier, we were talking about blocking and non-blocking statements.
Ôi, thật khó nói ra. Vâng, không sao đâu. Nhưng như lúc trước, chúng ta đã nói về các câu lệnh blocking và non-blocking.
We talked about how, like, with blocking statements, when you have multiple always blocks, because of the order of, like, evaluation, this resource is not deterministic, we might have, like, certain issues.
Chúng ta đã nói rằng với các câu lệnh blocking, khi có nhiều khối always, do thứ tự đánh giá, kết quả này không mang tính xác định, nên có thể gặp một số vấn đề.
Yes.
Vâng.
And so given that, with, like, we can't put a generate inside an always block, like, would we ever have issues?
Và như vậy, vì chúng ta không thể đặt generate bên trong một khối always, liệu có bao giờ gặp vấn đề không?
Because, like, say we want to make sure that some, like, because of, like, analysis is deterministic, like, it always goes through, like, I equals one, I equals two, I equals three, and so on.
Bởi vì, giả sử ta muốn đảm bảo rằng do phân tích mang tính xác định, tức là nó luôn chạy lần lượt qua i bằng một, i bằng hai, i bằng ba, và cứ thế.
But we can't do that because we can't put a generate inside an always block.
Nhưng ta không làm được vậy vì không thể đặt generate bên trong một khối always.
Yeah, I'm not sure I'm completely understanding. But yeah, you should come by office hours, if you can. And we can talk more about it, or post something on it as well.
Vâng, tôi không chắc là mình hiểu hoàn toàn. Nhưng nếu được, bạn hãy đến giờ tiếp sinh viên nhé. Và chúng ta có thể trao đổi thêm, hoặc bạn cũng có thể đăng bài hỏi về việc này.
Any other questions? So what's the answer to the last question? So the answer to the last question is, well, what do you, what do you think it is?
Còn câu hỏi nào khác không? Vậy đáp án của câu hỏi cuối là gì? Đáp án của câu hỏi cuối là, các bạn nghĩ nó là gì?
I guess, we see both multiplier. So, no, the answer is actually no, right?
Em nghĩ là ta thấy cả hai bộ nhân. Không, đáp án thực ra là không, đúng không?
This is the whole, this is the big difference between the generate and then if else inside a procedural block, or really an always block, is that in an always block, you're going to have two pieces of hardware that will be used.
Đây là điểm khác biệt lớn giữa generate và if else bên trong một khối thủ tục, hay đúng hơn là một khối always: trong khối always, bạn sẽ có hai phần cứng được dùng.
Right? If that option is one, it will use this one; if option zero, then it'll use the other one, and it'll always check to see which piece of hardware it should be using.
Đúng không? Nếu tùy chọn đó là một thì nó dùng cái này; nếu là không thì nó dùng cái kia, và nó luôn kiểm tra xem nên dùng phần cứng nào.
When you use the generate statement, only one of these things gets instantiated in the block itself.
Khi bạn dùng câu lệnh generate, chỉ một trong các thứ này được khởi tạo trong chính khối đó.
So it happens, you can think of it like at the very beginning of the simulation or the synthesis, it will look at that mult option and say, okay, does this, you know, should I instantiate a multiplier or an adder?
Nên bạn có thể hình dung là ngay từ đầu của quá trình mô phỏng hoặc tổng hợp, nó sẽ xem tùy chọn mult đó và tự hỏi: được rồi, mình nên khởi tạo một bộ nhân hay một bộ cộng?
Then it will pick whichever one. And then the other thing no longer exists, it doesn't exist. I see. So no option has to be a constant, it cannot be ever assigned.
Rồi nó sẽ chọn một trong hai. Và cái còn lại không còn tồn tại nữa. Em hiểu rồi. Vậy tùy chọn này phải là một hằng số, không bao giờ được gán lại.
That is, that is true. Yes. Yeah, it's a parameter. I see. And then you need to be decided in compile time. Uh, yeah, yeah.
Đúng vậy. Vâng. Vâng, nó là một parameter. Tôi hiểu rồi. Và nó cần được quyết định tại thời điểm biên dịch. À, vâng, vâng.
And then what if it's like, actually, it's not like denested for like, if loops that it was actually changed, who will catch it?
Vậy nếu nó không được lồng vào, ví dụ như, các vòng lặp if mà thực ra nó đã bị thay đổi, thì ai sẽ phát hiện ra?
Um, who will catch it? So compile time, or like run time? I don't think so. No. So there are two different kinds of parameters. There's just regular parameter, and then there's local param.
Ừm, ai sẽ phát hiện ra? Lúc biên dịch hay lúc chạy? Tôi không nghĩ vậy. Không. Có hai loại parameter khác nhau. Có parameter thông thường, và có local param.
This one is actually a constant. So you define something as a local parameter, it will never change.
Loại này thực sự là một hằng số. Khi bạn định nghĩa một thứ là local parameter, nó sẽ không bao giờ thay đổi.
For a parameter, I would imagine that what happens is that when the block is elaborated, kind of the initial value of the parameter is used for the generate statements.
Còn với parameter thông thường, tôi đoán điều xảy ra là khi khối được elaborate, giá trị ban đầu của parameter sẽ được dùng cho các câu lệnh generate.
And then if you were to change the parameter at some later time, it wouldn't affect the generate statement in any way, because that's already been evaluated, and it's done.
Và nếu sau đó bạn thay đổi parameter, thì nó cũng không ảnh hưởng gì đến câu lệnh generate, vì câu lệnh đó đã được đánh giá xong rồi.
Like you said, you can put a generate statement in a for loop, right? That's right. Well, generate statement in a for loop. So you can use a for loop as a generate statement.
Như bạn nói, bạn có thể đặt một câu lệnh generate trong vòng lặp for, đúng không? Đúng vậy. À, câu lệnh generate trong một vòng lặp for. Vậy bạn có thể dùng một vòng lặp for như một câu lệnh generate.
Essentially, I can create some way where this generative statement will be evaluated multiple times. Generative statement. Yeah, you can have a generate statement inside a generate statement.
Về cơ bản, tôi có thể tạo ra một cách nào đó để câu lệnh generate này được đánh giá nhiều lần. Câu lệnh generate. Vâng, bạn có thể có một câu lệnh generate bên trong một câu lệnh generate.
A generative statement? Right. Yeah, yeah. Depending on the value of I, it would have to instantiate one or the other multiple times, right? Yeah, you could do something like that. Yeah.
Một câu lệnh generate ư? Đúng rồi. Vâng, vâng. Tùy theo giá trị của I, nó sẽ phải tạo ra cái này hoặc cái kia nhiều lần, đúng không? Vâng, bạn có thể làm như vậy. Vâng.
And that would actually be either one or the other hardware actually living on them. Exactly. Yeah, yeah. One or the other. Yeah. Okay. We're gonna end.
Và thực tế đó sẽ là phần cứng này hoặc phần cứng kia thực sự tồn tại trên chip. Chính xác. Vâng, vâng. Cái này hoặc cái kia. Vâng. Được rồi. Chúng ta sẽ kết thúc.
Đă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.