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 here. Welcome to EECS 151/251A, Introduction to Digital Logic and Integrated Circuits. It's great to see you again.
Chào buổi sáng cả lớp. Rất vui được gặp các bạn ở đây. Chào mừng các bạn đến với EECS 151/251A, Nhập môn Thiết kế Logic số và Mạch tích hợp. Rất vui được gặp lại các bạn.
In today's lecture, we're going to have our seventh lecture of the semester. We're going to finish our discussion on finite state machine.
Hôm nay chúng ta sẽ có bài giảng thứ bảy của học kỳ. Chúng ta sẽ kết thúc phần thảo luận về máy trạng thái hữu hạn.
We started our discussion on Moore versus Mealy, different ways of building finite state machine. We'll talk about the differences and how we express them in Verilog.
Chúng ta đã bắt đầu bàn về Moore so với Mealy, những cách khác nhau để xây dựng máy trạng thái hữu hạn. Chúng ta sẽ nói về những điểm khác biệt và cách diễn đạt chúng trong Verilog.
We are also going to start some of our discussion on RISC-V. For folks who have taken 61C before, the RISC-V discussion is more like a review session.
Chúng ta cũng sẽ bắt đầu bàn đôi chút về RISC-V. Với những bạn đã học 61C rồi, phần RISC-V giống như một buổi ôn tập hơn.
We'll go through the basics of the ISAs very quickly. Basically, next two lectures, next week's lecture, we'll go over different ISA aspects so that you are ready for your final project.
Chúng ta sẽ điểm qua những kiến thức cơ bản về ISA rất nhanh. Về cơ bản, trong hai bài giảng tới, tức là bài giảng tuần sau, chúng ta sẽ đi qua các khía cạnh khác nhau của ISA để các bạn sẵn sàng cho đồ án cuối kỳ.
For folks who haven't seen RISC-V before, it's okay. We'll also use those two lectures to go over different components of RISC-V so you are also prepared for your project.
Với những bạn chưa từng thấy RISC-V thì không sao. Chúng ta cũng sẽ dùng hai bài giảng đó để đi qua các thành phần khác nhau của RISC-V để các bạn cũng được chuẩn bị cho đồ án của mình.
Since we're talking about ISAs, it's less of an issue really these days.
Nói về ISA, thật ra ngày nay vấn đề này không còn quá quan trọng.
If you actually, I guess, went to any kind of computer architecture class 10, like 15, 20 years ago, the hottest topic is always RISC versus CISC, which I say will win.
Nếu các bạn, tôi đoán là, đã học bất kỳ lớp kiến trúc máy tính nào cách đây 10, 15, 20 năm, thì chủ đề nóng nhất luôn là RISC so với CISC, xem bên nào sẽ thắng.
Today, it's actually interesting to see the ISA dynamics, especially with this pretty recent announcement from Intel. They are first planning to actually license their x86 ISA.
Ngày nay, thật thú vị khi quan sát diễn biến của các ISA, đặc biệt với thông báo khá gần đây từ Intel. Lần đầu tiên họ dự định cấp phép ISA x86 của mình.
Not only Intel, so basically now Intel and AMD, there is another, VIA Technologies. They also have an x86 license. That's about it.
Không chỉ Intel, hiện giờ là Intel và AMD, còn có một bên nữa là VIA Technologies. Họ cũng có giấy phép x86. Chỉ có vậy thôi.
They are actually interested in opening up the x86 license so that external customers, external users, can also build their own x86 processor. That's the one thing that's actually interesting.
Giờ họ quan tâm đến việc mở giấy phép x86 để các khách hàng bên ngoài, những người dùng bên ngoài, cũng có thể tự xây dựng bộ xử lý x86 của riêng mình. Đó là một điều thực sự thú vị.
Intel is adding x86 to the ISA mix. Not only just ARM and RISC-V, there are also more components. They are also opening up their FAB. They are calling this a multi-ISA strategy.
Intel đang đưa x86 vào tập hợp các ISA. Không chỉ có ARM và RISC-V, còn có nhiều thành phần khác nữa. Họ cũng đang mở cửa nhà máy sản xuất chip (FAB) của mình. Họ gọi đây là chiến lược đa ISA.
It's not only about which ISA will win, which ISA we will choose. We are really talking about this kind of more heterogeneous platform. RISC-V is used. Let's get a RISC-V IP here.
Vấn đề không chỉ là ISA nào sẽ thắng, chúng ta sẽ chọn ISA nào. Chúng ta đang thực sự nói về một nền tảng đa dạng (heterogeneous) hơn như vậy. RISC-V được dùng. Hãy lấy một IP RISC-V ở đây.
If we actually really want to use ARM... ARM just announced their high performance core for server market recently. That's also very exciting.
Nếu thực sự muốn dùng ARM... ARM vừa công bố lõi hiệu năng cao cho thị trường máy chủ gần đây. Điều đó cũng rất thú vị.
If they want to use ARM, they can also use ARM IP, or x86 of interest. They can also use that. We do see the ecosystem become a lot more open but also competitive.
Nếu muốn dùng ARM, họ cũng có thể dùng IP của ARM, hoặc x86 nếu quan tâm. Họ cũng có thể dùng cái đó. Chúng ta thấy hệ sinh thái trở nên mở hơn nhiều nhưng cũng cạnh tranh hơn.
Users do have the choice. We have this kind of separated market, FAPs providing FAP facilities. Then we have different ISA vendors and we can also get different IP vendors.
Người dùng có quyền lựa chọn. Chúng ta có thị trường tách biệt này, với các FAB cung cấp dịch vụ sản xuất. Rồi có các nhà cung cấp ISA khác nhau và chúng ta cũng có thể chọn các nhà cung cấp IP khác nhau.
It's getting easier to build this kind of heterogeneous platform. That's really important, especially for newcomers in this industry.
Việc xây dựng loại nền tảng đa dạng này đang trở nên dễ dàng hơn. Điều đó thực sự quan trọng, đặc biệt với những người mới vào ngành này.
It's also getting very competitive, especially from a system level, how you efficiently integrate different ISAs together and how you actually compete with one another, because everything is in the open space.
Nó cũng đang trở nên rất cạnh tranh, đặc biệt ở cấp độ hệ thống, làm thế nào để tích hợp hiệu quả các ISA khác nhau với nhau và làm thế nào để thực sự cạnh tranh với nhau, vì mọi thứ đều nằm trong một không gian mở.
We'll see a lot more competition in this area, but we'll also see not only just the traditional hardware company. We'll see a lot of other companies actually participating in the semiconductor, in the startups.
Chúng ta sẽ thấy cạnh tranh nhiều hơn hẳn trong lĩnh vực này, nhưng không chỉ có các công ty phần cứng truyền thống. Chúng ta sẽ thấy rất nhiều công ty khác tham gia vào ngành bán dẫn, trong các công ty khởi nghiệp.
There will be a lot of exciting development in this era when people think about how they use different ISAs, using different advanced FAP facilities to build interesting hardware.
Sẽ có rất nhiều phát triển thú vị trong kỷ nguyên này khi mọi người nghĩ về cách sử dụng các ISA khác nhau, dùng các cơ sở FAP tiên tiến khác nhau để xây dựng phần cứng thú vị.
Some interesting developments on the ISA war. I guess it's not war anymore. It's super collaborative, but it's interesting after a couple of decades.
Có một số diễn biến thú vị về cuộc chiến ISA. Tôi đoán giờ không còn là chiến tranh nữa. Nó mang tính hợp tác rất cao, nhưng thật thú vị sau vài thập kỷ.
The ISA discussion, instead of fighting which one is a winner, it's more about how we can actually work collaboratively so that we can build efficient systems.
Trong thảo luận về ISA, thay vì tranh nhau xem ai là người chiến thắng, trọng tâm là làm sao chúng ta thực sự hợp tác với nhau để có thể xây dựng các hệ thống hiệu quả.
That's on the ISA end before we start RISC-V discussions.
Đó là phần về ISA trước khi chúng ta bắt đầu thảo luận về RISC-V.
As I mentioned earlier, today's lecture, we're going to wrap up our FSM discussion so that we can talk about the differences with more on the Mealy FSM and how we actually express that in Verilog.
Như tôi đã nói trước đó, bài giảng hôm nay, chúng ta sẽ kết thúc phần thảo luận về FSM để có thể nói về những khác biệt, với trọng tâm là FSM Mealy và cách chúng ta thực sự diễn đạt nó trong Verilog.
We'll also start our RISC-V discussion. We'll mostly just focus on different datapath components. We'll talk about how we actually connect all the different components in a coherent fashion next week.
Chúng ta cũng sẽ bắt đầu thảo luận về RISC-V. Chủ yếu chúng ta sẽ tập trung vào các thành phần datapath khác nhau. Tuần sau chúng ta sẽ nói về cách kết nối tất cả các thành phần đó lại với nhau một cách mạch lạc.
More on the Mealy FSM. We mentioned this already last lecture. For FSM, always three components. We need some state element to store the state. We need two types of combinational logic.
Thêm về FSM Mealy. Chúng ta đã đề cập điều này ở bài giảng trước. Với FSM, luôn có ba thành phần. Chúng ta cần một phần tử trạng thái để lưu trạng thái. Chúng ta cần hai loại logic tổ hợp.
One is to calculate what the next state should be, and another combinational logic to calculate what the output should be.
Một loại để tính trạng thái kế tiếp, và một logic tổ hợp khác để tính đầu ra.
Next state is actually always the same for either Moore or Mealy machines, always determined by current state and input. The difference is really in thinking about the combinational logic to calculate the output logic.
Trạng thái kế tiếp thực ra luôn giống nhau với cả máy Moore lẫn Mealy, luôn được xác định bởi trạng thái hiện tại và đầu vào. Sự khác biệt thực sự nằm ở việc suy nghĩ về logic tổ hợp để tính logic đầu ra.
Basically, this part of the diagram.
Về cơ bản là phần này của sơ đồ.
When we think about output logic, whether it's only dependent on the current state of the machine, that's basically Moore FSM, or it's actually dependent on both the current state and also the current input.
Khi nghĩ về logic đầu ra, nếu nó chỉ phụ thuộc vào trạng thái hiện tại của máy, thì đó về cơ bản là FSM Moore, còn nếu nó phụ thuộc vào cả trạng thái hiện tại lẫn đầu vào hiện tại.
Now it's not only just because of the state, but also the current input. That's the Mealy FSM.
Lúc này không chỉ do trạng thái, mà còn do đầu vào hiện tại. Đó là FSM Mealy.
Towards the end of the last lecture, our students also mentioned the key difference is whether the output is only dependent on the register, which is synchronized with clock, versus in Mealy FSM, it's not only dependent on the register, the value of the register, but also dependent on the input.
Gần cuối bài giảng trước, các bạn sinh viên cũng đã nêu khác biệt chính là liệu đầu ra chỉ phụ thuộc vào thanh ghi, vốn đồng bộ với xung nhịp, hay trong FSM Mealy, nó không chỉ phụ thuộc vào thanh ghi, tức giá trị của thanh ghi, mà còn phụ thuộc vào đầu vào.
In that case, it can be asynchronous. As long as input changes, output can actually change immediately, fully combinational logic.
Trong trường hợp đó, nó có thể là bất đồng bộ. Miễn là đầu vào thay đổi, đầu ra có thể thay đổi ngay lập tức, logic tổ hợp hoàn toàn.
Today we're going to talk about why they're different and what the implications are, especially from a timing behavior, why this difference actually matters when you think about FSM design.
Hôm nay chúng ta sẽ nói về lý do chúng khác nhau và những hệ quả của sự khác biệt đó, đặc biệt là về hành vi định thời, tức là vì sao sự khác biệt này thực sự quan trọng khi bạn thiết kế FSM.
In today's discussion, we'll use a different FSM.
Trong buổi hôm nay, chúng ta sẽ dùng một FSM khác.
We'll cover different, you will also see different FSM in your homeworks, in your labs, and also in exams, past exams, you will see different, you'll get to exercise different things.
Chúng ta sẽ đề cập các FSM khác nhau, bạn cũng sẽ gặp các FSM khác nhau trong bài tập về nhà, trong các bài lab, và cả trong các kỳ thi, các đề thi cũ, bạn sẽ thấy những FSM khác nhau, và bạn sẽ được luyện tập nhiều điều khác nhau.
In this example, we'll be using an edge detection logic. As the name suggests, we are basically trying to figure out a particular pattern.
Trong ví dụ này, chúng ta sẽ dùng một logic phát hiện cạnh. Đúng như tên gọi, về cơ bản chúng ta đang cố nhận ra một mẫu nhất định.
The pattern is basically what we call an edge. It's basically when we notice a shift from zero to one.
Mẫu đó chính là cái mà ta gọi là một cạnh. Về cơ bản, đó là khi ta nhận thấy một sự chuyển từ 0 lên 1.
There is basically an edge observed in the input bitstream, and then we notify the external world, "Edge is detected."
Tức là có một cạnh được quan sát thấy trong chuỗi bit đầu vào, và khi đó ta thông báo cho thế giới bên ngoài: "Đã phát hiện cạnh."
Whenever we approach a finite state machine, we always need to figure out what's the input, what's the output, what's the functionality of this circuit. Here, the input is basically a sequence of bitstream.
Mỗi khi tiếp cận một máy trạng thái hữu hạn, ta luôn cần xác định đầu vào là gì, đầu ra là gì, và chức năng của mạch này là gì. Ở đây, đầu vào về cơ bản là một dãy bit.
Here, it's a bitstream, we're actually receiving one bit at a time. Every cycle, we receive one bit, and again, we like to actually detect the output.
Đây là một chuỗi bit, và ta nhận từng bit một. Mỗi chu kỳ, ta nhận một bit, và một lần nữa, ta muốn phát hiện ra đầu ra.
For this edge detection, the output is basically, or true, basically true or false, or false or true, whether a particular pattern, in this case, a zero to one transition, is detected.
Với việc phát hiện cạnh này, đầu ra về cơ bản là đúng hoặc sai, về cơ bản là đúng hay sai, hoặc sai hay đúng, tùy một mẫu nhất định, trong trường hợp này, một sự chuyển từ 0 lên 1, có được phát hiện hay không.
That's the output. The functionality of this FSM is basically edge detection.
Đó là đầu ra. Chức năng của FSM này về cơ bản là phát hiện cạnh.
Whenever we detect, as we mentioned earlier, this particular pattern, input changes from zero to one, we tell the output, "Here, the pattern you want is detected. We observe this zero to one transition."
Mỗi khi ta phát hiện, như đã nói trước đó, mẫu này, tức đầu vào đổi từ 0 sang 1, ta báo cho đầu ra: "Đã phát hiện mẫu bạn muốn. Chúng ta quan sát thấy sự chuyển từ 0 lên 1 này."
This is, again, only the input and output, and also the behavior of the internal circuit. There could be different ways of actually designing this FSM.
Một lần nữa, đây mới chỉ là đầu vào và đầu ra, và cả hành vi của mạch bên trong. Có thể có nhiều cách khác nhau để thiết kế FSM này.
FSM is basically the internal logic that meets this function specification.
FSM về cơ bản là phần logic bên trong đáp ứng đặc tả chức năng này.
One thing you do notice, that when we specify here output, we only specify the expected value of the output, but we didn't specify the timing, when zero and one is supposed to actually show up.
Có một điều bạn để ý: khi chỉ định đầu ra ở đây, ta chỉ chỉ định giá trị mong đợi của đầu ra, mà không chỉ định định thời, tức là khi nào thì 0 và 1 phải xuất hiện.
You will see that that actually has an implication in deciding whether we want to do Moore versus Mealy FSM.
Bạn sẽ thấy điều đó thực sự ảnh hưởng đến việc quyết định nên chọn FSM Moore hay Mealy.
In this example, with this combination of input and output and the FSM functionality, we could actually design two styles of FSM, finite state machine, that meet the specification.
Trong ví dụ này, với tổ hợp đầu vào và đầu ra này cùng chức năng của FSM, ta có thể thiết kế hai kiểu FSM, máy trạng thái hữu hạn, đều đáp ứng đặc tả.
We'll start from the left-hand side. Again, we talked about last time, whenever we think about FSM machine, we start from the state transition diagram.
Chúng ta sẽ bắt đầu từ phía bên trái. Như đã nói lần trước, mỗi khi nghĩ đến một máy FSM, ta bắt đầu từ sơ đồ chuyển trạng thái.
What are the different states? How they transition from each other? Whenever we talk about state transition diagram, there's always circle indicating states.
Các trạng thái khác nhau là gì? Chúng chuyển đổi qua lại với nhau như thế nào? Mỗi khi nói về sơ đồ chuyển trạng thái, luôn có các hình tròn biểu thị các trạng thái.
Whenever I see a circle, it's indicating the states, and also edges indicating transitions, and inputs are labeled on the edges.
Mỗi khi thấy một hình tròn, nó biểu thị các trạng thái, và còn có các cạnh biểu thị các phép chuyển, với đầu vào được ghi trên các cạnh.
Whenever we receive certain inputs, that triggers a transition, either a self-edge, come back to my current state, or that actually triggers some activity that we are actually leaving the current state, go to a different state.
Mỗi khi nhận được một số đầu vào nhất định, điều đó kích hoạt một phép chuyển, hoặc là cạnh tự lặp, quay về trạng thái hiện tại của mình, hoặc là kích hoạt một hoạt động nào đó khiến ta rời khỏi trạng thái hiện tại và sang một trạng thái khác.
For FSM, we always start from the state transition diagram that consists of circles indicating states and edges indicating inputs that triggered transition.
Với FSM, ta luôn bắt đầu từ sơ đồ chuyển trạng thái gồm các hình tròn biểu thị các trạng thái và các cạnh biểu thị đầu vào kích hoạt phép chuyển.
You will actually approach this problem from a Moore machine. Here is a potential design that we came up with. In this machine, we actually have three states.
Các bạn sẽ tiếp cận bài toán này bằng máy Moore. Đây là một thiết kế khả dĩ mà chúng tôi đã nghĩ ra. Trong máy này, ta có ba trạng thái.
We have zero states, meaning that we have been observing zeros. We haven't observed the patterns.
Ta có trạng thái zero, nghĩa là ta đang quan sát thấy các số không. Ta chưa quan sát thấy mẫu cần tìm.
We have a change state because we're actually trying to track this rising edge, changes from zero to one transition.
Ta có trạng thái change vì ta đang cố theo dõi cạnh lên này, tức là phép chuyển từ không sang một.
We have a change state where we track, we notice, we observe there is a zero to one transition, and then we actually output one.
Ta có trạng thái change, nơi ta theo dõi, ta nhận thấy, ta quan sát được có một phép chuyển từ không sang một, và khi đó ta xuất ra một.
After we actually get one, and then we have a one state, meaning we are basically receiving one. We're either receiving zero or receiving one, but we haven't actually observed the transition.
Sau khi ta nhận được một, thì ta có trạng thái one, nghĩa là về cơ bản ta đang nhận số một. Ta đang nhận số không hoặc đang nhận số một, nhưng ta chưa quan sát thấy phép chuyển.
That's basically the next state.
Đó về cơ bản là trạng thái kế tiếp.
In this state transition diagram, we have three states: zero states, we're receiving zero; one state, we're receiving one; and between those states, we have this change state notifying that we observe this zero to one transition.
Trong sơ đồ chuyển trạng thái này, ta có ba trạng thái: trạng thái zero, ta đang nhận số không; trạng thái one, ta đang nhận số một; và giữa hai trạng thái đó, ta có trạng thái change này để báo rằng ta đã quan sát thấy phép chuyển từ không sang một.
If you have time, you can also go over other edges. That basically signals why we actually move from certain stage to another.
Nếu có thời gian, các bạn cũng có thể xem qua các cạnh khác. Chúng cho biết vì sao ta chuyển từ trạng thái này sang trạng thái khác.
One thing you'll notice here is that we only output one in the change state because that's basically the pattern that we're observing. We only output one in the change state.
Một điều các bạn sẽ để ý ở đây là ta chỉ xuất ra một ở trạng thái change vì đó chính là mẫu mà ta đang quan sát. Ta chỉ xuất ra một ở trạng thái change.
If we're receiving zero, we don't output one. If we're receiving one, it's also not the expected pattern. We also keep our output low. This is a Moore machine.
Nếu đang nhận số không, ta không xuất ra một. Nếu đang nhận số một, đó cũng không phải mẫu mong đợi. Ta cũng giữ đầu ra ở mức thấp. Đây là máy Moore.
We see the output is actually tied to the current state. Whenever input changes, we always need to transition to a different state to actually change the output.
Ta thấy đầu ra gắn với trạng thái hiện tại. Mỗi khi đầu vào thay đổi, ta luôn cần chuyển sang một trạng thái khác để thay đổi đầu ra.
You can go through this, and then we talk about adding encodings and how we actually figure out the Boolean expression of different combinational logic. We can actually get to this gate-level representation.
Các bạn có thể xem qua phần này, rồi ta sẽ nói về việc thêm mã hóa và cách ta xác định biểu thức Boolean của các mạch tổ hợp khác nhau. Từ đó ta có thể đi đến biểu diễn ở mức cổng này.
Again, we have state registers here.
Một lần nữa, ở đây ta có các thanh ghi trạng thái.
We have our logic to figure out what the next state is, the next state of computing combinational logic, and we have our output combinational logic.
Ta có phần logic để xác định trạng thái kế tiếp là gì, trạng thái kế tiếp của mạch tổ hợp tính toán, và chúng ta có khối logic tổ hợp cho đầu ra.
We see that in our output combinational logic, we're only dependent on the current state. That's our Moore machine here. Question? This only detects the positive? Yes.
Ta thấy trong khối logic tổ hợp đầu ra này, đầu ra chỉ phụ thuộc vào trạng thái hiện tại. Đó chính là máy Moore ở đây. Có câu hỏi không? Cái này chỉ phát hiện cạnh dương thôi à? Đúng vậy.
This only detects the positive. A good exercise you can do is maybe we can also do a negative edge detection. That will be a different change state.
Cái này chỉ phát hiện cạnh dương. Một bài tập hay các em có thể làm là phát hiện cả cạnh âm nữa. Khi đó sẽ là một sự thay đổi trạng thái khác.
You may either actually have more edges here, or you may have another different edge to signaling the zero to one transition number.
Các em có thể có thêm nhiều cạnh hơn ở đây, hoặc có một cạnh khác để báo hiệu sự chuyển từ không lên một.
Detecting a positive basically means if the bitstream comes in too fast, some of them might just get ignored, right?
Phát hiện cạnh dương về cơ bản nghĩa là nếu chuỗi bit đến quá nhanh, một số bit có thể bị bỏ qua, đúng không?
If the bitstream comes in too fast, some of them, oh, we are assuming the bitstream is coming at one bit per cycle. Yeah, so everything comes at one bit per cycle.
Nếu chuỗi bit đến quá nhanh, một số bit, à, ta đang giả sử chuỗi bit đến với tốc độ một bit mỗi chu kỳ. Vâng, nên mọi thứ đến với tốc độ một bit mỗi chu kỳ.
Everything is synchronized. Yeah, the input is synchronized with the machine. Yeah, if it's actually coming early, it will be ignored. Yeah, before the clock, before things get clocked. Good question.
Mọi thứ đều được đồng bộ. Vâng, đầu vào được đồng bộ với máy. Vâng, nếu nó đến sớm hơn thì sẽ bị bỏ qua. Vâng, trước xung nhịp, trước khi mọi thứ được chốt theo xung nhịp. Câu hỏi hay.
Yeah, this is considered purely digital, right? So we haven't, we don't consider, well, because it's already doing a zero to one detection, right?
Vâng, cái này được coi là thuần số, đúng không? Nên chúng ta không xét đến, à, vì nó vốn đã đang phát hiện chuyển từ không lên một rồi, đúng không?
Yeah, but to me, it's kind of like turning the analog to physical zero to one.
Vâng, nhưng với em, nó giống như việc biến tín hiệu tương tự thành không và một vật lý.
Because of what? It feels like there's an analog component?
Vì sao vậy? Em cảm thấy có một thành phần tương tự à?
Oh, it feels like an analog signal where things are. Well, I guess every signal eventually will be an analog signal, right? Every signal when we say signal are toggling, right?
À, em cảm thấy nó giống tín hiệu tương tự ở chỗ này. Thì tôi cho rằng cuối cùng mọi tín hiệu đều là tín hiệu tương tự, đúng không? Mọi tín hiệu mà ta nói đến đều đang chuyển mức, đúng không?
So basically transition from zero to one, Right? So if it goes a low level, you can view it as an analog signal.
Tức là về cơ bản chuyển từ không lên một, đúng không? Nên nếu xét ở mức thấp, em có thể xem nó là tín hiệu tương tự.
We talk about how we actually categorize different voltages as zero or one, right? So everything eventually is implemented using analog signals.
Ta đã nói về cách phân loại các điện áp khác nhau thành không hoặc một, đúng không? Vậy nên rốt cuộc mọi thứ đều được hiện thực bằng tín hiệu tương tự.
But for now, for our abstraction, we're ignoring the voltage transition from zero to one. We just assume everything is in binary, in digital space. Yeah. Any other questions?
Nhưng hiện tại, với mức trừu tượng của chúng ta, ta bỏ qua quá trình chuyển điện áp từ không lên một. Ta chỉ giả sử mọi thứ ở dạng nhị phân, trong không gian số. Vâng. Còn câu hỏi nào khác không?
OK, so that's Moore machine. One thing we can do, actually, one thing you'll notice is that we actually have a dedicated state for just signaling the observation, right?
Được rồi, đó là máy Moore. Có một điều ta có thể làm, một điều các em sẽ nhận thấy là ta có một trạng thái riêng chỉ để báo hiệu việc đã quan sát thấy, đúng không?
Another way to actually implement the same, again, the same spec, because the spec actually doesn't specify the timing behavior, right?
Một cách khác để hiện thực cùng đặc tả đó, vì đặc tả thực ra không quy định hành vi về thời gian, đúng không?
So instead of associating output to each state, we can actually associate output to each of the inputs or each of the edges during the transition.
Thay vì gắn đầu ra với mỗi trạng thái, ta có thể gắn đầu ra với mỗi đầu vào hay với mỗi cạnh trong lúc chuyển trạng thái.
So that's one way, because the behavior we're observing is basically we have received zero, and then the input switches to one, we receive the toggle, right?
Đó là một cách, vì hành vi ta quan sát về cơ bản là ta đã nhận được không, rồi đầu vào chuyển sang một, ta nhận được sự chuyển mức, đúng không?
We receive this, and we observe this pattern, right? So instead of having a dedicated state for this change state, we could actually associate output with input.
Ta nhận được điều này, và ta quan sát thấy mẫu này, đúng không? Vì vậy, thay vì dùng một trạng thái riêng cho việc chuyển trạng thái này, thực ra chúng ta có thể gắn đầu ra với đầu vào.
So we start from the zero state, right? We're observing zeros. And then whenever input turns into one, that basically means we observe this transition, right?
Vậy ta bắt đầu từ trạng thái không, đúng không? Ta đang quan sát các số không. Và khi nào đầu vào chuyển thành một, điều đó có nghĩa là ta quan sát thấy sự chuyển đổi này, đúng không?
So then we also set our output to be one. So that's another way to design the FSM that also meets the original spec, right? The original spec didn't specify the timing behavior.
Thì lúc đó ta cũng đặt đầu ra bằng một. Đó là một cách khác để thiết kế FSM mà vẫn đáp ứng đặc tả ban đầu, đúng không? Đặc tả ban đầu không quy định hành vi về thời gian.
So here, we basically say the output actually changes to one immediately after input changes to one. So with this, we actually have a different finite state machine.
Vì vậy ở đây, ta nói rằng đầu ra thay đổi thành một ngay sau khi đầu vào thay đổi thành một. Như vậy, ta có một máy trạng thái hữu hạn khác.
Instead of associating the output as part of the state, we actually associate the output as part of the edges. So the output basically changes whenever the input changes.
Thay vì gắn đầu ra như một phần của trạng thái, ta gắn đầu ra như một phần của các cạnh chuyển. Do đó đầu ra thay đổi mỗi khi đầu vào thay đổi.
So what are the implications of this style of design? So you will look at the time transition, the timing diagram, right? So here, we have two designs.
Vậy kiểu thiết kế này có những hệ quả gì? Ta hãy xem sự chuyển đổi theo thời gian, tức giản đồ thời gian, nhé. Ở đây ta có hai thiết kế.
One is Moore machine here, solution A, and one is Mealy machine, right? So we see here, we see the timing transitions. We want to observe the zero to one transition, right?
Một là máy Moore ở đây, lời giải A, và một là máy Mealy, đúng không? Ở đây ta thấy các chuyển đổi theo thời gian. Ta muốn quan sát sự chuyển từ không sang một, đúng không?
So this is our input, and this is the transition we want to observe, right? We start from Moore machine, right? So Moore machine will only change output when state changes.
Đây là đầu vào của ta, và đây là sự chuyển đổi mà ta muốn quan sát, đúng không? Ta bắt đầu với máy Moore nhé. Máy Moore chỉ thay đổi đầu ra khi trạng thái thay đổi.
And state only changes when clock is triggered, right? Because state is registered, right? State only changes when clock is triggered.
Và trạng thái chỉ thay đổi khi xung clock kích hoạt, đúng không? Vì trạng thái được lưu trong thanh ghi, đúng không? Trạng thái chỉ thay đổi khi clock kích hoạt.
So even input actually changes pretty early, but we haven't actually, the clock, we haven't observed the positive edge of the clock yet.
Vì vậy, dù đầu vào thay đổi khá sớm, nhưng ta vẫn chưa thấy, cạnh lên của clock.
So the state won't change until the clock actually toggles. So here, for output of the Moore machine, we only change after the clock. So everything is synchronous.
Nên trạng thái sẽ không đổi cho đến khi clock thực sự chuyển. Do đó, với đầu ra của máy Moore, ta chỉ thấy thay đổi sau clock. Vậy mọi thứ đều đồng bộ.
Even if input actually changes earlier, the output actually, it doesn't change until the clock is toggled, because that's when actually our register has changed. So that's the behavior of Moore machine.
Dù đầu vào có thay đổi sớm hơn, đầu ra vẫn không thay đổi cho đến khi clock chuyển, vì đó là lúc thanh ghi của ta thay đổi. Đó là hành vi của máy Moore.
Everything is synchronous with respect to clock, to the clock signal. Versus a Mealy machine, right? We talked about earlier, the Mealy machine output is only dependent on input, right?
Mọi thứ đều đồng bộ với clock, với tín hiệu clock. Còn máy Mealy thì sao? Ta đã nói trước đó, đầu ra của máy Mealy chỉ phụ thuộc vào đầu vào, đúng không?
So whenever input changes, output actually follows immediately, right? So you also see the pattern here. The output of the Mealy machine, whenever the input changes, it goes together with the output.
Nên khi đầu vào thay đổi, đầu ra thay đổi theo ngay lập tức, đúng không? Bạn cũng thấy quy luật này ở đây. Đầu ra của máy Mealy, mỗi khi đầu vào thay đổi, nó thay đổi cùng với đầu ra.
Sorry, so whenever the input changes, output goes together with the input, right?
Xin lỗi, mỗi khi đầu vào thay đổi, đầu ra thay đổi cùng với đầu vào, đúng không?
So we see the Mealy machine actually the output set to one immediately, but after certain combinational logic delay, after the input changes, it doesn't need to wait until the state actually transitions.
Vậy ta thấy ở máy Mealy, đầu ra được đặt bằng một ngay lập tức, nhưng sau một độ trễ logic tổ hợp nhất định, sau khi đầu vào thay đổi, nó không cần đợi đến khi trạng thái thực sự chuyển.
So that's the difference. So Moore machine are actually synchronous with clock, but Mealy machine is actually asynchronous with clock, because it's actually a combinational logic, depends on the input.
Đó là điểm khác biệt. Vậy máy Moore thực ra đồng bộ với xung clock, còn máy Mealy thực ra không đồng bộ với xung clock, vì nó thực chất là logic tổ hợp, phụ thuộc vào đầu vào.
Whenever the input changes, output actually changes. Make sense? Questions?
Bất cứ khi nào đầu vào thay đổi, đầu ra cũng thay đổi. Hiểu chứ? Có câu hỏi nào không?
Okay, so that's basically a high-level idea, right? What are the differences between Moore's and Mealy's, and what are the, especially from timing perspective, right?
Được rồi, về cơ bản đó là ý tưởng ở mức tổng quát, đúng không? Sự khác biệt giữa máy Moore và máy Mealy là gì, và đặc biệt là xét từ góc độ định thời thì sao, đúng không?
We actually summarize all the differences, right? Moore's machine and Mealy's machine.
Chúng ta tóm tắt tất cả các điểm khác biệt, giữa máy Moore và máy Mealy.
Again, the high level, it's really just how this combinational logic works, whether we're only dependent on the current state or dependent on both current state and input state.
Một lần nữa, ở mức tổng quát, vấn đề chỉ là khối logic tổ hợp này hoạt động thế nào, tức là nó chỉ phụ thuộc vào trạng thái hiện tại hay phụ thuộc vào cả trạng thái hiện tại và đầu vào.
You remember what we saw earlier, like Moore's machine actually has three states, because we actually need to dedicate a transition state, right, because that has a different output.
Các bạn còn nhớ ví dụ trước đó, máy Moore có ba trạng thái, vì chúng ta cần dành riêng một trạng thái chuyển tiếp, đúng không, do trạng thái đó có đầu ra khác.
Whereas a Mealy machine, we can actually just stay with two states, because the edges, the output actually changes with edges. We can just use different edges to represent different transitions.
Còn với máy Mealy, chúng ta chỉ cần giữ hai trạng thái, vì đầu ra thay đổi theo các cạnh chuyển. Chúng ta chỉ cần dùng các cạnh khác nhau để biểu diễn các chuyển tiếp khác nhau.
So generally, Mealy machine has fewer number of states, but also the outputs are asynchronous, right? You may be wondering, like, okay, so fewer states and these actually transition faster, right?
Nên nói chung, máy Mealy có số trạng thái ít hơn, nhưng đầu ra cũng không đồng bộ, đúng không? Có thể các bạn tự hỏi, vậy thì ít trạng thái hơn và chuyển tiếp nhanh hơn, như thế chẳng phải là tốt sao?
Isn't that a good thing, right?
Sometimes it's a good thing, but sometimes it actually could potentially lead to actually wrong or very, like, very hard to optimize timing behaviors, because it's basically extend the critical path from the previous stage to the current stage, because everything is actually combinational, right?
Đôi khi đúng là tốt, nhưng đôi khi nó có thể dẫn đến hành vi định thời sai hoặc rất khó tối ưu, vì về cơ bản nó kéo dài đường tới hạn từ tầng trước sang tầng hiện tại, vì mọi thứ đều là logic tổ hợp, đúng không?
Whenever we talk about time frequency, we're basically talking about the critical path right here.
Bất cứ khi nào nói về tần số, về cơ bản chúng ta đang nói về đường tới hạn ngay chỗ này.
Now, because things are asynchronous, our critical paths actually become longer, and especially you will actually, the signal doesn't actually hold for long enough, it may also lead to actually error-prone logic for the subsequent design.
Vì mọi thứ không đồng bộ, đường tới hạn của chúng ta trở nên dài hơn, và đặc biệt là tín hiệu có thể không được giữ đủ lâu, điều này cũng có thể gây ra logic dễ lỗi cho phần thiết kế phía sau.
One potential issue is if we actually have very short output in our design.
Một vấn đề tiềm ẩn là nếu thiết kế của chúng ta có đầu ra rất ngắn.
For example, in this example, we are designing, so this is actually a Mealy machine. We're designing a Mealy machine. The input actually toggles, changes shortly before the clock, right?
Ví dụ, trong ví dụ này, chúng ta đang thiết kế, đây thực ra là một máy Mealy. Chúng ta đang thiết kế một máy Mealy. Đầu vào đảo trạng thái, thay đổi ngay trước xung clock, đúng không?
So here, as we mentioned, because it's a Mealy machine, so this is when input change, and this is when clock changes, right?
Ở đây, như đã nói, vì đây là máy Mealy, nên đây là lúc đầu vào thay đổi, và đây là lúc clock thay đổi, đúng không?
Because a Miele machine, so first, and the output actually depends on both the current state and input, right? So in this case, whenever the input changes, I change a different color, output changes, right?
Vì là máy Mealy, nên trước tiên, đầu ra phụ thuộc vào cả trạng thái hiện tại và đầu vào, đúng không? Vậy trong trường hợp này, bất cứ khi nào đầu vào thay đổi, tôi đổi sang màu khác, đầu ra thay đổi, đúng không?
Because output is dependent on input, but shortly after the clock also toggles. Again, output is actually dependent on both input and the current state.
Vì đầu ra phụ thuộc vào đầu vào, nhưng ngay sau đó clock cũng đảo trạng thái. Một lần nữa, đầu ra phụ thuộc vào cả đầu vào và trạng thái hiện tại.
Whenever clock changes, current state also changes, right?
Mỗi khi xung clock thay đổi thì trạng thái hiện tại cũng thay đổi, đúng không?
So it's possible output actually will, may need to come back shortly after because it's actually dependent on both factors, and there's not a lot of room for output to transition because first input changes, and then after the clock, the current state changes, and then the output actually needs to toggle again.
Vì vậy có thể đầu ra sẽ, có thể phải thay đổi trở lại ngay sau đó vì nó phụ thuộc vào cả hai yếu tố, và đầu ra không có nhiều thời gian để chuyển trạng thái, vì trước tiên đầu vào thay đổi, rồi sau xung clock thì trạng thái hiện tại thay đổi, và sau đó đầu ra lại phải đảo trạng thái một lần nữa.
So we may just have a very short signal for the output. This can be very challenging for the next stage, right?
Vì vậy ta có thể chỉ có một tín hiệu đầu ra rất ngắn. Điều này có thể rất khó khăn cho tầng tiếp theo, đúng không?
So because output is generated, like we're looking for patterns, whenever it's actually triggered, we actually ask the downstream logic to do some computation, right?
Vì đầu ra được tạo ra, ví dụ như ta đang tìm kiếm các mẫu, mỗi khi nó thực sự được kích hoạt, ta yêu cầu logic phía sau thực hiện một số phép tính, đúng không?
If this output is too short, it's actually possible, like what we discussed earlier, it's too short, it's actually possible the later logic, the downstream logic, is actually not able to catch the signal, right?
Nếu đầu ra này quá ngắn, thì có thể xảy ra, như ta đã thảo luận trước đó, nó quá ngắn nên có thể logic phía sau, tức logic hạ nguồn, không bắt được tín hiệu, đúng không?
It's just too short because it's actually dependent on both factors. So this could be actually challenging. It's funny, for this particular logic, we did generate the signal correctly.
Nó đơn giản là quá ngắn vì nó phụ thuộc vào cả hai yếu tố. Vì vậy điều này có thể gây khó khăn. Thú vị là, với khối logic này, ta đã tạo ra tín hiệu một cách chính xác.
But let's say there is another combinational logic afterwards, right? If the signal is too short, exactly what Vemba asked earlier, right?
Nhưng giả sử phía sau còn một mạch logic tổ hợp khác, đúng không? Nếu tín hiệu quá ngắn, đúng như điều Vemba đã hỏi lúc nãy, đúng không?
So it's actually too short, we actually don't actually get to sample this signal in the later stage, it may actually trigger some errors there.
Tức là nó quá ngắn, thì ở tầng sau ta không lấy mẫu được tín hiệu này, và có thể gây ra lỗi ở đó.
So that's basically some of the downsides of the Mealy machine we actually need to be aware of. Generally, it's up to you. It's different styles.
Đó về cơ bản là một số nhược điểm của máy Mealy mà ta cần lưu ý. Nói chung là tùy bạn. Đó là các phong cách khác nhau.
I generally prefer to write Moore machine, just like everything is synchronous, it's a lot easier to think about.
Tôi thường thích viết máy Moore hơn, vì mọi thứ đều đồng bộ, nên dễ suy nghĩ hơn nhiều.
And the number of states, basically the number of bits, especially with space logic, is actually less important these days.
Còn số trạng thái, tức số bit, nhất là với logic về không gian, thì ngày nay ít quan trọng hơn.
We don't need to actually optimize that part, about the number of bits, number of registers we use.
Ta không cần tối ưu phần đó, tức số bit, số thanh ghi mà ta dùng.
It's actually a lot safer to just do Moore machine instead of worrying about this kind of weird timing behavior here. That's actually very hard to catch when you actually do a debugging, right?
An toàn hơn nhiều nếu chỉ dùng máy Moore thay vì lo lắng về kiểu hành vi định thời kỳ lạ này. Lỗi đó rất khó phát hiện khi bạn gỡ lỗi, đúng không?
But you still, at a high level, you need to understand whatever the other differences.
Nhưng dù sao, ở mức tổng quát, bạn vẫn cần hiểu những khác biệt kia.
So we, especially for this kind of scenario, if actually the signal is too short, it may be a problem for later logic. Question?
Vì vậy, nhất là với kiểu tình huống này, nếu tín hiệu quá ngắn, nó có thể là vấn đề cho logic phía sau. Có câu hỏi không?
Oh, this outline and the bottom line. So it's basically, this is out, let's say this is out two. So this is out two.
À, đường viền này và đường dưới cùng. Về cơ bản, đây là out, giả sử đây là out hai. Vậy đây là out hai.
So this is basically some combinational logic after the out, right? So that's basically what we're talking about. This out needs to be actually fed into some downstream task, another combinational logic, right?
Vậy đây về cơ bản là một mạch logic tổ hợp phía sau out, đúng không? Đó chính là điều ta đang nói tới. Out này cần được đưa vào một tác vụ phía sau, một mạch logic tổ hợp khác, đúng không?
So the first thing we need to be aware of is that this is basically, so there's another register, another clock, another clock before.
Vậy điều đầu tiên cần lưu ý là về cơ bản đây là, có một thanh ghi khác, một clock khác, một clock khác ở trước.
So basically the entire, both two combinational logic are part of the critical path, right? Because the signal is actually propagating throughout the combinational. That's the first challenging one mentioned earlier.
Vậy về cơ bản toàn bộ, cả hai khối logic tổ hợp đều nằm trên đường tới hạn, đúng không? Vì tín hiệu thực sự lan truyền qua toàn bộ phần logic tổ hợp. Đó là thách thức đầu tiên đã nói ở trên.
The combination, the critical path is much longer. The second challenge is basically the signal is very short, especially after it's propagated.
Logic tổ hợp, đường tới hạn dài hơn nhiều. Thách thức thứ hai là tín hiệu rất ngắn, đặc biệt là sau khi nó đã lan truyền.
Maybe we won't be able to even catch the signal in the next sampling stage.
Có thể chúng ta thậm chí không bắt được tín hiệu ở tầng lấy mẫu tiếp theo.
Johnny?
Johnny?
Yeah, that's a good question, right? So Johnny is wondering whether we can actually manually extend the signal. So a lot of time, if we go back to this example, right?
Vâng, đó là một câu hỏi hay, đúng không? Johnny đang thắc mắc liệu chúng ta có thể kéo dài tín hiệu bằng tay hay không. Nhiều khi, nếu quay lại ví dụ này, đúng không?
So one thing people do, instead of actually go through this second, the downstream combinational logic hierarchy, they actually get this out signal.
Một việc người ta làm là, thay vì đi qua khối thứ hai này, tức là phần logic tổ hợp phía sau, họ lấy tín hiệu out này.
Then they actually add a register first Before this goes to the second combinational logic. So it's basically clocked afterwards. So then we can actually clock this signal, we can still sample the signal.
Rồi họ thêm một thanh ghi trước trước khi tín hiệu đi vào khối logic tổ hợp thứ hai. Tức là nó được lấy xung nhịp sau đó. Như vậy ta có thể lấy xung nhịp cho tín hiệu này, và vẫn lấy mẫu được tín hiệu.
So that's something other people do, another way to potentially work around it. But yeah, there's still this fundamental longer. That is basically become another version of Moore machine, right?
Đó là việc mà một số người làm, một cách khác để có thể khắc phục vấn đề. Nhưng vẫn còn hạn chế cơ bản là độ trễ dài hơn. Về cơ bản nó trở thành một dạng khác của máy Moore, đúng không?
Yeah. So actually in this particular example, right, adding a clock, adding another register still doesn't work, right? Because it's just too short. The next clock won't be triggered actually until the next cycle.
Vâng. Thực ra trong ví dụ cụ thể này, việc thêm một xung nhịp, thêm một thanh ghi nữa vẫn không hiệu quả, đúng không? Vì tín hiệu quá ngắn. Xung nhịp tiếp theo sẽ không được kích hoạt cho đến chu kỳ sau.
Well, it depends on how long this signal is. It's very subtle, right? It all depends on the timing, right? How long this signal actually holds before the clock, right?
Còn tùy tín hiệu này dài bao lâu. Nó rất tinh tế, đúng không? Tất cả phụ thuộc vào thời gian, đúng không? Tín hiệu này giữ được bao lâu trước xung nhịp, đúng không?
That would actually trigger, that would actually dictate whether the next clock actually holds that. So yeah, so that's why we get to the very subtle.
Điều đó sẽ kích hoạt, điều đó sẽ quyết định xung nhịp tiếp theo có giữ được tín hiệu đó hay không. Vì vậy đây là chỗ rất tinh tế.
We actually need to double check to make sure whether it actually meets the setup and hold time constraint. So that's the tricky part with Mealy machine because of timing optimization.
Chúng ta cần kiểm tra kỹ để chắc chắn rằng nó thỏa mãn ràng buộc về thời gian thiết lập và thời gian giữ. Đó là phần khó của máy Mealy do việc tối ưu thời gian.
And we'll talk later. Setup time violation can actually be handled by running it slower. So we just have a slower clock. But hold time violation is actually very hard to fix, right?
Và chúng ta sẽ nói sau. Vi phạm thời gian thiết lập có thể xử lý bằng cách chạy chậm hơn. Tức là ta chỉ cần xung nhịp chậm hơn. Nhưng vi phạm thời gian giữ thì rất khó sửa, đúng không?
So again, so that's another reason, especially we're less sensitive with the number of states, the number of bits in our register. Moore machine is a lot safer with timing optimization.
Vậy đó là một lý do nữa, đặc biệt khi ta ít nhạy cảm hơn với số trạng thái, số bit trong thanh ghi của mình. Máy Moore an toàn hơn nhiều khi tối ưu thời gian.
Okay. So we talk a lot about Moore and the Mealy machine. Let's take a look at a couple of examples.
Được rồi. Chúng ta đã nói nhiều về máy Moore và máy Mealy. Hãy xem một vài ví dụ.
So we have four different representations of binary state machines. We have both state transition diagrams, all different circles and edges.
Chúng ta có bốn cách biểu diễn khác nhau của các máy trạng thái nhị phân. Chúng ta có các sơ đồ chuyển trạng thái, gồm nhiều hình tròn và cạnh khác nhau.
We also have gate level representations, right?
Chúng ta cũng có các biểu diễn ở mức cổng, đúng không?
By looking at these state transition diagrams and the gate level representation, what are the FSMs here representing Moore machine from the four examples?
Bằng cách nhìn vào các trạng thái này chuyển trạng thái và sơ đồ ở mức cổng, thì FSM nào trong bốn ví dụ này biểu diễn máy Moore?
Let's take a 30 seconds break and you can think about it and also discuss with your colleagues.
Chúng ta nghỉ 30 giây để suy nghĩ và cũng thảo luận với các bạn cùng lớp.
Sorry, I had a question. I had a question about the previous. I saw your question in chat. I'll go back to that in a minute after the quiz, after the basic quiz. Okay.
Xin lỗi, em có một câu hỏi. Em có câu hỏi về phần trước. Thầy đã thấy câu hỏi của em trong khung chat. Thầy sẽ quay lại câu đó sau một phút nữa, sau bài kiểm tra nhanh này. Được chứ.
And one more thing. Can you like quickly say what is the setup time or hold time violations? Because I kind of forgot. We'll get to that in, I guess, a couple more lectures.
Và còn một điều nữa. Thầy có thể nói nhanh vi phạm thời gian thiết lập hay thời gian giữ là gì không? Vì em hơi quên rồi. Chúng ta sẽ học phần đó trong khoảng vài bài giảng nữa.
Okay. So we have four examples. Any guesses? Any solutions, Omar?
Được rồi. Chúng ta có bốn ví dụ. Ai có dự đoán nào không? Omar, em trả lời thế nào?
A and B. Why?
A và B. Tại sao?
The reason why it's so easy is because the input is not directly connected to the output. Right, right, right. So Omar thinks A and B. Any other ideas?
Lý do dễ nhận ra là vì đầu vào không nối trực tiếp với đầu ra. Đúng, đúng. Omar cho rằng là A và B. Còn ý kiến nào khác không?
Everyone thinks A and B. Great, right. So as Omar suggested, right, we compare A and B, right? So Moore machines basically output only depends on the state, right, instead of input.
Mọi người đều nghĩ là A và B. Tốt, đúng rồi. Như Omar đã gợi ý, chúng ta hãy so sánh A và B nhé? Máy Moore về cơ bản có đầu ra chỉ phụ thuộc vào trạng thái, chứ không phụ thuộc vào đầu vào.
Here for A, output is associated with state. But for B, output actually depends on the input, right? So that's a very important feature of Moore machine.
Ở A, đầu ra gắn với trạng thái. Nhưng ở B, đầu ra thực ra phụ thuộc vào đầu vào, đúng không? Đó là một đặc điểm rất quan trọng của máy Moore.
Similarly, we look at the logic, the state level representation, right? So for B, it's very clean. All the output only depends on the current state.
Tương tự, chúng ta xem biểu diễn ở mức logic, mức trạng thái nhé? Ở B thì rất rõ ràng. Toàn bộ đầu ra chỉ phụ thuộc vào trạng thái hiện tại.
For C here, the output path actually includes everything here, right? So it depends on both the current state and also the inputs, right?
Còn ở C, đường dẫn tới đầu ra bao gồm tất cả mọi thứ ở đây, đúng không? Nên nó phụ thuộc vào cả trạng thái hiện tại lẫn các đầu vào.
So A and D in this example are Moore machines. So Mohammed on Zoom asked why the critical path is actually longer in Mealy machine, right?
Vậy A và D trong ví dụ này là các máy Moore. Bạn Mohammed trên Zoom hỏi tại sao đường tới hạn lại dài hơn trong máy Mealy.
So you will actually just use this C as an example here, right? We think about the critical path. It actually propagates, the longest path actually propagates through A all the way to out, right?
Chúng ta cứ dùng C làm ví dụ ở đây nhé. Hãy nghĩ về đường tới hạn. Nó thực sự lan truyền, đường dài nhất lan truyền từ A đi suốt tới đầu ra, đúng không?
Everything is combinational. It's also potentially possible there's some combinational logic before. There is also some potential combinational after, right? So everything is not separated by clock.
Tất cả đều là tổ hợp. Cũng có thể có một số logic tổ hợp ở phía trước. Và cũng có thể có một số logic tổ hợp ở phía sau. Vì vậy mọi thứ không bị tách ra bởi xung nhịp.
Everything is actually fully combinational. So the critical path is longer. Mohammed also asked earlier, the setup time, why it's actually related.
Tất cả hoàn toàn là tổ hợp. Do đó đường tới hạn dài hơn. Trước đó Mohammed cũng hỏi về thời gian thiết lập, vì sao nó liên quan.
So when it comes to register, we'll actually talk about it in a couple of weeks.
Khi nói đến thanh ghi, chúng ta sẽ nói về nó trong vài tuần nữa.
Basically, before the signal arrives, we want to actually make sure the signal actually holds long enough so the register has enough time to sample the signal. We call it setup time.
Về cơ bản, trước khi tín hiệu đến, chúng ta muốn đảm bảo tín hiệu được giữ ổn định đủ lâu để thanh ghi có đủ thời gian lấy mẫu tín hiệu. Ta gọi đó là thời gian thiết lập.
And when the signal is here, the signal also needs to hold long enough, propagate long enough so that the next stage register can actually catch the signal correctly.
Và khi tín hiệu đã ở đây, tín hiệu cũng cần được giữ đủ lâu, lan truyền đủ lâu để thanh ghi ở tầng kế tiếp có thể bắt được tín hiệu một cách chính xác.
We call it hold time, right? So with register, the setup, we need enough time for the register to hold the value and also to sample the value.
Chúng ta gọi đó là thời gian giữ (hold time), đúng không? Vậy với thanh ghi, về thời gian thiết lập (setup), chúng ta cần đủ thời gian để thanh ghi giữ được giá trị và cũng để lấy mẫu giá trị đó.
So that's also become very important when we think about timing propagation. We'll talk, for ASIC lab students, I think you folks already started exploring some of that in your maybe lab tool.
Vì vậy điều này cũng trở nên rất quan trọng khi chúng ta xét đến việc lan truyền thời gian. Với các bạn học phòng thí nghiệm ASIC, tôi nghĩ các bạn đã bắt đầu tìm hiểu một phần của việc này trong công cụ ở phòng thí nghiệm của các bạn.
You'll do actually simulation. You already see how we set up the different setup time and the hold time in the labs.
Các bạn sẽ thực hiện mô phỏng. Các bạn đã thấy cách chúng ta thiết lập các thời gian setup khác nhau và thời gian hold trong các buổi thí nghiệm.
For FPGA students, folks, it's OK, we'll actually go also deeper into this topic in a couple of weeks. Lucy?
Với các bạn học FPGA, không sao cả, chúng ta cũng sẽ đi sâu hơn vào chủ đề này trong vài tuần nữa. Lucy?
Oh, yeah, yeah. So this is input slash output. Yeah, yeah, yeah. Good question. So typically, we do for Mealy machines, input slash output.
À, vâng, vâng. Đây là đầu vào gạch chéo đầu ra. Vâng, đúng rồi. Câu hỏi hay. Thông thường, với máy Mealy, chúng ta viết đầu vào gạch chéo đầu ra.
So before the slash is input and after the slash is output.
Phần trước dấu gạch chéo là đầu vào và phần sau dấu gạch chéo là đầu ra.
OK, so Mealy and Moore, Moore and Mealy machines, very important two different ways of designing FSMs. Any other questions, comments, thoughts?
Được rồi, máy Mealy và Moore, Moore và Mealy, là hai cách thiết kế FSM khác nhau rất quan trọng. Còn câu hỏi, nhận xét hay ý kiến nào khác không?
OK, just the different ways of building hardware, right? So it's pretty straightforward. So we talk about the two differences, different ways of building the machine.
Được rồi, đó chỉ là những cách xây dựng phần cứng khác nhau, đúng không? Vì vậy nó khá đơn giản. Chúng ta đã nói về hai sự khác biệt, hai cách khác nhau để xây dựng máy.
We'll also go over how we actually express that in Verilog, because eventually, we actually want to implement it.
Chúng ta cũng sẽ xem cách biểu diễn điều đó trong Verilog, vì cuối cùng chúng ta muốn hiện thực hóa nó.
So before we mentioned, generally, the thought process of implementing an FSM, we specify, we understand the function. You follow the discussion earlier. Sometimes the function actually doesn't specify the timing behavior.
Như trước đó đã nhắc, nói chung, quy trình tư duy khi hiện thực một FSM là chúng ta đặc tả, chúng ta hiểu chức năng. Các bạn đã theo dõi phần thảo luận trước đó. Đôi khi chức năng không quy định hành vi về thời gian.
So we can actually do more on the Mealy. If we have a more detailed specification, We actually need to choose one or another. So spec is very important.
Vì vậy chúng ta có thể làm được nhiều hơn với Mealy. Nếu có đặc tả chi tiết hơn, chúng ta cần chọn cách này hoặc cách kia. Vì vậy đặc tả rất quan trọng.
What is the expected behavior? And then we start the transition, state transition diagram, the circles and the edges, to figure out how things actually transition.
Hành vi mong đợi là gì? Sau đó chúng ta bắt đầu vẽ sơ đồ chuyển trạng thái, gồm các hình tròn và các cạnh, để xác định các chuyển đổi diễn ra như thế nào.
And then add the encodings for different states and different inputs so that we can actually derive basically the representation for different combinational logic to calculate the next state and also the output.
Rồi thêm các mã hóa cho các trạng thái khác nhau và các đầu vào khác nhau để chúng ta có thể suy ra về cơ bản là biểu diễn của các mạch tổ hợp khác nhau để tính trạng thái kế tiếp và cả đầu ra.
When we're actually building things, eventually we actually want to code this finite state machine in Verilog, in our program, so that we can actually implement it directly.
Khi xây dựng thực tế, cuối cùng chúng ta muốn viết mã máy trạng thái hữu hạn này bằng Verilog, trong chương trình của chúng ta, để có thể hiện thực nó trực tiếp.
We do a lot of paper and pencil exercises, but eventually we actually need to implement it.
Chúng ta làm nhiều bài tập trên giấy bằng bút chì, nhưng cuối cùng chúng ta cần hiện thực nó.
We'll talk about some of the common patterns you will see and some of the recommended coding style we recommend for this class. We'll talk about how we use parameters to represent the encoding.
Chúng ta sẽ nói về một số mẫu phổ biến mà các bạn sẽ gặp và một số phong cách viết mã được khuyến nghị cho lớp này. Chúng ta sẽ nói về cách dùng tham số để biểu diễn mã hóa.
I mentioned the states need to be encoded. We'll also talk about two separate always blocks.
Tôi đã nói là các trạng thái cần được mã hóa. Chúng ta cũng sẽ nói về hai khối always riêng biệt.
Remember, when we talk about finite state machine, always three components: registers, and combinational logic, and two types of combinational logic, to calculate the next state and to calculate the output.
Hãy nhớ, khi nói về máy trạng thái hữu hạn, luôn có ba thành phần: thanh ghi, và logic tổ hợp, và hai loại logic tổ hợp, để tính trạng thái kế tiếp và để tính đầu ra.
Generally, when we think about finite state machine, especially with Verilog implementation, we need at least two always blocks. The always blocks can be implemented in parallel because they are actually hardware.
Nói chung, khi nghĩ về máy trạng thái hữu hạn, đặc biệt là với cách cài đặt bằng Verilog, ta cần ít nhất hai khối always. Các khối always có thể được cài đặt song song vì thực chất chúng là phần cứng.
One always block, always at posedge, to signal the state transition because we are actually doing a sequential logic. We actually need to do the state transition.
Một khối always, always tại posedge, để báo hiệu chuyển trạng thái vì ta đang làm logic tuần tự. Ta thực sự cần thực hiện việc chuyển trạng thái.
Another always block is actually for a combinational logic to calculate both the, well, it depends on the logic, calculate both the next states and also the output.
Khối always còn lại dành cho logic tổ hợp để tính cả à, tùy vào logic, tính cả trạng thái kế tiếp lẫn đầu ra.
We have used the always block to do the register and also the combinational logic.
Ta đã dùng khối always để tạo thanh ghi và cả logic tổ hợp.
We'll talk about how we actually implement Moore versus Mealy and different coding styles that we can do. We think about Verilog, we already talked about this.
Chúng ta sẽ nói về cách cài đặt Moore so với Mealy và các phong cách viết mã khác nhau mà ta có thể dùng. Khi nghĩ về Verilog, chúng ta đã nói về điều này rồi.
We start from state transition diagram with our circuit implementation. Basically, we have state registers. We want to have an always block to actually update our registers.
Ta bắt đầu từ sơ đồ chuyển trạng thái cùng với cách cài đặt mạch. Về cơ bản, ta có các thanh ghi trạng thái. Ta muốn có một khối always để cập nhật các thanh ghi.
We have a combinational logic to actually calculate the next state and also the output.
Ta có một khối logic tổ hợp để tính trạng thái kế tiếp và cả đầu ra.
Depends on the Moore and Mealy machine, the output can be either only depend on the current state or depend on both the input and the current state. That's basically what we want to implement.
Tùy vào máy Moore hay Mealy, đầu ra có thể chỉ phụ thuộc vào trạng thái hiện tại hoặc phụ thuộc vào cả đầu vào và trạng thái hiện tại. Về cơ bản đó là điều ta muốn cài đặt.
With that, let's take a look at an example. We have, again, figuring out the state transition diagram is very useful just to understand what are the states you want to implement.
Với điều đó, hãy xem một ví dụ. Một lần nữa, việc xác định sơ đồ chuyển trạng thái rất hữu ích để hiểu các trạng thái mà bạn muốn cài đặt.
Then you can basically do the conversion, really implement this state transition diagram into Verilog. A couple of things to highlight. Whenever you get to the hardware, reset is very important.
Sau đó bạn về cơ bản có thể chuyển đổi, cài đặt sơ đồ chuyển trạng thái này thành Verilog. Có vài điều cần nhấn mạnh. Khi làm việc với phần cứng, reset rất quan trọng.
You need to tell the hardware what's the beginning state. If nothing happened, you need to reset to a default state so that we know where things start.
Bạn cần cho phần cứng biết trạng thái bắt đầu là gì. Nếu chưa có gì xảy ra, bạn cần reset về một trạng thái mặc định để ta biết mọi thứ bắt đầu từ đâu.
Generally, especially for this kind of thing, we start from the idle state or the initial default state. That's where our finite state machine starts. We talk about encoding.
Nói chung, đặc biệt với loại bài này, ta bắt đầu từ trạng thái idle hoặc trạng thái khởi đầu mặc định. Đó là nơi máy trạng thái hữu hạn của ta bắt đầu. Ta nói về mã hóa.
We talk about actually different ways that we can do encoding, like binary encoding, one-hot encoding. Especially these days, we're less sensitive with a number of bits that we have in the implementation.
Ta nói về các cách khác nhau để mã hóa, như mã hóa nhị phân, mã hóa one-hot. Đặc biệt là ngày nay, ta ít nhạy cảm hơn với số bit dùng trong cách cài đặt.
You can actually pick different encoding you like that you think actually implement the state. For example, we have three states here. We can actually use this as our encoding to encode different states.
Bạn có thể chọn cách mã hóa mà bạn thích, cách mà bạn nghĩ là cài đặt trạng thái tốt. Ví dụ, ở đây ta có ba trạng thái. Thực ra chúng ta có thể dùng cách này làm phép mã hóa để mã hóa các trạng thái khác nhau.
Then we basically need state register. We actually want to calculate the current state and the next state so we can actually do assignment. Sometimes, we already talked about that.
Sau đó, về cơ bản chúng ta cần một thanh ghi trạng thái. Chúng ta muốn tính trạng thái hiện tại và trạng thái kế tiếp để có thể thực hiện phép gán. Đôi khi, chúng ta đã nói về chuyện này rồi.
Reg is basically whenever we use always block, any of the output need to be a reg type.
Reg về cơ bản là: bất cứ khi nào dùng khối always, mọi đầu ra đều cần có kiểu reg.
They may not be actually implemented into a register, but we need to have a reg type here. We talk about two always block.
Chúng có thể không thực sự được hiện thực thành một thanh ghi, nhưng ở đây ta vẫn cần dùng kiểu reg. Chúng ta nói về hai khối always.
Generally, you will see actually when you read or we implement your logic. First, We have a sequential logic where we actually do our state transition.
Nhìn chung, bạn sẽ thấy điều này khi đọc hoặc khi hiện thực logic của mình. Đầu tiên, chúng ta có logic tuần tự, nơi thực hiện chuyển trạng thái.
Whenever clock triggers, we actually move on, transition to the next state. The current state actually transitions to the next state. We talk about reset. Always reset to a default state.
Mỗi khi xung clock kích, chúng ta tiến tới, chuyển sang trạng thái kế tiếp. Trạng thái hiện tại chuyển sang trạng thái kế tiếp. Chúng ta nói về reset. Luôn reset về một trạng thái mặc định.
Typically, we reset to our idle state. Always have an initial state. That's the first always block for state transition.
Thông thường, ta reset về trạng thái idle. Luôn phải có một trạng thái ban đầu. Đó là khối always đầu tiên, dùng cho chuyển trạng thái.
We'll also have another always block, always star, for our combinational logic.
Chúng ta cũng có một khối always khác, always star, cho logic tổ hợp.
Here, for combinational logic, we basically calculate what the next state should be based on the current input and the current state, and what the output should be.
Ở đây, với logic tổ hợp, về cơ bản chúng ta tính xem trạng thái kế tiếp phải là gì dựa trên đầu vào hiện tại và trạng thái hiện tại, và đầu ra phải là gì.
In this example here, we basically can use our case statement here. We have different scenarios, and whichever state we are in.
Trong ví dụ này, về cơ bản chúng ta có thể dùng câu lệnh case. Chúng ta có các trường hợp khác nhau, tùy theo trạng thái đang ở.
Then, we can use begin, end to have a case clause and then to specify different behaviors.
Sau đó, chúng ta có thể dùng begin, end để tạo một mệnh đề case rồi chỉ định các hành vi khác nhau.
Looking at the operation that we're doing inside each block, is this a Moore machine or Mealy machine?
Nhìn vào thao tác mà chúng ta làm bên trong mỗi khối, đây là máy Moore hay máy Mealy?
Omer. So you will look at the change. The output only depends on the state.
Omer. Vậy bạn sẽ nhìn vào sự thay đổi. Đầu ra chỉ phụ thuộc vào trạng thái.
Once we see the state, we actually go to the output. We basically assign output directly. The output only depends on the current state.
Khi đã biết trạng thái, chúng ta đi thẳng tới đầu ra. Về cơ bản chúng ta gán đầu ra trực tiếp. Đầu ra chỉ phụ thuộc vào trạng thái hiện tại.
Then, the next state depends on both the current state and input. Here, we use if-else to specify different edges. Different edges, we're specifying different transitions. All right.
Còn trạng thái kế tiếp phụ thuộc vào cả trạng thái hiện tại và đầu vào. Ở đây, chúng ta dùng if-else để chỉ định các cạnh khác nhau. Các cạnh khác nhau, tức là chúng ta chỉ định các chuyển trạng thái khác nhau. Được rồi.
This is also a Moore machine, where in each case statement, we associate output directly with the current state. Then, we use if-else statement to specify different input transitions.
Đây cũng là một máy Moore, trong đó ở mỗi câu lệnh case, chúng ta gắn đầu ra trực tiếp với trạng thái hiện tại. Sau đó, chúng ta dùng câu lệnh if-else để chỉ định các chuyển trạng thái theo đầu vào khác nhau.
This is how we actually express that in a Moore machine. You may actually also be wondering, oh, so we have a question.
Đây là cách chúng ta biểu diễn điều đó trong một máy Moore. Có thể bạn cũng đang thắc mắc, ồ, chúng ta có một câu hỏi.
Someone is asking, how come actually blocking statement is used here instead of non-blocking statement? Should we use blocking statement here or non-blocking statement here?
Có người hỏi, tại sao ở đây lại dùng câu lệnh blocking thay vì câu lệnh non-blocking? Ở đây nên dùng câu lệnh blocking hay non-blocking?
Brendan? No? Okay, Omer. I don't think it will matter. We can use either if we want.
Brendan? Không ạ? Được, Omer. Tôi nghĩ nó không quan trọng. Muốn thì chúng ta có thể dùng cái nào cũng được.
At the end of the day, we will only evaluate one of the cases, right? George? I think we want it to be purely combinational. We want it to be sequential.
Cuối cùng thì chúng ta chỉ đánh giá một trong các trường hợp, đúng không? George? Tôi nghĩ chúng ta muốn nó thuần túy là logic tổ hợp. Chúng ta muốn nó là mạch tuần tự.
We want one of the assignments to then nominate the further identifier. Right, right. So I'll tell me.
Chúng ta muốn một trong các phép gán đó chỉ định định danh tiếp theo. Đúng, đúng. Vậy bạn cứ nói cho tôi.
There's no input variable on the right-hand side.
Không có biến đầu vào ở vế phải.
And Ethan? So we wouldn't use a non-blocking statement. So if we said else next state, we could use that current state for the next state though to create new states.
Còn Ethan? Vậy là chúng ta sẽ không dùng câu lệnh non-blocking. Vậy nếu ta viết else next state, thì ta vẫn có thể dùng current state để tạo ra các trạng thái mới cho next state.
Right. So here, we actually separate. I think all of you mentioned different aspects. But first, as Ethan mentioned, we are actually doing the next state assignment. We're not doing the current state assignment.
Đúng. Vậy ở đây, chúng ta thực sự tách riêng. Tôi nghĩ các bạn đều đã nhắc đến những khía cạnh khác nhau. Nhưng trước hết, như Ethan đã nói, ở đây chúng ta đang thực hiện phép gán cho next state. Chúng ta không gán cho current state.
We already did our current state assignment earlier in this. And this is using non-blocking statement here, right?
Phép gán current state đã được làm ở phần trước rồi. Và ở đó dùng câu lệnh non-blocking, đúng không?
So when we talk about our sequential logic, we already used non-blocking statement here. Remember, we use non-blocking statement to describe the sequential logic behaviors, right?
Vậy khi nói về logic tuần tự, chúng ta đã dùng câu lệnh non-blocking ở đây. Hãy nhớ rằng ta dùng câu lệnh non-blocking để mô tả hành vi của logic tuần tự, đúng không?
So that's why we want to separate, have two clean parallax. So for the sequential logic, we have actually used non-blocking statement.
Đó là lý do ta muốn tách ra, có hai phần song song rõ ràng. Với logic tuần tự, chúng ta đã dùng câu lệnh non-blocking.
So here, this is when we actually do the next state to current state transition. This is where we actually update the register.
Vậy ở đây là lúc chúng ta thực hiện chuyển từ next state sang current state. Đây là chỗ chúng ta cập nhật thanh ghi.
Next, what we are doing here with this always block, we're doing a fully combinational. So everything here is actually combinational. And Ethan is right. We are actually not touching the current state anymore.
Tiếp theo, với khối always này, chúng ta làm hoàn toàn tổ hợp. Vậy mọi thứ ở đây đều là tổ hợp. Và Ethan nói đúng. Chúng ta không còn động đến current state nữa.
We are describing a combinational logic to actually update the next state. So everything here is basically blocking because we use blocking statement to actually describe combinational logic in always block.
Chúng ta đang mô tả một logic tổ hợp để cập nhật next state. Vậy mọi thứ ở đây về cơ bản là blocking vì ta dùng câu lệnh blocking để mô tả logic tổ hợp trong khối always.
Remember. Although next state and state, they're both declared as reg. But actually, only state is reg, but next state is a wire. Like when there are synthesis. Right.
Hãy nhớ. Dù next state và state đều được khai báo là reg. Nhưng thực ra chỉ có state là reg, còn next state là một wire. Khi tổng hợp thì như vậy. Đúng.
So therefore, since next state is not reg, so we cannot use the non-blocking. Is that a valid argument to make, or I'm on the wrong way? I think you are.
Vì vậy, do next state không phải là reg, nên ta không thể dùng non-blocking. Lập luận đó có đúng không, hay tôi đang đi sai hướng? Tôi nghĩ là bạn đang sai.
I think you're closing the loop, but there's a little bit like a chicken and egg problem, Right? I think the intention is we only have one register, right?
Tôi nghĩ bạn đang khép được vòng lại, nhưng có một chút vấn đề kiểu con gà và quả trứng, đúng không? Tôi nghĩ ý đồ là chúng ta chỉ có một thanh ghi, đúng không?
Intention is we only have one register, and that's basically we only have one register.
Ý đồ là chúng ta chỉ có một thanh ghi, và về cơ bản là chỉ có một thanh ghi.
This is a clock, right? The input of the register is the next state, and the output is the current state, right? We only update whenever the clock triggers.
Đây là một xung clock, đúng không? Đầu vào của thanh ghi là next state, và đầu ra là current state, đúng không? Chúng ta chỉ cập nhật mỗi khi clock kích hoạt.
And this next state is basically a combinational logic with a wire. The reason we declare it as a reg, because it's being assigned in the always block later, right?
Còn next state về cơ bản là một logic tổ hợp với một wire. Lý do ta khai báo nó là reg là vì nó được gán trong khối always ở phía sau, đúng không?
So there is some parallax syntax in play here, but eventually there's only one, I guess, two bits, right? Two bits register, because every state are two bits, right?
Vậy có một số quy tắc cú pháp song song đang tác động ở đây, nhưng cuối cùng chỉ có một, tôi đoán là hai bit, đúng không? Thanh ghi hai bit, vì mỗi trạng thái có hai bit, đúng không?
Current state is the one actually being, is the output of the register, right? But next state is really a wire that's actually being computed in the combinational logic.
Trạng thái hiện tại chính là đầu ra của thanh ghi, đúng không? Còn trạng thái kế tiếp thực chất là một wire được tính toán trong logic tổ hợp.
So we use non-blocking statement in this always block describing the sequential logic, but everything here we're actually just describing a pure combinational path, so that's why we are using blocking statement.
Vì vậy chúng ta dùng câu lệnh non-blocking trong khối always mô tả logic tuần tự này, còn mọi thứ ở đây thực chất chỉ mô tả một đường thuần tổ hợp, nên đó là lý do chúng ta dùng câu lệnh blocking.
Good question, Yihang. So we talk about Moore machine, right? We talk about this is Moore machine. You may wonder, we talk about both, right?
Câu hỏi hay, Yihang. Chúng ta đang nói về máy Moore, đúng không? Chúng ta nói đây là máy Moore. Có thể bạn thắc mắc, vì chúng ta nói về cả hai loại, đúng không?
How do we actually express the logic in a Mealy machine? So this is the same example, the edge detection example, right?
Vậy làm sao biểu diễn logic trong máy Mealy? Đây vẫn là ví dụ đó, ví dụ phát hiện cạnh, đúng không?
So now we're talking about two different ways of implementing that in Verilog instead of just paper and pencil, right? Again, you will see the first part is the same, the sequential logic.
Bây giờ chúng ta nói về hai cách hiện thực ví dụ đó bằng Verilog thay vì chỉ dùng giấy và bút, đúng không? Một lần nữa, bạn sẽ thấy phần đầu là giống nhau, tức là logic tuần tự.
There is always a register update. Both Mealy machine and Moore machine are describing sequential logic, right? They're describing different FSM, right?
Luôn có một phần cập nhật thanh ghi. Cả máy Mealy và máy Moore đều mô tả logic tuần tự, đúng không? Chúng mô tả các FSM khác nhau, đúng không?
So we always have our register update and we always use our always block to describe our register update and we are using non-blocking statement, right?
Vì vậy lúc nào chúng ta cũng có phần cập nhật thanh ghi và luôn dùng khối always để mô tả phần cập nhật thanh ghi đó và dùng câu lệnh non-blocking, đúng không?
So that block is actually shared, which also makes sense if you think about what's actually being done with Moore and the Mealy machine, right?
Như vậy khối đó thực ra được dùng chung, điều này cũng hợp lý nếu bạn nghĩ xem máy Moore và máy Mealy thực sự làm gì, đúng không?
The only difference is the combinational logic to calculate the output, right? That's a key difference.
Khác biệt duy nhất là logic tổ hợp để tính đầu ra, đúng không? Đó là khác biệt chính.
The, we always have state machine, we always have a combinational logic to calculate the next state, and the only difference is for the output, whether it's dependent on input or not.
Chúng ta luôn có máy trạng thái, luôn có một logic tổ hợp để tính trạng thái kế tiếp, và khác biệt duy nhất nằm ở đầu ra: có phụ thuộc vào đầu vào hay không.
So state transition, we always have the first sequential logic always block, right? So next, we have two different always at star, which are used to describe different combinational logic, right?
Về chuyển trạng thái, chúng ta luôn có khối always logic tuần tự đầu tiên, đúng không? Tiếp theo, chúng ta có hai khối always @(*) khác nhau, dùng để mô tả các logic tổ hợp khác nhau, đúng không?
So combinational logic, again, we have different case statements signaling different states. Before, Omer mentioned, right, so you will look at this, the output is only dependent on the state, right?
Còn với logic tổ hợp, một lần nữa, chúng ta có các câu lệnh case khác nhau cho các trạng thái khác nhau. Lúc nãy Omer có nhắc, bạn nhìn vào đây, đầu ra chỉ phụ thuộc vào trạng thái, đúng không?
Once we figure out which state we are in, we basically specify our output directly. Let's take a look at how we do output assignment in a Mealy machine.
Khi đã xác định được mình đang ở trạng thái nào, ta chỉ việc gán đầu ra trực tiếp. Hãy xem cách gán đầu ra trong máy Mealy.
So this is our zero state, right? So it's actually very intuitive.
Đây là trạng thái không của chúng ta, đúng không? Nó thực ra rất trực quan.
You will actually have our, it's always good to have our state transition diagram right next to us, right?
Bạn sẽ có luôn nên để sơ đồ chuyển trạng thái ngay bên cạnh, đúng không?
Even, you know, before you write your Verilog, just put it there so that we know what kind of transition we want to implement, right?
Ngay cả trước khi viết Verilog, cứ đặt nó ở đó để biết mình muốn hiện thực những chuyển trạng thái nào, đúng không?
So here, since we're talking about Mealy machine, the output actually depends on both input and the current state, right?
Ở đây, vì đang nói về máy Mealy, đầu ra thực sự phụ thuộc vào cả đầu vào lẫn trạng thái hiện tại, đúng không?
So we figure out what our current state is, and then we check the input value, right?
Vậy chúng ta xác định trạng thái hiện tại là gì, rồi chúng ta kiểm tra giá trị đầu vào, đúng không?
Whether input is one or zero, that will dictate not only the next state, but also our output, right? So you can also see the output assignment is also reflected.
Dù đầu vào là một hay không, điều đó sẽ quyết định không chỉ trạng thái kế tiếp mà cả đầu ra của chúng ta, đúng không? Vậy các bạn cũng thấy phần gán đầu ra cũng được thể hiện ở đây.
The difference between Moore and Mealy machine, the way we do assignment is also reflected in our combinational always block when we actually do the assignment.
Sự khác biệt giữa máy Moore và máy Mealy, cách chúng ta thực hiện phép gán cũng được thể hiện trong khối always tổ hợp khi chúng ta thực sự làm phép gán.
So in Mealy machine, output is not only just associated with state, but also associated with the current input, which is different in the way we think about Moore machine when we implement it in Verilog.
Vậy với máy Mealy, đầu ra không chỉ gắn với trạng thái, mà còn gắn với đầu vào hiện tại, khác với cách chúng ta nghĩ về máy Moore khi cài đặt nó bằng Verilog.
So that's the high-level differences. Again, it's actually the same.
Đó là những khác biệt ở mức cao. Nhưng về cơ bản, nó vẫn giống nhau.
We always talk about three components for finite-state machines, three components, state registers, Two combinational logics: one combinational logic to calculate next state, one combinational logic to calculate output.
Chúng ta luôn nói về ba thành phần của máy trạng thái hữu hạn, ba thành phần: các thanh ghi trạng thái, và hai khối logic tổ hợp: một khối logic tổ hợp để tính trạng thái kế tiếp, một khối logic tổ hợp để tính đầu ra.
For Moore versus Mealy, two out of the three components are the same. The only thing different is how output is calculated, right?
Giữa Moore và Mealy, hai trong ba thành phần là giống nhau. Điểm khác duy nhất là cách tính đầu ra, đúng không?
So we talk about how we see, how we capture the differences in state transition diagram, whether output is associated with state or not; in gate-level representation, right?
Vậy chúng ta đã nói về cách nhìn thấy, cách thể hiện những khác biệt đó trong sơ đồ chuyển trạng thái, tức là đầu ra có gắn với trạng thái hay không; và trong biểu diễn mức cổng, đúng không?
Whether we see a combinational path from input to output directly. Now we also see how it's reflected in Verilog, right?
Tức là có thấy một đường tổ hợp đi thẳng từ đầu vào đến đầu ra hay không. Giờ chúng ta cũng thấy điều đó được thể hiện thế nào trong Verilog, đúng không?
Whether we actually, when we do the combinational logic implementation, whether the output is assigned only based on the current state, or it's actually assigned based on both the current state and input.
Tức là khi chúng ta cài đặt logic tổ hợp, đầu ra chỉ được gán dựa trên trạng thái hiện tại, hay được gán dựa trên cả trạng thái hiện tại lẫn đầu vào.
So that's our actual example. Johnny?
Đó là ví dụ thực tế của chúng ta. Johnny?
Yeah, so x basically means undetermined, undecided. So I generally, this, if I'm implementing this, I would actually assign it to be zero instead of x. So x basically means uninitialized, right?
Vâng, x về cơ bản nghĩa là chưa xác định, chưa quyết định. Nên nói chung, nếu tôi cài đặt cái này, tôi sẽ gán nó bằng 0 thay vì x. x về cơ bản nghĩa là chưa được khởi tạo, đúng không?
We don't really know, we don't know the value of this. So it depends on the implementation.
Chúng ta thực sự không biết giá trị của nó. Nên điều này phụ thuộc vào cách cài đặt.
I generally don't reset to x's because whenever you have x's, the best thing is x actually propagate, right?
Nói chung tôi không reset về x, vì hễ có x thì điều tệ nhất là x sẽ lan truyền, đúng không?
You actually don't know where x is actually propagating, and that may actually change the functionality of your later functions. Ethan? I guess, what is x output when you simply assign it to that?
Bạn không biết x đang lan truyền đến đâu, và điều đó có thể làm thay đổi chức năng của các hàm phía sau. Ethan? Em nghĩ, đầu ra x là gì khi ta chỉ gán nó như vậy?
It's just unknown. You don't actually know. Randomly, yeah, yeah. It is not determined, right? Because we're not, so that's another thing, always set things clearly.
Nó chỉ là không xác định. Bạn không thực sự biết. Ngẫu nhiên, đúng vậy. Nó không được xác định, đúng không? Vì chúng ta không, đó là một điều nữa: luôn đặt giá trị một cách rõ ràng.
In this example, I think we have some history with the slides, but if I'm actually doing the implementation, I will just set it to zero. It's just clean.
Trong ví dụ này, tôi nghĩ có một chút lịch sử với các slide, nhưng nếu tôi thực sự đang cài đặt, tôi sẽ đặt nó bằng 0. Như vậy gọn gàng.
We have a default behavior, we know it, and we just set it to a value that we are sure. So I generally avoid setting things to x, just always set to zero or one.
Chúng ta có một hành vi mặc định, chúng ta biết rõ nó, và chỉ đặt nó về một giá trị mà ta chắc chắn. Nên nói chung tôi tránh đặt giá trị là x, cứ luôn đặt là 0 hoặc 1.
You always need to specify a default behavior. Good question. Okay, so we talked about sequential logic. We start from combinational logic, now we transition to sequential logic, right?
Bạn luôn cần chỉ định một hành vi mặc định. Câu hỏi hay. Được rồi, vậy là chúng ta đã nói về logic tuần tự. Chúng ta bắt đầu từ logic tổ hợp, giờ chuyển sang logic tuần tự, đúng không?
Sequential logic, very important. We have this memory component. Sequential logic can also be implemented as finite state machine. Again, those three components, I keep repeating myself, right?
Logic tuần tự rất quan trọng. Chúng ta có thành phần bộ nhớ này. Logic tuần tự cũng có thể được triển khai dưới dạng máy trạng thái hữu hạn. Lại là ba thành phần đó, tôi cứ lặp đi lặp lại, đúng không?
Register, capturing the state, two combinational logics to calculate the next state and the output, and the Moore and Mealy, two out of those three components stay the same.
Thanh ghi, lưu giữ trạng thái, hai khối logic tổ hợp để tính trạng thái kế tiếp và đầu ra, và với Moore và Mealy, hai trong ba thành phần đó vẫn giữ nguyên.
The only thing different is how output is actually calculated, right? Whether output is only dependent on the current state or the output is actually dependent on both the current state and the input, right?
Điểm khác duy nhất là cách tính đầu ra, đúng không? Đầu ra chỉ phụ thuộc vào trạng thái hiện tại hay đầu ra phụ thuộc vào cả trạng thái hiện tại và đầu vào, đúng không?
So that's the key differences with Moore and Mealy. Both of them are describing finite state machine and basically sequential logic. Any questions, thoughts?
Đó là điểm khác biệt chính giữa Moore và Mealy. Cả hai đều mô tả máy trạng thái hữu hạn và về cơ bản là logic tuần tự. Có câu hỏi hay ý kiến gì không?
Okay, well, we will actually do all our designs later in our labs or things that we will discuss later will basically be different finite state machines.
Được rồi, chúng ta sẽ thực hiện mọi thiết kế sau này trong các bài lab, hay những thứ mà chúng ta sẽ bàn sau này về cơ bản sẽ là các máy trạng thái hữu hạn khác nhau.
So do actually go through a lot of exercise how we can actually use this and implement it, implement finite state machines to represent complex logic.
Vì vậy hãy làm thật nhiều bài tập về cách sử dụng và triển khai điều này, triển khai máy trạng thái hữu hạn để biểu diễn logic phức tạp.
Announcement, not a lot of announcement today. One thing we realized is that there are just a lot of threads on Ed.
Thông báo, hôm nay không có nhiều thông báo. Một điều chúng tôi nhận thấy là có rất nhiều chủ đề trên Ed.
I'm not sure if Ed is less compact compared to PS, maybe just my layout, right? Just like always, so many things going on. So our staff is pretty creative.
Tôi không chắc Ed có kém gọn hơn PS hay không, có thể chỉ là do bố cục của tôi thôi, đúng không? Như mọi khi, có quá nhiều thứ đang diễn ra. Đội ngũ của chúng tôi khá sáng tạo.
I think they have a count, like an index thread that give you pointers to all the threads.
Tôi nghĩ họ có một bảng tổng hợp, như một chủ đề chỉ mục chỉ cho bạn tới tất cả các chủ đề.
So we like to have this mega thread for lab and homework, just easier to consolidate all the questions.
Chúng tôi muốn có chủ đề tổng hợp này cho lab và bài tập về nhà, để dễ gom tất cả các câu hỏi vào một chỗ hơn.
And if you don't find it, you can find basically the mega, mega thread that has all the links to actually get to that. And feel free to post questions there.
Và nếu bạn không tìm thấy, bạn có thể tìm chủ đề tổng hợp lớn, chủ đề lớn có tất cả các liên kết để đến đó. Và cứ thoải mái đăng câu hỏi ở đó.
So we have a consolidated place to actually address all the questions. Our staff is pretty good catching up all the discussions on Ed.
Như vậy chúng ta có một nơi tập trung để giải đáp tất cả các câu hỏi. Đội ngũ của chúng tôi theo dõi các thảo luận trên Ed khá tốt.
So if you have any questions, feel free to post it on Ed. Homework 2 is due this week. We released the homework last week. Homework 2 is due.
Nên nếu có câu hỏi nào, cứ đăng lên Ed. Bài tập về nhà 2 đến hạn nộp trong tuần này. Chúng tôi đã đăng bài tập tuần trước. Bài tập 2 đến hạn.
We have a new homework, basically K-map and finite state machine, especially the Verilog implementation this week. So it will be out probably later today or early tomorrow morning.
Tuần này có bài tập mới, về cơ bản là bìa Karnaugh và máy trạng thái hữu hạn, đặc biệt là phần triển khai bằng Verilog. Có lẽ nó sẽ được đăng vào cuối ngày hôm nay hoặc sáng sớm mai.
So keep an eye on it. But again, those homeworks are just a way to give you a chance to review the material. They are not very time-consuming.
Nên hãy để ý nhé. Nhưng một lần nữa, những bài tập này chỉ là cách để cho các bạn cơ hội ôn lại tài liệu. Chúng không tốn quá nhiều thời gian.
You should be able to finish it in a couple hours, just every week. And we discuss different things. You'll see all the different things during discussion.
Bạn có thể hoàn thành trong vài giờ mỗi tuần. Và chúng ta thảo luận những nội dung khác nhau. Bạn sẽ thấy tất cả những nội dung khác nhau trong buổi thảo luận.
But also, it's good to use homework as an enforcing function to see whether you understand different materials. Those are the general announcements.
Nhưng cũng nên dùng bài tập về nhà như một công cụ thúc đẩy để xem bạn có hiểu các nội dung khác nhau hay không. Đó là những thông báo chung.
Any questions or any feedback you have regarding the class or things you're wondering, things we can improve?
Các bạn có câu hỏi hay phản hồi nào về lớp học không, hay có điều gì thắc mắc, điều gì chúng tôi có thể cải thiện không?
OK. Well, let us know. Let us know if you have any questions. So Mohammed is saying lab queue is too long. Is that common? What do you think?
Được rồi. Cứ cho chúng tôi biết nhé. Có câu hỏi gì thì cứ nói. Mohammed nói hàng chờ ở lab quá dài. Điều đó có phổ biến không? Các bạn nghĩ sao?
I see. I see. Oh, really? Last time I heard Tuesday lab is super busy. So now it's Friday lab is...
Tôi hiểu rồi. Ồ, thật vậy sao? Lần trước tôi nghe nói lab thứ Ba cực kỳ đông. Giờ thì lab thứ Sáu lại...
Oh. I see. I see. Yeah, I think we are also learning through the semester.
Ồ. Tôi hiểu rồi. Vâng, tôi nghĩ chúng tôi cũng đang học hỏi dần trong suốt học kỳ.
So that's why we have the queue system.
Vì vậy chúng tôi mới có hệ thống hàng chờ.
The reason we have more office hours on Monday and Wednesday is because we have a lot of labs on the rest of the days and all the office hours and labs.
Lý do chúng tôi có nhiều giờ tiếp sinh viên hơn vào thứ Hai và thứ Tư là vì các ngày còn lại có rất nhiều buổi lab, cùng với các giờ tiếp sinh viên và lab.
We don't want to have, like, parallel office hours and labs to make things even more confusing. So let's give it a try.
Chúng tôi không muốn giờ tiếp sinh viên và lab diễn ra song song, vì như vậy sẽ càng thêm rối. Vậy hãy thử cách này.
We still want to strongly recommend you go to your own lab session. And you can also do checkout actually during office hours.
Chúng tôi vẫn rất khuyến khích các bạn đến đúng buổi lab của mình. Và thực ra các bạn cũng có thể làm checkout trong giờ tiếp sinh viên.
It's actually easier to get a slot, especially get a machine, get a workstation during office hours, compared to going to another lab session, because those students, they also need basically machine access.
Thực ra sẽ dễ có chỗ hơn, nhất là dễ có máy, có trạm làm việc trong giờ tiếp sinh viên so với đến buổi lab khác, vì các sinh viên ở đó cũng cần dùng máy.
So if possible, you can go to, if you want to just catch up with GSA, we do have 10 different office hours, right? Go to the office hours to get things checked out.
Nên nếu được, nếu các bạn muốn bắt kịp tiến độ với GSA, chúng tôi có 10 giờ tiếp sinh viên khác nhau, đúng không? Hãy đến giờ tiếp sinh viên để được kiểm tra bài.
We don't want to make our lab too crowded because the students who are actually supposed to attend those lab sessions have high priority. If things get worse, let us know.
Chúng tôi không muốn lab quá đông vì những sinh viên thực sự phải tham dự các buổi lab đó được ưu tiên cao. Nếu tình hình tệ hơn, hãy cho chúng tôi biết.
We do want to, we haven't enforced too heavily because it doesn't seem so crowded yet.
Chúng tôi chưa siết quá chặt vì hiện tại có vẻ chưa quá đông.
But if things become too crowded, we'll basically enforce only students who are enrolled in this session can actually come to the session, especially the first two hours. But office hours are there.
Nhưng nếu trở nên quá đông, chúng tôi sẽ chỉ cho phép những sinh viên đã đăng ký buổi đó được đến buổi đó, nhất là trong hai giờ đầu. Nhưng vẫn có giờ tiếp sinh viên.
So always go to the office hour and you have the full week to actually finish the, you don't need to get things done by Friday, right?
Vì vậy cứ đến giờ tiếp sinh viên, và các bạn có cả tuần để hoàn thành, không cần phải xong trước thứ Sáu, đúng không?
You have a full week, on the weekend actually, to wrap things up.
Các bạn có cả tuần, kể cả cuối tuần, để hoàn tất.
Well, definitely let also the TAs know if you think certain sessions are getting too crowded and we can start doing, observing the traffic a little bit more.
Chắc chắn hãy báo cho các trợ giảng biết nếu các bạn thấy buổi nào quá đông và chúng tôi có thể bắt đầu theo dõi lượng người kỹ hơn một chút.
Also another thing, it's also very important, especially for this class, like talking to other students actually doing the lab. Sometimes you may not run into this problem, but others run into it.
Một điều nữa cũng rất quan trọng, nhất là với lớp này, là trò chuyện với các sinh viên khác đang làm lab. Đôi khi bạn không gặp vấn đề này, nhưng người khác lại gặp.
It's like a pair programming, right? So getting more experience seeing what other issues that other students run into, it's also helpful, right?
Giống như lập trình theo cặp vậy, đúng không? Vì thế có thêm kinh nghiệm khi thấy những vấn đề khác mà các sinh viên khác gặp phải cũng rất hữu ích, đúng không?
So we will actually, let me actually announce next time more formally, but generally we actually have extra credit for students who are not only just like doing what they're supposed to do, but also helping others or having other debugging or answering questions on Ed, right?
Lần sau tôi sẽ thông báo chính thức hơn, nhưng nhìn chung chúng tôi có điểm cộng cho những sinh viên không chỉ làm những gì mình phải làm, mà còn giúp đỡ người khác, hoặc cùng người khác gỡ lỗi hoặc trả lời câu hỏi trên Ed, đúng không?
All those things actually generate more discussion, actually also good to actually get to know other students a little bit more, see different design styles.
Tất cả những việc đó thực ra tạo ra thêm nhiều thảo luận, và cũng giúp các bạn hiểu biết thêm về các bạn khác một chút, thấy được những phong cách thiết kế khác nhau.
I mentioned earlier, there's not just like one right answer, right? There are different ways to do that. So seeing more designs is also helpful.
Như tôi đã nói trước đó, không phải chỉ có một đáp án đúng duy nhất, đúng không? Có nhiều cách khác nhau để làm. Vì vậy xem thêm nhiều thiết kế cũng rất hữu ích.
And so that's also a good experience to actually attending the lab and discuss with other, your fellow students. Other feedback? My question is, how will the extra credit work?
Và đó cũng là một trải nghiệm tốt khi các bạn đến buổi thực hành và trao đổi với các bạn cùng lớp. Còn phản hồi nào khác không? Câu hỏi của em là điểm cộng sẽ hoạt động thế nào?
Like how much are you expected to, how much is expected to boost our grade? So let me come back this next week with a more detail.
Ví dụ, dự kiến điểm cộng sẽ nâng điểm của chúng em lên bao nhiêu? Để tuần sau tôi quay lại với chi tiết hơn.
So every semester we do that, but every semester the enrollment is different.
Học kỳ nào chúng tôi cũng làm vậy, nhưng mỗi học kỳ số lượng sinh viên đăng ký lại khác nhau.
Yeah, but we do extra credit more like 5 at most about that way to encourage participation, both in class in discussion and also in the lab.
Vâng, nhưng điểm cộng thường vào khoảng 5 là tối đa, theo hướng đó, để khuyến khích sự tham gia, cả trong lớp, khi thảo luận, lẫn trong buổi thực hành.
Well, I'll come back with more details next week. Okay. Any other thoughts?
Được rồi, tuần sau tôi sẽ nói chi tiết hơn. Ổn chứ? Còn ý kiến nào khác không?
Okay, good. So we talk a lot about Verilog and also finite state machine, right? So next we're going to get to basically the finite state machine of the class, right?
Được rồi, tốt. Chúng ta đã nói nhiều về Verilog và cả máy trạng thái hữu hạn, đúng không? Tiếp theo chúng ta sẽ đi đến về cơ bản là máy trạng thái hữu hạn của cả môn học, đúng không?
How we actually implement a very complex processor, in particular RISC-V processor as a finite state machine during this semester.
Tức là cách chúng ta hiện thực một bộ xử lý rất phức tạp, cụ thể là bộ xử lý RISC-V, dưới dạng máy trạng thái hữu hạn trong học kỳ này.
So I talk about different layers of the design. Verilog is really a method, right? To help us to implement the hardware, but we need a spec, right?
Tôi đã nói về các tầng khác nhau của thiết kế. Verilog thực chất là một phương pháp, đúng không? để giúp chúng ta hiện thực phần cứng, nhưng chúng ta cần một đặc tả, đúng không?
Before we're just doing, for example, this edge detection, but the final spec for the project is basically implementing a RISC-V processor.
Trước đây chúng ta chỉ làm, ví dụ, bài phát hiện biên này, nhưng đặc tả cuối cùng của dự án về cơ bản là hiện thực một bộ xử lý RISC-V.
So we're going to talk a little bit more about RISC-V, I say, and today's discussion will mostly focus on the datapath component.
Vì vậy chúng ta sẽ nói thêm một chút về RISC-V, và buổi hôm nay chủ yếu tập trung vào thành phần datapath.
We'll talk about how we stitch different components together and to build a full pipeline next week. So for this audience, especially here at Berkeley, we are very proud of RISC-V.
Chúng ta sẽ nói về cách ghép các thành phần khác nhau lại với nhau để xây dựng một đường ống hoàn chỉnh vào tuần sau. Với các bạn ở đây, đặc biệt là ở Berkeley, chúng ta rất tự hào về RISC-V.
This is, I say, an open source ISA, I say, actually invented here at Berkeley that actually really transformed the way we think about computing industry.
Đây là một ISA mã nguồn mở, được phát minh ngay tại Berkeley, và đã thực sự thay đổi cách chúng ta nghĩ về ngành công nghiệp điện toán.
That's also another way to think about your impact, right? Things that you do during your school or university could actually change the world.
Đó cũng là một cách khác để nghĩ về tác động của các bạn, đúng không? Những việc các bạn làm khi còn đi học hoặc ở trường đại học có thể thay đổi thế giới.
And this is, I guess, 10, 15 years ago when people think about open source, I say, they never think this would actually be something so important.
Cách đây khoảng 10, 15 năm, khi mọi người nghĩ về mã nguồn mở, họ chưa bao giờ nghĩ nó sẽ trở nên quan trọng đến vậy.
But now looking back, right, we just talked about early this lecture, right?
We're talking about three, I say, heterogeneous platforms: x86, commercial one, not open; Arm, commercial one, not open; then RISC-V, right, open source and invented here at Berkeley.
Nhưng giờ nhìn lại, đúng không, chúng ta vừa nói ở đầu bài giảng này, chúng ta nói về ba nền tảng không đồng nhất: x86, loại thương mại, không mở; Arm, loại thương mại, không mở; rồi RISC-V, mã nguồn mở và được phát minh ngay tại Berkeley.
So very important, has a big impact in today's world and will be even more important moving forward with all the different contributors from all over the world.
Vì vậy rất quan trọng, có tác động lớn trong thế giới ngày nay và sẽ còn quan trọng hơn nữa trong tương lai nhờ nhiều người đóng góp từ khắp nơi trên thế giới.
So it's originally really designed, so I think Patterson actually has either an article or slide deck actually talking about how they started the RISC-V project.
Vậy nó ban đầu thực sự được thiết kế và tôi nghĩ thầy Patterson có một bài viết hoặc một bộ slide nói về việc họ đã bắt đầu dự án RISC-V như thế nào.
They actually started thinking about building an ISA for this class.
Thực ra họ bắt đầu nghĩ đến việc xây dựng một ISA cho chính lớp học này.
This is how we actually have an ISA that is simple enough, clean enough that we can actually teach students, share all the different trade-offs in the ISA design, and also implementable, and also have actually software at the end of the semester, right?
Nhờ vậy chúng ta có một ISA đủ đơn giản, đủ gọn gàng để có thể dạy cho sinh viên, chia sẻ mọi sự đánh đổi trong thiết kế ISA, và cũng có thể triển khai được, và đến cuối học kỳ còn có cả phần mềm chạy được, đúng không?
So that's basically how they started. I think that either Chris Dyer or Patterson actually has a paragraph saying like, oh, when they first started, they thought this would be just a summer project.
Về cơ bản họ đã bắt đầu như vậy. Tôi nghĩ là Chris Dyer hoặc Patterson có viết một đoạn đại loại như là, lúc mới bắt đầu, họ nghĩ đây chỉ là một dự án hè.
They had like a couple of grad students working together to figure out something. And then next fall semester, we can introduce it to the 151 students.
Có vài nghiên cứu sinh cùng làm việc để tìm ra một thứ gì đó. Rồi học kỳ mùa thu năm sau, có thể giới thiệu nó cho sinh viên lớp 151.
And then, probably that day, they eventually turned into this multi-year effort in building this open source ecosystem. So that's very impressive to see how much they actually have achieved, right?
Và rồi, có lẽ từ hôm đó, nó dần trở thành một nỗ lực kéo dài nhiều năm nhằm xây dựng hệ sinh thái mã nguồn mở này. Thật ấn tượng khi thấy họ đã đạt được nhiều đến thế, đúng không?
So we're mostly talking about ISA, but again, we mentioned the different layer abstractions. RISC-V is an ISA that is actually fully open source, all the specs are out.
Vậy là chúng ta chủ yếu đang nói về ISA, nhưng như đã đề cập, có nhiều tầng trừu tượng khác nhau. RISC-V là một ISA hoàn toàn mã nguồn mở, toàn bộ đặc tả đều được công bố.
There are a lot of implementations publicly available. We have our internal, we have our Berkeley version. There are a lot of commercial versions, actually hardware that implements the RISC-V ISA.
Có rất nhiều bản triển khai công khai. Chúng ta có bản nội bộ, có bản của Berkeley. Có rất nhiều bản thương mại, tức là phần cứng triển khai ISA RISC-V.
At the end of the semester, you folks will also implement your own RISC-V processor that is compatible with the ISA, right?
Đến cuối học kỳ, các bạn cũng sẽ tự triển khai bộ xử lý RISC-V của riêng mình tương thích với ISA này, đúng không?
So this is ISA level, everything's open, and you can build your own hardware that implements the ISA.
Vậy ở cấp độ ISA, mọi thứ đều mở, và bạn có thể xây dựng phần cứng của riêng mình triển khai ISA đó.
CS61C goes through all the different ISAs and also the components in greater detail. They also have the videos publicly available.
CS61C đi qua tất cả các ISA khác nhau và cả các thành phần một cách chi tiết hơn. Họ cũng công khai các video bài giảng.
If you, some of you haven't taken 61C before and want to do a deeper dive, you can also check out their website. We also have a link on our website.
Nếu một số bạn chưa học 61C và muốn tìm hiểu sâu hơn, các bạn cũng có thể xem trang web của họ. Chúng tôi cũng có đường liên kết trên trang web của lớp.
In this class, we'll basically go through things pretty quickly. It's more like a review session, so that it's still fresh for you with all the different components.
Trong lớp này, về cơ bản chúng ta sẽ đi khá nhanh. Nó giống một buổi ôn tập hơn, để các bạn vẫn còn nhớ rõ tất cả các thành phần.
But if you want to actually go a lot deeper, a lot slower, you can check out 61C videos.
Nhưng nếu bạn muốn đi sâu hơn nhiều, chậm hơn nhiều, bạn có thể xem các video 61C.
So, when it comes to the processor design, right? We see these layers of abstraction again, right? So RISC-V is really, we talk about the RISC-V spec, right? The RISC-V spec.
Vậy, khi nói đến thiết kế bộ xử lý, đúng không? Chúng ta lại thấy các tầng trừu tượng này, đúng không? RISC-V thực sự là, chúng ta nói về đặc tả RISC-V, đúng không? Đặc tả RISC-V.
We'll talk about what is the instruction, how the instruction is specified, what are the different fields, and how they are supposed to be interpreted.
Chúng ta sẽ nói về lệnh là gì, lệnh được đặc tả như thế nào, có những trường nào, và chúng phải được diễn giải ra sao.
And you will actually go through the RISC-V spec from time to time, especially during your implementation. That's always the ground truth.
Và các bạn sẽ thỉnh thoảng xem lại đặc tả RISC-V, đặc biệt là trong quá trình triển khai. Đó luôn là chuẩn mực để đối chiếu.
Whenever I teach this class, I also check the RISC-V spec, making sure I actually understand it. So it's good to have this ground truth there, whenever you're checking, making sure it is understood, right?
Mỗi khi dạy lớp này, tôi cũng kiểm tra lại đặc tả RISC-V, để chắc chắn rằng mình hiểu đúng. Vì vậy thật tốt khi có chuẩn mực này, mỗi khi bạn kiểm tra, để đảm bảo mình đã hiểu đúng, đúng không?
In this lecture, in this class, what we want to do eventually is basically really implement this RISC-V actually in Verilog, in your project. That's basically your final design.
Trong bài giảng này, trong lớp này, điều cuối cùng chúng ta muốn làm về cơ bản là hiện thực RISC-V này bằng Verilog trong dự án của các bạn. Đó về cơ bản là thiết kế cuối cùng của các bạn.
The architecture, we will introduce one way of designing an in-order RISC-V processor in the class.
Về kiến trúc, chúng tôi sẽ giới thiệu một cách thiết kế bộ xử lý RISC-V thực thi tuần tự (in-order) trong lớp.
You will be actually designing a different version, but your own version actually during your project, right? So this architecture, especially microarchitecture component, is actually specified by yourself, right?
Các bạn sẽ thiết kế một phiên bản khác, phiên bản của riêng mình trong dự án, đúng không? Vì vậy kiến trúc này, đặc biệt là thành phần vi kiến trúc, là do chính các bạn quy định, đúng không?
So there's a lot of flexibility. We will cover the RISC-V. We'll talk about the instruction.
Nên có rất nhiều sự linh hoạt. Chúng ta sẽ học RISC-V. Chúng ta sẽ nói về tập lệnh.
We'll have an example of an implementation that captures some of the trade-off when we think about implementing a RISC-V. But in your design, you actually get to implement yours, right?
Chúng ta sẽ có một ví dụ về một cách hiện thực cho thấy một số đánh đổi khi nghĩ về việc hiện thực RISC-V. Nhưng trong thiết kế của mình, các bạn được tự hiện thực phiên bản của mình, đúng không?
So there is a lot of flexibility and also a lot of creativity. Whenever I go through the final project checkup, everyone's design is actually very different.
Vì vậy có rất nhiều linh hoạt và cả nhiều sáng tạo. Mỗi khi tôi đi kiểm tra dự án cuối kỳ, thiết kế của mỗi người đều rất khác nhau.
So that's very, very interesting. And we'll also design... We talked about both single-cycle processor. We also talked about pipelining, right? So to get actually better performance.
Điều đó rất thú vị. Và chúng ta cũng sẽ thiết kế... Chúng ta đã nói về bộ xử lý một chu kỳ. Chúng ta cũng đã nói về đường ống, đúng không? để đạt hiệu năng tốt hơn.
So that's what we want to do in this class. So if we think about executing instructions, right?
Đó là điều chúng ta muốn làm trong lớp này. Vậy nếu nghĩ về việc thực thi lệnh, đúng không?
When we actually do building a RISC-V and want to actually execute, let's start with just building, like, executing one instruction per cycle. What are the different steps that we actually need to go through?
Khi xây dựng một bộ xử lý RISC-V và muốn thực thi lệnh, hãy bắt đầu với việc thực thi một lệnh mỗi chu kỳ. Chúng ta cần trải qua những bước khác nhau nào?
I mentioned this is actually a pipeline logic, right? So we have a clock, and whenever clock ticks, we actually change all the sequential elements.
Tôi đã nói đây là logic đường ống, đúng không? Chúng ta có một xung nhịp, và mỗi khi xung nhịp chuyển, ta thay đổi tất cả các phần tử tuần tự.
What are the different sequential elements actually exist in the RISC-V processor? Of course, we have registers, right? We'll talk about the different registers in RISC-V.
Có những phần tử tuần tự nào trong bộ xử lý RISC-V? Tất nhiên là có các thanh ghi, đúng không? Chúng ta sẽ nói về các thanh ghi khác nhau trong RISC-V.
A register is definitely a state element. We're holding those values. We're updating and fetching those values later. The register is an important state element.
Thanh ghi chắc chắn là một phần tử trạng thái. Nó lưu giữ các giá trị. Ta cập nhật và lấy các giá trị đó ra sau này. Thanh ghi là một phần tử trạng thái quan trọng.
Another state element in our finite state machine is a program counter, right? We need to remember where we were before, and which instruction we want to execute next, we want to fetch next, right?
Một phần tử trạng thái khác trong máy trạng thái hữu hạn của ta là bộ đếm chương trình, đúng không? Ta cần nhớ trước đó mình ở đâu, và lệnh nào ta muốn thực thi tiếp theo, muốn lấy tiếp theo, đúng không?
So this is another state element in our finite state machine that we actually need to update every clock cycle. We also have memory, right? We have both instruction memory and data memory.
Đây là một phần tử trạng thái khác trong máy trạng thái hữu hạn mà ta cần cập nhật mỗi chu kỳ xung nhịp. Ta cũng có bộ nhớ, đúng không? Có cả bộ nhớ lệnh và bộ nhớ dữ liệu.
Those are also state elements, right? We think about state elements in finite state machine, all the different registers, all different memory. Those are basically holding values.
Đó cũng là các phần tử trạng thái, đúng không? Khi nghĩ về các phần tử trạng thái trong máy trạng thái hữu hạn, tất cả các thanh ghi khác nhau, tất cả các bộ nhớ khác nhau. Chúng về cơ bản lưu giữ các giá trị.
These are holding instructions or holding data that's being read and also written every cycle. Those are basically different state elements.
Chúng lưu giữ lệnh hoặc lưu giữ dữ liệu được đọc và cũng được ghi mỗi chu kỳ. Đó về cơ bản là các phần tử trạng thái khác nhau.
Whenever we actually clock ticks, we check all the state elements and to see whether we want to update them or not. After that, we basically have a big blob of combinational logic.
Mỗi khi xung nhịp chuyển, chúng ta kiểm tra tất cả các phần tử trạng thái để xem có muốn cập nhật chúng hay không. Sau đó, về cơ bản chúng ta có một khối lớn logic tổ hợp.
You think about processor design, eventually it's basically a sequential logic that can be implemented as a finite state machine.
Khi các em nghĩ về thiết kế bộ xử lý, thì cuối cùng nó về cơ bản là một logic tuần tự có thể được hiện thực dưới dạng một máy trạng thái hữu hạn.
The processor is basically doing a bunch of computation based on the current states that we actually observed from all the different state elements and also instructions we just fetched from instruction memory, right?
Bộ xử lý về cơ bản thực hiện một loạt tính toán dựa trên các trạng thái hiện tại mà chúng ta quan sát được từ tất cả các phần tử trạng thái khác nhau và cả các lệnh vừa được nạp từ bộ nhớ lệnh, đúng không?
So that's basically the core part of the processor design. We're doing a bunch of combinational logic.
Đó về cơ bản là phần cốt lõi của thiết kế bộ xử lý. Chúng ta thực hiện một loạt logic tổ hợp.
We're going to break them down later, what are the different components of the combinational logic, but there's a big blob of combinational logic that interacts with the state element and also updating the state elements, right?
Sau này chúng ta sẽ phân tách chúng ra, xem các thành phần khác nhau của logic tổ hợp là gì, nhưng đây là một khối lớn logic tổ hợp tương tác với các phần tử trạng thái và cũng cập nhật các phần tử trạng thái, đúng không?
So that we can actually move on either by updating the registers, updating the program counter, right? Either we go to the next instruction or jump to a different instruction or updating the memory, right?
Nhờ đó chúng ta có thể tiếp tục, hoặc bằng cách cập nhật các thanh ghi, cập nhật bộ đếm chương trình, đúng không? Hoặc là chuyển sang lệnh kế tiếp hoặc nhảy tới một lệnh khác, hoặc cập nhật bộ nhớ, đúng không?
So whenever we think of, we can basically abstract our machine into a finite state machine with state elements and combinational logic that interacts with the state elements, right?
Vậy nên mỗi khi chúng ta nghĩ về, chúng ta có thể trừu tượng hóa cỗ máy của mình thành một máy trạng thái hữu hạn với các phần tử trạng thái và logic tổ hợp tương tác với các phần tử trạng thái, đúng không?
So when we think about RISC-V processor, of course we'll talk about the different components later, but it is basically a finite state machine with state elements and combinational logic.
Vậy khi nghĩ về bộ xử lý RISC-V, tất nhiên sau này chúng ta sẽ nói về các thành phần khác nhau, nhưng về cơ bản nó là một máy trạng thái hữu hạn với các phần tử trạng thái và logic tổ hợp.
So specifically, what are the state elements, right? We already talked briefly earlier, we have registers, we'll talk about all the different registers.
Cụ thể thì các phần tử trạng thái là gì, đúng không? Lúc nãy chúng ta đã nói sơ qua, chúng ta có các thanh ghi, chúng ta sẽ nói về tất cả các thanh ghi khác nhau.
Here for RISC-V, I say we have 32 registers that actually hold the value. There are some special registers, for example x0 is always zero, right?
Với RISC-V, có 32 thanh ghi dùng để lưu giá trị. Có một số thanh ghi đặc biệt, ví dụ x0 luôn bằng không, đúng không?
So that we can get a zero, we can always treat x0 to actually get zero values, right? Another state element is program counter, right?
Nhờ vậy chúng ta có được số không, chúng ta luôn có thể dùng x0 để lấy giá trị không, đúng không? Một phần tử trạng thái khác là bộ đếm chương trình, đúng không?
PC, we need to know where we want to fetch instructions and during the instruction execution, we're also updating our program counters. We also have memory, right?
PC, chúng ta cần biết cần nạp lệnh từ đâu, và trong quá trình thực thi lệnh, chúng ta cũng cập nhật bộ đếm chương trình. Chúng ta cũng có bộ nhớ, đúng không?
So memory will actually hold both instructions and the data, Right?
Bộ nhớ sẽ lưu cả lệnh lẫn dữ liệu, đúng không?
So we read instructions from instruction memory, we read data from data memory, and we also update data in data memory if we actually perform a store operation, right?
Chúng ta đọc lệnh từ bộ nhớ lệnh, đọc dữ liệu từ bộ nhớ dữ liệu, và cũng cập nhật dữ liệu trong bộ nhớ dữ liệu nếu chúng ta thực hiện thao tác lưu (store), đúng không?
We'll talk about how we actually treat read and write, either as fully combinational or sequential logic later, but those are different state elements we consider in our processor pipeline, right?
Sau này chúng ta sẽ nói về cách xử lý việc đọc và ghi, là logic hoàn toàn tổ hợp hay logic tuần tự, nhưng đó là các phần tử trạng thái khác nhau mà chúng ta xét trong đường ống của bộ xử lý, đúng không?
So, talk about state elements. Again, this is just high level, talking about different components, right? We have state elements, we also have compute elements, basically the combinational logic.
Vậy là chúng ta đã nói về các phần tử trạng thái. Một lần nữa, đây chỉ là mức tổng quan, nói về các thành phần khác nhau, đúng không? Chúng ta có các phần tử trạng thái, và cũng có các phần tử tính toán, về cơ bản là logic tổ hợp.
One way to think about combinational logic is basically a blob of, sorry, when you think about datapaths, right? How we actually execute the instructions.
Một cách để hình dung logic tổ hợp là coi nó về cơ bản như một khối, xin lỗi, khi các bạn nghĩ về các datapath, đúng không? Tức là chúng ta thực sự thực thi các lệnh như thế nào.
It is basically a blob, or monolithic combinational logic, that interacts with the state elements to execute instructions, right?
Về cơ bản nó là một khối, hay logic tổ hợp nguyên khối, tương tác với các phần tử trạng thái để thực thi lệnh, đúng không?
So basically what we are doing is fetching instructions, seeing what this instruction is trying to do, and then either fetching data from either the register file or memory, or actually changing the state in our register file by updating our state elements, right?
Vậy về cơ bản những gì chúng ta làm là nạp lệnh, xem lệnh này đang cố làm gì, rồi hoặc lấy dữ liệu từ tệp thanh ghi hoặc từ bộ nhớ, hoặc thực sự thay đổi trạng thái trong tệp thanh ghi bằng cách cập nhật các phần tử trạng thái, đúng không?
A lot of interactions between combinational logic and our state elements. So that's basically the functionality of the datapath. That is, it's just too complex, especially when we talk about datapaths.
Có rất nhiều tương tác giữa logic tổ hợp và các phần tử trạng thái của chúng ta. Đó về cơ bản là chức năng của datapath. Tức là nó quá phức tạp, đặc biệt khi nói đến các datapath.
It's just a blob of combinational logic, right? And that terminology doesn't really help us. So here is a layer of abstraction.
Nó chỉ là một khối logic tổ hợp, đúng không? Và cách gọi đó thực sự không giúp ích cho chúng ta. Vậy đây là một tầng trừu tượng hóa.
We started from, especially when we go to the gate level, Boolean expressions; we talk about the gate level logic.
Chúng ta bắt đầu từ, đặc biệt khi đi xuống mức cổng, các biểu thức Boolean; chúng ta nói về logic mức cổng.
Now we go all the way up to just a blob of all the different logic, and both are actually not very helpful when we approach pipelining, when we approach a processor design, because we need to have higher level abstractions than just AND gates, but also lower level abstraction than just treating this as a blob of logic.
Giờ chúng ta đi lên tận mức chỉ còn là một khối gồm tất cả các loại logic, và cả hai đều thực sự không hữu ích lắm khi chúng ta tiếp cận kỹ thuật đường ống, khi chúng ta tiếp cận việc thiết kế bộ xử lý, vì chúng ta cần những mức trừu tượng cao hơn chỉ các cổng AND, nhưng cũng thấp hơn việc coi nó chỉ là một khối logic.
So we need some new terms to help us describe different modules, different functionalities in our processor, Right?
Vì vậy chúng ta cần một số thuật ngữ mới để mô tả các mô-đun khác nhau, các chức năng khác nhau trong bộ xử lý của chúng ta, đúng không?
So here we're basically breaking up the combinational logic into different stages, and each stage has this particular functionality. So this, all of this is basically a layer of abstractions.
Ở đây về cơ bản chúng ta chia logic tổ hợp thành các giai đoạn khác nhau, và mỗi giai đoạn có một chức năng riêng. Như vậy, tất cả những điều này về cơ bản là một tầng các mức trừu tượng hóa.
We don't want to stay too high because that doesn't help us. We don't want to stay too low because that's too tedious.
Chúng ta không muốn ở mức quá cao vì nó không giúp ích gì. Chúng ta cũng không muốn ở mức quá thấp vì như vậy quá rườm rà.
We want to actually talk about different stages and also how they, how we can actually design and implement different stages.
Chúng ta muốn nói về các giai đoạn khác nhau và cả việc chúng ta có thể thiết kế và triển khai các giai đoạn đó như thế nào.
So different stages, you can basically think about different combinational logic performing different functions, but we break them down so that we have our vocabulary or terminology to describe different functionalities.
Vậy các giai đoạn khác nhau, về cơ bản bạn có thể xem là các khối logic tổ hợp thực hiện những chức năng khác nhau, nhưng chúng ta chia nhỏ chúng ra để có từ vựng hay thuật ngữ mô tả các chức năng khác nhau.
So that gets to the five stage of our datapaths. First stage, fetching instructions, instruction fetch.
Từ đó ta có năm giai đoạn của datapath. Giai đoạn đầu tiên là nạp lệnh, instruction fetch.
After we fetch instruction, we decode the instruction to figure out what the instruction is trying to do, and then we execute the instruction to perform different functionalities.
Sau khi nạp lệnh, chúng ta giải mã lệnh để biết lệnh đang cố làm gì, rồi thực thi lệnh để thực hiện các chức năng khác nhau.
If it needs memory accesses, we read or write our memory in our memory stage, and then finally we write back the registers to actually update the state. So those are the five stages.
Nếu cần truy cập bộ nhớ, ta đọc hoặc ghi bộ nhớ ở giai đoạn memory, và cuối cùng ta ghi lại vào các thanh ghi để thực sự cập nhật trạng thái. Đó là năm giai đoạn.
This is a higher level than the individual gate, but a lower level than just the entire datapaths, right?
Đây là mức cao hơn từng cổng riêng lẻ, nhưng thấp hơn toàn bộ datapath, đúng không?
So those are the different components, and we'll use those stages to describe the functionality of our processors.
Đó là các thành phần khác nhau, và chúng ta sẽ dùng các giai đoạn này để mô tả chức năng của các bộ xử lý.
So now, before we have this one-cycle RISC-V datapath, there's some state element and a blob of combinational logic, right? So now we break it down.
Bây giờ, trước khi có đường dữ liệu RISC-V một chu kỳ này, ta chỉ có một phần tử trạng thái và một khối logic tổ hợp, đúng không? Giờ ta chia nhỏ nó ra.
This helps us to actually see the different components of datapaths a little bit, a lot more clearly, right? So it's still a single cycle, right?
Việc này giúp ta thực sự nhìn thấy các thành phần của đường dữ liệu một chút, rõ ràng hơn nhiều, đúng không? Vậy nó vẫn là một chu kỳ duy nhất, đúng không?
We have our clock toggled, and then we start performing function, right?
Xung nhịp đổi trạng thái, rồi ta bắt đầu thực hiện chức năng, đúng không?
So this is still basically a sequential logic when we are building a finite state machine, but during the time, during this clock period, all the different computation is actually going out.
Về cơ bản đây vẫn là logic tuần tự khi ta xây dựng một máy trạng thái hữu hạn, nhưng trong khoảng thời gian này, trong chu kỳ xung nhịp này, tất cả các phép tính khác nhau thực sự diễn ra.
I will talk about the five stages.
Tôi sẽ nói về năm giai đoạn.
We fetch the instructions, we decode the instruction, perform register read, we execute, doing the computation, our ALU, and then we do the memory accesses, and finally we actually write back to the register.
Ta nạp lệnh, giải mã lệnh, đọc thanh ghi, thực thi, tức là tính toán, bằng ALU, rồi truy cập bộ nhớ, và cuối cùng ghi kết quả trở lại thanh ghi.
So those are basically different stages. Now we actually see a little bit clearly what are the different components actually involved. So far, we're still talking about the one-cycle execution.
Đó về cơ bản là các giai đoạn khác nhau. Giờ ta đã thấy rõ hơn một chút những thành phần nào thực sự tham gia. Cho đến giờ, ta vẫn đang nói về thực thi một chu kỳ.
Next, we will also get to how we actually add more registers, pipeline registers, to break the entire datapath into finer components. So now we have our vocabularies, right?
Tiếp theo, ta sẽ xem cách thêm các thanh ghi, thanh ghi đường ống, để chia toàn bộ đường dữ liệu thành các phần nhỏ hơn. Vậy là ta đã có vốn từ vựng, đúng không?
So instead of just a blob of combinational logic, we have the different sub-modules or modules building up the modules hierarchically, right?
Thay vì chỉ một khối logic tổ hợp, ta có các mô-đun con khác nhau hoặc các mô-đun xây dựng nên các mô-đun theo phân cấp, đúng không?
So let's take a look at some of the combinational logic that will actually show up very frequently when we think about datapath design.
Hãy xem một số logic tổ hợp sẽ xuất hiện rất thường xuyên khi ta nghĩ về thiết kế đường dữ liệu.
So first, when we think about combinational elements, right, we'll talk about different computations like adders, or mostly just talking about adder that can also be used as subtractor.
Đầu tiên, khi nghĩ về các phần tử tổ hợp, ta sẽ nói về các phép tính khác nhau như bộ cộng, hay chủ yếu là bộ cộng, cũng có thể dùng làm bộ trừ.
Here, we take two inputs in and we output the sum and the carry out, right? We also have carry in here.
Ở đây, ta nhận hai đầu vào và cho ra tổng và carry out, đúng không? Ở đây cũng có carry in.
ALU can also perform more functions we'll talk about later, not only additions, but also logical functions later. I think you will see a lot, especially in our processor design, is the multiplexer or MUX.
ALU còn có thể thực hiện nhiều chức năng khác mà ta sẽ nói sau, không chỉ phép cộng mà sau này còn có các phép logic. Tôi nghĩ bạn sẽ gặp rất nhiều, đặc biệt trong thiết kế bộ xử lý, là bộ dồn kênh hay MUX.
Whenever, oh yeah, MUX here. So you will see this a lot, especially when we get to the control of datapaths, right? Depends on the different instructions that we are seeing.
Bất cứ khi nào, à đây, MUX đây. Bạn sẽ gặp nó rất nhiều, đặc biệt khi ta đến phần điều khiển đường dữ liệu, đúng không? Tùy vào các lệnh khác nhau mà ta gặp.
Depends on the current state, we may actually have different signals to control different parts of the pipeline.
Tùy vào trạng thái hiện tại, ta có thể có các tín hiệu khác nhau để điều khiển các phần khác nhau của đường ống.
So multiplexer is very important, very useful to describe, represent some of the combinational elements in our hardware. Based on the control signal, you will see a lot of different control signals later.
Vì vậy bộ dồn kênh rất quan trọng, rất hữu ích để mô tả, biểu diễn một số phần tử tổ hợp trong phần cứng của ta. Dựa trên tín hiệu điều khiển, sau này bạn sẽ thấy rất nhiều tín hiệu điều khiển khác nhau.
Basically, by decoding the instruction, we'll get different control signals, and then that can actually dictate what the output should be. For example, you will see a branch instruction and the branch is actually taken.
Về cơ bản, bằng cách giải mã lệnh, ta sẽ có các tín hiệu điều khiển khác nhau, và chúng quyết định đầu ra phải là gì. Ví dụ, bạn sẽ thấy một lệnh rẽ nhánh và nhánh đó thực sự được thực hiện.
We may want to have our program counter to jump to our destination, or if it's just a regular instruction, we may just advance to the next instruction, right?
Có thể ta muốn bộ đếm chương trình nhảy tới địa chỉ đích, hoặc nếu chỉ là một lệnh thông thường, thì ta chỉ tiến tới lệnh tiếp theo, đúng không?
So program counter just advance to the next instruction. So for this kind of control, where this could be multiple different scenarios, depends on the instructions, multiplexer or MUX is very important.
Vậy bộ đếm chương trình chỉ tiến tới lệnh tiếp theo. Vì vậy với kiểu điều khiển này, nơi có thể có nhiều trường hợp khác nhau, tùy theo lệnh, bộ dồn kênh hay MUX rất quan trọng.
So we'll see this a lot next week when we talk about the datapath design. So this is a combinational logic. Another part of the datapath design we already mentioned is register, right?
Ta sẽ thấy nó rất nhiều vào tuần sau khi nói về thiết kế datapath. Đây là một mạch logic tổ hợp. Một phần khác của thiết kế datapath mà ta đã nhắc tới là thanh ghi, đúng không?
So this should be fairly familiar, we already talked about register. It's actually toggled by clock. We have this triangle here.
Phần này khá quen thuộc, ta đã nói về thanh ghi rồi. Nó thực ra được kích bởi xung clock. Ta có hình tam giác này ở đây.
One thing, again, when we get to more control signal is actually we only want to do update or update the register if certain condition is met, right?
Một điều nữa, khi nói tới nhiều tín hiệu điều khiển hơn là ta chỉ muốn cập nhật thanh ghi nếu một điều kiện nào đó được thỏa mãn, đúng không?
So with that, when we talk about register, we also want to introduce, we haven't seen this a lot before, but this write enable signal.
Vì vậy, khi nói về thanh ghi, ta cũng muốn giới thiệu một thứ trước đây ta chưa thấy nhiều, đó là tín hiệu write enable.
So again, giving us another level of control, we only update, particular, we only update, only write to the register, not only at the passage of clock, when clock is triggered, but when we actually do want to write the register, right?
Nó cho ta thêm một mức điều khiển nữa: ta chỉ cập nhật, cụ thể là chỉ ghi vào thanh ghi, không chỉ khi xung clock đến, khi clock được kích, mà khi ta thực sự muốn ghi vào thanh ghi, đúng không?
We do want to perform a write. Because depending on the instruction, sometimes you actually write to a register, sometimes you just do a store, right? You actually don't need to write the register.
Tức là ta thực sự muốn thực hiện một thao tác ghi. Bởi vì tùy theo lệnh, đôi khi bạn ghi vào một thanh ghi, đôi khi bạn chỉ thực hiện lệnh store, đúng không? Bạn thực ra không cần ghi vào thanh ghi.
So you also want to have this level of control when we think about register. So that's something we want to see. We only do the write or when the write enable is actually asserted.
Vì vậy khi nghĩ về thanh ghi, bạn cũng muốn có mức điều khiển này. Đó là điều ta muốn thấy. Ta chỉ ghi khi write enable thực sự được kích hoạt.
So this is single register, right? So when we talk about, especially a processor, we actually have a set of registers, what we call a register file, right?
Đây là một thanh ghi đơn, đúng không? Khi nói về, đặc biệt là một bộ xử lý, ta có một tập thanh ghi, gọi là register file, đúng không?
In the RISC-V, I say we always have 32 registers, right? So we have 32 different registers that we can use.
Trong RISC-V, tôi nói là luôn có 32 thanh ghi, đúng không? Vậy ta có 32 thanh ghi khác nhau để dùng.
And particularly, we already mentioned earlier, x zero is just wired to zero. It's very handy to use when we just need a zero element, right?
Đặc biệt, như đã nhắc trước đó, x0 được nối cứng với giá trị không. Rất tiện khi ta chỉ cần một phần tử bằng không, đúng không?
We'll talk about later, especially how instructions are being decoded to actually perform the register accesses, but we can basically have two address lines to actually specify which register we want, which two registers that we want to read, and get the values from register A and B.
Ta sẽ nói sau, đặc biệt là cách các lệnh được giải mã để thực hiện việc truy cập thanh ghi, nhưng về cơ bản ta có hai đường địa chỉ để chỉ định ta muốn thanh ghi nào, hai thanh ghi nào ta muốn đọc, và lấy giá trị từ thanh ghi A và B.
And then we also, remember the write enable? We basically perform the write, actually write enable is set, so that we can actually update the register.
Và ta cũng có, còn nhớ write enable không? Ta thực hiện việc ghi khi write enable được đặt, để có thể cập nhật thanh ghi.
And whenever we talk about register, there's always a clock component, right? So we update the register when clock is triggered.
Và bất cứ khi nào nói về thanh ghi, luôn có thành phần clock, đúng không? Ta cập nhật thanh ghi khi clock được kích.
So this is a way to actually implement this register file actually in Verilog, right? We talk about this is our register file, right?
Đây là một cách để hiện thực register file này bằng Verilog, đúng không? Chúng ta nói đây là register file của chúng ta, đúng không?
We have 32 registers, each register, internally we have 32, we have 32 registers. Each register is also 32 bits, right? Because we're talking about this file, 32-bit integer, ISA, right?
Chúng ta có 32 thanh ghi, mỗi thanh ghi, bên trong chúng ta có 32 thanh ghi. Mỗi thanh ghi cũng rộng 32 bit, đúng không? Vì chúng ta đang nói về tập lệnh ISA số nguyên 32 bit này, đúng không?
So that's the integer ISA that we're implementing. To index 32 different registers, we need five bits.
Đó là ISA số nguyên mà chúng ta đang hiện thực. Để đánh chỉ số cho 32 thanh ghi khác nhau, chúng ta cần năm bit.
So those are basically the indices that we'll want to use to figure out which register that we want to read at the right.
Đó chính là các chỉ số mà chúng ta sẽ dùng để xác định thanh ghi nào mà chúng ta muốn đọc ở bên phải.
And for the write, remember what we saw earlier, write enable, right? Write enable, we perform the write. And for read here, we just assume combinational read, right?
Còn với việc ghi, hãy nhớ những gì chúng ta đã thấy trước đó, write enable, đúng không? Có write enable thì chúng ta thực hiện việc ghi. Còn với việc đọc ở đây, chúng ta chỉ giả sử là đọc tổ hợp, đúng không?
We just check the address, it reads the value directly. So this is basically a register, how we actually think about register file and how we actually implement it.
Chúng ta chỉ kiểm tra địa chỉ, và nó đọc ra giá trị trực tiếp. Vậy về cơ bản đây là một thanh ghi, cách chúng ta nghĩ về register file và cách chúng ta hiện thực nó.
One final question. So we say this is the 32-bit integer, ISA, right? This is the register file. What if we are actually implementing RISC-V 64-bit integer, ISA?
Một câu hỏi cuối cùng. Chúng ta nói đây là ISA số nguyên 32 bit, đúng không? Đây là register file. Nếu chúng ta hiện thực ISA số nguyên RISC-V 64 bit thì sao?
How would our Verilog code change? Omer? It's going to be the same, except you'll have to adjust the inputs and the output, the number of things.
Mã Verilog của chúng ta sẽ thay đổi thế nào? Omer? Nó sẽ giống nhau, chỉ khác là bạn phải điều chỉnh các đầu vào và đầu ra, số lượng các thứ.
For example, the write enable will be 6-bit instead of 5. So this will be 6-bit? Yeah.
Ví dụ, write enable sẽ là 6 bit thay vì 5. Vậy cái này sẽ là 6 bit? Vâng.
We have 64 registers? Oh, 64. Our reason for doing that is the address is 64, it doesn't mean that we have 64 registers, right?
Chúng ta có 64 thanh ghi? Ồ, 64. Lý do của chúng ta là địa chỉ là 64, điều đó không có nghĩa là chúng ta có 64 thanh ghi, đúng không?
Right. So we still have to adjust the address. Adjust the address. So the number of registers is going to be the same.
Đúng. Vậy chúng ta vẫn phải điều chỉnh địa chỉ. Điều chỉnh địa chỉ. Vậy số lượng thanh ghi sẽ giữ nguyên.
And all the registers, the register file is going to be 64 instead of 32. Right, right. So, yeah, Omer took a deep word, but you eventually...
Và tất cả các thanh ghi, register file sẽ là 64 thay vì 32. Đúng, đúng. Vâng, Omer đã suy nghĩ rất sâu, nhưng cuối cùng bạn...
Well, thank you for sharing your thought process. Right. 64-bit, I say, it only means the data is 64-bit. We always have 32 registers, no matter what I say we're talking about.
Cảm ơn bạn đã chia sẻ quá trình suy nghĩ của mình. Đúng. Khi tôi nói 64 bit, nó chỉ có nghĩa là dữ liệu là 64 bit. Chúng ta luôn có 32 thanh ghi, dù tôi nói đến loại nào.
So there are always 32 rows. We always have 32 different registers. So we don't need to change the bitwise. Everything stays the same. The only thing different is the bus are wider, right?
Vậy luôn luôn có 32 hàng. Chúng ta luôn có 32 thanh ghi khác nhau. Nên chúng ta không cần thay đổi số bit chỉ số. Mọi thứ giữ nguyên. Điểm khác duy nhất là các bus rộng hơn, đúng không?
Internally, we'll have wider bit because everything is 64-bit. Something to think about, very important. That's one very catch, some question very hard to catch, very tricky question. But always, only 32 registers.
Bên trong, chúng ta sẽ có số bit rộng hơn vì mọi thứ là 64 bit. Đây là điều đáng suy nghĩ, rất quan trọng. Đó là một cái bẫy, một câu hỏi rất khó nhận ra, một câu hỏi rất hóc búa. Nhưng luôn luôn chỉ có 32 thanh ghi.
The bitwise can be different, but only 32. We'll just pause here. We'll continue our discussion next time. We'll see more different fancy components on RISC-V. Good to see you all.
Số bit có thể khác, nhưng chỉ có 32 thanh ghi. Chúng ta dừng ở đây. Chúng ta sẽ tiếp tục thảo luận vào lần sau. Chúng ta sẽ thấy thêm nhiều thành phần phức tạp khác trên RISC-V. Rất vui được gặp các bạn.
See you next week. Sure.
Hẹn gặp lại các bạn tuần sau. Vâng.
Đă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.