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ả.
And welcome everyone to discussion 5 of EECS 151. Today we'll be talking mainly about RISC-V. During our last discussion, we ended with an introduction to pipelining.
Xin chào mừng mọi người đến với buổi thảo luận 5 của EECS 151. Hôm nay chúng ta chủ yếu sẽ nói về RISC-V. Trong buổi thảo luận trước, chúng ta kết thúc bằng phần giới thiệu về pipelining.
So we'll go into more details, some hazards that can occur from pipelining a CPU. We'll look at both examples of data and control hazards.
Vì vậy, chúng ta sẽ đi vào chi tiết hơn, về một số hazard có thể xảy ra khi chia CPU thành đường ống. Chúng ta sẽ xem cả ví dụ về data hazard và control hazard.
And then we'll also talk a little bit about FPGAs, how they generally work, as well as the concept of LUTs.
Sau đó chúng ta cũng sẽ nói một chút về FPGA, cách chúng hoạt động nói chung, cũng như khái niệm LUT.
So from last time, we talked about how the RISC-V CPU has five general operations.
Nhắc lại từ lần trước, chúng ta đã nói rằng CPU RISC-V có năm thao tác chung.
It has the instruction fetch, instruction decode and register read, ALU execute, memory access, and write back.
Đó là nạp lệnh, giải mã lệnh và đọc thanh ghi, thực thi ALU, truy cập bộ nhớ và ghi lại.
From last time, we know that one way to increase the overall throughput of this processor is to break this up into different pipelines.
Từ lần trước, chúng ta biết một cách để tăng thông lượng tổng thể của bộ xử lý này là chia nó thành các tầng đường ống khác nhau.
So we add pipeline registers between each stage, and that allows us to work on multiple instructions at the same time.
Vì vậy, chúng ta thêm các thanh ghi đường ống giữa mỗi tầng, và điều đó cho phép xử lý nhiều lệnh cùng một lúc.
However, there are a few potential issues that could come up from pipelining, which are usually related to some sort of resource or data dependency.
Tuy nhiên, có một vài vấn đề tiềm ẩn có thể nảy sinh từ việc chia đường ống, thường liên quan đến một dạng phụ thuộc về tài nguyên hoặc dữ liệu.
So these are the different types of hazards that we could face in pipelining. We have structural hazards, data hazards, and control hazards.
Đây là các loại hazard khác nhau mà chúng ta có thể gặp trong pipelining. Có structural hazard, data hazard và control hazard.
So structural hazards occur when more than one instruction is using the same resource. An example of this is the register file.
Structural hazard xảy ra khi có nhiều hơn một lệnh dùng cùng một tài nguyên. Một ví dụ là tập thanh ghi (register file).
So maybe you have one instruction, which is in the instruction decode stage, that needs to read values from registers. And you have another instruction, the write back stage, that is writing to a register.
Chẳng hạn có một lệnh đang ở tầng giải mã lệnh cần đọc giá trị từ các thanh ghi. Và có một lệnh khác, ở tầng ghi lại, đang ghi vào một thanh ghi.
Generally speaking, structural hazards are the easiest to solve, because all that it requires is to add a little bit more hardware.
Nói chung, structural hazard là loại dễ giải quyết nhất, vì chỉ cần thêm một chút phần cứng.
So in the case of the register file, we have separate read and write ports so that both instructions can interface with the register file at the same time.
Trong trường hợp tập thanh ghi, chúng ta có các cổng đọc và ghi riêng để cả hai lệnh có thể truy cập tập thanh ghi cùng một lúc.
Then we have what are called data hazards.
Tiếp theo là cái gọi là data hazard.
And these occur when, let's say, one instruction completes some value, stores it into a register, and soon after another instruction requires that new value of the register.
Loại này xảy ra khi, giả sử, một lệnh tính xong một giá trị, lưu vào thanh ghi, và ngay sau đó một lệnh khác cần giá trị mới đó của thanh ghi.
If the instructions are very close to each other, then the writeback might not happen for the first instruction until we get to the second one. So we'll go through a few examples of there.
Nếu các lệnh nằm rất gần nhau, thì việc ghi lại có thể chưa xảy ra cho lệnh đầu tiên cho tới khi ta đến lệnh thứ hai. Chúng ta sẽ đi qua một vài ví dụ về điều này.
Two main ways that you could deal with it are stalling and forwarding. Stall generally tends to be a fairly bad approach because you wait cycles just waiting for the instruction to pass.
Hai cách chính để xử lý là stalling và forwarding. Stall nhìn chung là một cách khá tệ vì bạn mất các chu kỳ chỉ để chờ lệnh đi qua.
Forwarding is generally a better way to do things. It results in a little bit more hardware, but you're able to maintain higher throughput.
Forwarding nhìn chung là cách tốt hơn. Nó tốn thêm một chút phần cứng, nhưng bạn duy trì được thông lượng cao hơn.
Then we'll talk about control hazards, which are generally for branch instructions. And in this case, the branch condition is evaluated in the execute phase.
Sau đó chúng ta sẽ nói về control hazard, thường liên quan đến các lệnh rẽ nhánh. Và trong trường hợp này, điều kiện rẽ nhánh được đánh giá ở giai đoạn thực thi.
So when we need to jump to the next line or the next instruction, we don't necessarily know what that is until later.
Vì vậy, khi cần nhảy đến dòng tiếp theo hoặc lệnh tiếp theo, chúng ta không nhất thiết biết đó là lệnh nào cho đến sau này.
So the general approach there is just to guess either the branch is taken or not taken.
Cho nên cách tiếp cận chung ở đây là cứ đoán rằng nhánh sẽ được thực hiện hoặc không được thực hiện.
And then if you happen to be wrong later, then you go back and fix it by just flushing it out.
Và nếu sau đó hóa ra bạn đoán sai, thì bạn quay lại sửa bằng cách xóa (flush) các lệnh đó đi.
Branch prediction is a type of circuit that tries to more intelligently guess whether the branch should or should not be taken prior to knowing what the condition evaluates to.
Branch prediction là một loại mạch cố gắng đoán thông minh hơn xem nhánh nên hay không nên được thực hiện, trước khi biết điều kiện cho kết quả gì.
And we'll see some examples of the control hazards as well. Any questions so far?
Chúng ta cũng sẽ xem một vài ví dụ về control hazard. Đến đây có câu hỏi nào không?
If not, we'll go to the data forwarding, data hazard examples.
Nếu không, chúng ta sẽ chuyển sang data forwarding và các ví dụ về data hazard.
So here we have a set of instructions, ADD, SUBTRACT, XOR and OR. And we see that there are two data dependencies here.
Ở đây ta có một tập lệnh gồm ADD, SUBTRACT, XOR và OR. Và ta thấy có hai phụ thuộc dữ liệu ở đây.
One is from the ADD to XOR, where in the ADD we write to XOR and in the ADD we write to X3.
Một là từ ADD đến XOR, trong đó ở lệnh ADD ta ghi vào XOR và ở lệnh ADD ta ghi vào X3.
And then in the XOR we read from X3 to compute the value of X5.
Rồi ở lệnh XOR ta đọc từ X3 để tính giá trị của X5.
We have another data dependency from XOR to OR through the register X5.
Ta có một phụ thuộc dữ liệu khác từ XOR đến OR thông qua thanh ghi X5.
So if you were to draw out the timing of the instructions and the stages that they're in. At the beginning, only the ADD instruction is running and is at instruction fetch.
Vậy nếu bạn vẽ ra biểu đồ thời gian của các lệnh và các giai đoạn mà chúng đang ở. Ban đầu, chỉ có lệnh ADD đang chạy và đang ở giai đoạn nạp lệnh.
Then in pipeline fashion, on the next cycle, the ADD moves to the instruction decode. The subtraction instruction is at the fetch stage, and so on.
Sau đó, theo kiểu đường ống, ở chu kỳ tiếp theo, ADD chuyển sang giải mã lệnh. Lệnh trừ đang ở giai đoạn nạp lệnh, và cứ thế tiếp tục.
But once we get to computing the XOR, what we need to have is for the ADD to be in the writeback stage by the time that the XOR is in instruction decode.
Nhưng khi đến lúc tính XOR, điều chúng ta cần là ADD phải ở giai đoạn ghi lại (writeback) vào lúc XOR ở giai đoạn giải mã lệnh.
And that's just to make sure that we have written into the register file before we can correctly load the correct value of X3.
Và điều đó chỉ nhằm đảm bảo rằng ta đã ghi vào tệp thanh ghi trước khi có thể đọc đúng giá trị của X3.
So now, because the register write occurs in the writeback phase and the register read occurs in the decode stage, these are three cycles apart, which means that the XOR and ADD need to be three cycles apart.
Bây giờ, vì việc ghi thanh ghi xảy ra ở giai đoạn writeback còn việc đọc thanh ghi xảy ra ở giai đoạn giải mã, nên hai giai đoạn này cách nhau ba chu kỳ, nghĩa là XOR và ADD cần cách nhau ba chu kỳ.
So in this case, these are usually two instructions apart, which is why an additional bubble is added here to align the instructions correctly.
Trong trường hợp này, chúng thường chỉ cách nhau hai lệnh, đó là lý do một bubble bổ sung được thêm vào đây để căn chỉnh các lệnh cho đúng.
The same thing could be done for the XOR to OR dependency. And again, we need to make sure that the XOR is in the writeback phase, the OR is in the instruction decode.
Điều tương tự có thể làm cho phụ thuộc từ XOR đến OR. Và một lần nữa, ta cần đảm bảo XOR ở giai đoạn writeback khi OR ở giai đoạn giải mã lệnh.
And this time, because these are just one instruction apart, and we need three cycles, we add two cycles of stalling.
Và lần này, vì chúng chỉ cách nhau một lệnh, mà ta cần ba chu kỳ, nên ta thêm hai chu kỳ dừng (stall).
So in this case, we were at least able to avoid the data hazards, but it did introduce an additional three cycles of stalling, which is not the best.
Vậy trong trường hợp này, ít nhất ta đã tránh được các data hazard, nhưng nó lại đưa thêm ba chu kỳ dừng, điều này không tốt nhất.
So the question was, what are these bubbles that we place?
Vậy câu hỏi là, những bubble mà chúng ta chèn vào là gì?
These are usually just NOP instructions, and this is typically implemented in hardware.
Đó thường chỉ là các lệnh NOP, và điều này thường được cài đặt bằng phần cứng.
So this set of instructions comes from the assembly language compiler.
Tập lệnh này đến từ trình biên dịch hợp ngữ.
So what you will have in the RISC-V processor is there is probably some form of logic that is checking for data dependencies.
Vậy trong bộ xử lý RISC-V, bạn sẽ có lẽ có một dạng logic nào đó kiểm tra các phụ thuộc dữ liệu.
And if it would cause you to stall otherwise, then in the hardware, you add that NOP.
Và nếu không làm gì thì sẽ gây ra stall, thì trong phần cứng, người ta thêm lệnh NOP đó vào.
Yes, yes. So it would not be included within the actual assembly instruction set.
Vâng, vâng. Vậy nó sẽ không nằm trong tập lệnh assembly thực sự.
Yes, that's correct.
Vâng, đúng vậy.
Then let's look at data forwarding.
Bây giờ hãy xem data forwarding.
So as mentioned before, data forwarding is a better way to handle this.
Như đã nói trước đó, data forwarding là cách xử lý tốt hơn cho vấn đề này.
And let's consider the case where we have an X3 dependency from one instruction to the next.
Và hãy xét trường hợp có phụ thuộc X3 từ lệnh này sang lệnh kế tiếp.
One way that we could implement this data forwarding is to take the value from the memory stage and feed it directly back to the registers or the register read values.
Một cách để hiện thực data forwarding là lấy giá trị từ tầng bộ nhớ và đưa thẳng trở lại các thanh ghi hay đúng hơn là các giá trị đọc thanh ghi.
So here we're not waiting for the new values to be written to the register file. We're essentially bypassing all of that in the following way. So we could add a few muxes.
Như vậy ở đây ta không chờ các giá trị mới được ghi vào register file. Về cơ bản ta bỏ qua toàn bộ bước đó theo cách sau. Ta có thể thêm một vài mux.
And such.
Và như thế này.
And such. And these would both then be controlled by some control signal that checks if there is a hazard for RS2.
Và như thế này. Cả hai mux này sẽ được điều khiển bởi một tín hiệu điều khiển kiểm tra xem có hazard đối với RS2 hay không.
And hazard. For RS2. RS2.
Và hazard. Đối với RS2. RS2.
So note that when the add instruction is still in the write back phase, it will update the value of the register file.
Lưu ý rằng khi lệnh add vẫn đang ở giai đoạn write back, nó sẽ cập nhật giá trị của register file.
It's just, again, the idea is we don't wait for that to occur.
Ý tưởng, một lần nữa, là ta không chờ việc đó xảy ra.
But we already know that the value that will be updated in the register file is from the ALU output, which is why we take its registered output and feed it back in for the next instruction.
Vì ta đã biết giá trị sẽ được cập nhật vào register file là từ đầu ra của ALU, đó là lý do ta lấy đầu ra đã được đăng ký của nó và đưa ngược lại cho lệnh kế tiếp.
The selection signal of the mux is determined based on the control logic.
Tín hiệu chọn của mux được xác định dựa trên logic điều khiển.
So you could imagine that you would have some kind of decoding of the instruction that checks whether one instruction stores to some register.
Vậy bạn có thể hình dung rằng ta sẽ có một dạng giải mã lệnh nào đó để kiểm tra xem một lệnh có ghi vào một thanh ghi nào đó hay không.
And if the following instruction requires that register value.
Và liệu lệnh tiếp theo có cần giá trị của thanh ghi đó hay không.
Similar. So the way that we check this is similar to just how instruction decode is generally done.
Tương tự. Cách ta kiểm tra điều này tương tự cách giải mã lệnh thường được thực hiện.
So when you're parsing an instruction, you need to first figure out what register addresses are being used and also what type of instruction it is, which helps determine what the read and write registers are.
Khi bạn phân tích một lệnh, trước hết bạn cần xác định những địa chỉ thanh ghi nào đang được dùng và cả loại lệnh là gì, điều này giúp xác định đâu là thanh ghi đọc và thanh ghi ghi.
So then you could just compare them for consecutive instructions to see if those are equivalent, at least the write register of one instruction is equal to the read register of another instruction.
Sau đó bạn chỉ cần so sánh chúng giữa các lệnh liên tiếp để xem chúng có trùng nhau không, ít nhất là thanh ghi ghi của một lệnh có bằng thanh ghi đọc của lệnh khác hay không.
Does that make sense?
Như vậy có dễ hiểu không?
Any other questions on data forwarding?
Có câu hỏi nào khác về data forwarding không?
So we add more hardware and implementing data forwarding, but from a performance perspective, it's still better.
Vậy là chúng ta thêm phần cứng và triển khai chuyển tiếp dữ liệu, nhưng xét về hiệu năng thì cách này vẫn tốt hơn.
So, let's revisit the stall scenario without forwarding, where you're to draw which pipeline stage each instruction is in.
Vậy, hãy xem lại trường hợp bị stall khi không có chuyển tiếp, trong đó bạn phải vẽ ra mỗi lệnh đang ở tầng nào của đường ống.
We note that, again, once we get to the write back or the instruction decode of the second instruction, we need to wait until the first instruction is in write back until we could proceed to execute, and then finish the second instruction,
Một lần nữa, ta thấy rằng khi đến tầng ghi lại kết quả hoặc tầng giải mã lệnh của lệnh thứ hai, ta phải đợi đến khi lệnh thứ nhất ở tầng ghi lại kết quả thì mới có thể tiếp tục thực thi, rồi mới hoàn thành lệnh thứ hai,
which in this case introduced two cycles of stall.
và trong trường hợp này điều đó gây ra hai chu kỳ stall.
Data forwarding case: the outcome is such that once you finish executing and determining what the new value of the register should be at the memory phase, it gets forwarded.
Trường hợp có chuyển tiếp dữ liệu: kết quả là ngay khi bạn thực thi xong và xác định được giá trị mới của thanh ghi ở tầng bộ nhớ, giá trị đó được chuyển tiếp đi.
We don't have to wait for write back, so there's no additional bubbles that need to be inserted here.
Ta không phải đợi đến tầng ghi lại kết quả, nên không cần chèn thêm bubble nào ở đây.
With that in mind, we'll now look at some control hazard examples.
Với ý đó, bây giờ ta sẽ xem một số ví dụ về control hazard.
So, control hazards. Again, we don't know what the branch outcome is until the end of execute, which is where the branch control unit is usually instantiated.
Vậy, control hazard. Một lần nữa, ta không biết kết quả rẽ nhánh cho đến cuối tầng thực thi, là nơi thường đặt khối điều khiển rẽ nhánh.
So how do we know what instruction to decode next? Well, we just make a guess and then retroactively fix things as it is.
Vậy làm sao biết giải mã lệnh nào tiếp theo? Ta chỉ cần đoán, rồi sau đó sửa lại nếu cần.
So let's look at the following example, where we have a series of instructions, and if X1 is equal to X2, we jump to this immediate line where we have the and and no operations.
Hãy xem ví dụ sau, trong đó có một dãy lệnh, và nếu X1 bằng X2, ta nhảy đến dòng immediate này, nơi có lệnh and và các lệnh no operation.
Otherwise, if X1 is not X2, then we just run these instructions here.
Ngược lại, nếu X1 khác X2, thì ta chạy các lệnh ở đây.
So, let's assume that in this case, X1 did evaluate to X2, but we guessed branch not taken by default.
Giả sử trong trường hợp này X1 thực sự bằng X2, nhưng theo mặc định ta đoán là không rẽ nhánh.
In other words, in this case, we guessed incorrectly.
Nói cách khác, ở đây ta đoán sai.
So what will occur is first we run the BEQ instruction, which is an instruction fetch.
Vậy điều xảy ra là trước tiên ta chạy lệnh BEQ, tức là một lần nạp lệnh.
Then we don't know whether X1 has evaluated to X2 yet, so we just guess that branch is not taken, and we go to the add instruction.
Sau đó ta chưa biết X1 có bằng X2 hay chưa, nên ta đoán là không rẽ nhánh, và đi tiếp đến lệnh add.
Then we still don't know whether the branch has evaluated to true or not, so we keep proceeding, and we keep proceeding until this point.
Rồi ta vẫn chưa biết điều kiện rẽ nhánh đúng hay sai, nên ta cứ tiếp tục, và cứ tiếp tục cho đến điểm này.
Note that at the end of the execute stage, we know what the branch condition evaluates to.
Lưu ý rằng ở cuối tầng thực thi, ta biết điều kiện rẽ nhánh cho kết quả gì.
So at this point, we know that branch result is available.
Vậy tại điểm này, kết quả rẽ nhánh đã có.
So at that point, we realized that we guessed incorrectly. Which means that all three instructions, add, sub, and XOR, should not have been executed.
Và lúc đó ta nhận ra mình đã đoán sai. Nghĩa là cả ba lệnh add, sub, và XOR lẽ ra không được thực thi.
So we just flush these out.
Vì vậy ta flush chúng đi.
And to be a little bit clearer, when we say flush these instructions, we basically mean the instructions may still propagate, but we will turn off any write capabilities.
Và để rõ hơn một chút, khi nói flush các lệnh này về cơ bản là các lệnh vẫn có thể tiếp tục lan truyền, nhưng chúng ta sẽ tắt mọi khả năng ghi.
So we will disable the write enable of the register file, as well as any storing to the memory.
Tức là chúng ta sẽ vô hiệu hóa write enable của register file, cũng như mọi thao tác lưu vào bộ nhớ.
So then if we do that, the overall state of the RISC-V datapath does not change. And these instructions typically generally have no impact.
Nếu làm như vậy, thì trạng thái tổng thể của datapath RISC-V không thay đổi. Và nhìn chung các lệnh này không gây ảnh hưởng gì.
Then at that point, we know that we should have taken the branch. So we come to the end.
Đến lúc đó, chúng ta biết rằng lẽ ra mình phải thực hiện nhánh rẽ. Vậy là chúng ta đi đến cuối.
These get filled with no-ops effectively. The branch finishes.
Các lệnh này thực chất được lấp đầy bằng no-op. Lệnh rẽ nhánh hoàn tất.
And then we run the last instruction. And then it proceeds as is.
Rồi chúng ta chạy lệnh cuối cùng. Và sau đó mọi thứ tiếp tục như bình thường.
**AUDIO LOST** You mean the branch line?
**MẤT ÂM THANH** Ý bạn là dòng lệnh rẽ nhánh phải không?
**AUDIO LOST** Oh, so what these no-ops represent is these XOR, sub instructions that we started are just being nulled and just propagating.
**MẤT ÂM THANH** À, vậy những no-op này biểu diễn các lệnh XOR, sub mà chúng ta đã bắt đầu, chúng chỉ bị vô hiệu hóa và cứ thế lan truyền đi.
Exactly, yes.
Chính xác, đúng vậy.
So essentially what we're saying is these instructions shouldn't be completed, so they should be voided or nulled in some way. Which is why we do lose some cycles there.
Về cơ bản, ý chúng ta là các lệnh này không được phép hoàn tất, nên chúng phải bị hủy hoặc vô hiệu hóa theo cách nào đó. Đó là lý do chúng ta mất một số chu kỳ ở đây.
Then next we'll look at a... At the end of the third cycle, the branch result is already available, so why do we still execute the XOR in the fourth cycle?
Tiếp theo chúng ta sẽ xem một... Ở cuối chu kỳ thứ ba, kết quả rẽ nhánh đã có sẵn, vậy tại sao chúng ta vẫn thực thi XOR ở chu kỳ thứ tư?
It's a great question. Yes, as you said, at the end of execute, the branch condition is available. And we could build control logic, which at that point could flush immediately.
Câu hỏi rất hay. Đúng như bạn nói, ở cuối giai đoạn execute, điều kiện rẽ nhánh đã có sẵn. Và chúng ta có thể xây dựng logic điều khiển để xả (flush) ngay lúc đó.
The reason why we typically don't do that is more from a timing perspective.
Lý do thường không làm vậy chủ yếu xuất phát từ góc độ thời gian (timing).
I think generally speaking, in the five-stage RISC-V CPU, The execute stage can be one of the longer stages, and could be the critical path in setting how fast we could run the processor.
Tôi nghĩ nhìn chung, trong CPU RISC-V năm giai đoạn, giai đoạn execute có thể là một trong những giai đoạn dài nhất, và có thể là đường tới hạn quyết định tốc độ chạy tối đa của bộ xử lý.
So if you were to add additional branch control logic to compute immediately after the execute stage, you're making what was probably the critical path even longer.
Vì vậy nếu bạn thêm logic điều khiển rẽ nhánh để tính toán ngay sau giai đoạn execute, thì bạn đang làm cho đường tới hạn vốn đã dài càng dài hơn.
So typically what we do instead is just to run this comparison and control logic on the next stage, so that we could break up the critical path and achieve a higher throughput.
Do đó thông thường chúng ta thay vào đó chạy phần so sánh và logic điều khiển này ở giai đoạn kế tiếp, để chia nhỏ đường tới hạn và đạt thông lượng cao hơn.
So there is a downside that we will lose an additional cycle, but generally speaking, it may have better results in the long run.
Vậy có một nhược điểm là chúng ta mất thêm một chu kỳ, nhưng nhìn chung về lâu dài có thể cho kết quả tốt hơn.
And let's look at the example where the branch is taken.
Và hãy xem ví dụ khi nhánh được thực hiện.
So again, we start with the BEQ.
Một lần nữa, chúng ta bắt đầu với BEQ.
And this time, let's guess that the branch is taken by default, which means we'll jump to here.
Và lần này, hãy dự đoán rằng nhánh mặc định được thực hiện, nghĩa là chúng ta sẽ nhảy đến đây.
And then we'll jump to here.
Và rồi chúng ta sẽ nhảy đến đây.
Again, at the end of this phase, we know that branch result is available.
Một lần nữa, ở cuối giai đoạn này, chúng ta biết kết quả rẽ nhánh đã có sẵn.
And then we effectively just propagate all of these across.
Và rồi chúng ta cứ thế truyền tất cả các lệnh này đi.
And because we guessed correctly, there are no cycles that are wasted. We just proceed as normal.
Và vì chúng ta đoán đúng nên không có chu kỳ nào bị lãng phí. Chúng ta cứ tiếp tục như bình thường.
And questions on both cases of the control hazard exercise?
Có câu hỏi nào về cả hai trường hợp của bài tập hazard điều khiển không?
How is that guess made? Yeah.
Việc đoán đó được thực hiện như thế nào? Vâng.
So that's a good question. We could only execute, guess one of those two. The mechanism that allows us to determine how to guess is what's called the branch predictor circuit.
Đó là một câu hỏi hay. Chúng ta chỉ có thể thực thi, tức là đoán, một trong hai khả năng. Cơ chế cho phép chúng ta xác định cách đoán được gọi là mạch dự đoán rẽ nhánh (branch predictor).
So we have some dedicated control logic for that. And often in processors, that might be what makes them different. Or that's one of the main differences.
Vì vậy chúng ta có một phần logic điều khiển riêng cho việc đó. Và thường trong các bộ xử lý, đó có thể là điều làm chúng khác nhau. Hoặc đó là một trong những khác biệt chính.
And the better branch predictor you have, the fewer cycles that you waste on stalling.
Bộ dự đoán rẽ nhánh càng tốt, thì càng ít chu kỳ bị lãng phí cho việc dừng (stall).
In this class, we won't really get into much detail about branch prediction. In this discussion, we'll look at a very simple example of it.
Trong lớp này, chúng ta sẽ không đi sâu vào chi tiết về dự đoán rẽ nhánh. Trong buổi thảo luận này, chúng ta sẽ xem một ví dụ rất đơn giản về nó.
But by now, I think there's a lot of interesting topics out there on how people have implemented branch prediction.
Nhưng hiện nay, tôi nghĩ có rất nhiều chủ đề thú vị về cách người ta triển khai dự đoán rẽ nhánh.
So how do we know whether we guess the right way? Guess in the right way? Are you referring to which guess to take or whether the guess is correct?
Vậy làm sao biết chúng ta đoán đúng hướng? Đoán đúng hướng? Bạn đang hỏi về việc chọn cách đoán nào hay về việc phép đoán có đúng hay không?
So if the latter, then at the execute phase, we just evaluate whether X1 is X2. And at that point, we know whether our guess was correct or incorrect.
Nếu là vế sau, thì ở giai đoạn thực thi (execute), chúng ta chỉ cần đánh giá xem X1 có bằng X2 hay không. Và tại thời điểm đó, chúng ta biết phép đoán của mình đúng hay sai.
To handle control hazards, one, we need to know what to guess. But two, we also need to compute the next value of PC immediately.
Để xử lý các hazard điều khiển, thứ nhất, ta cần biết phải đoán gì. Nhưng thứ hai, ta cũng cần tính ngay giá trị tiếp theo của PC.
If you were to go back to the diagram of the RISC-V CPU, previously in the single-cycle CPU case, we used the ALU output to figure out what the next value of PC should be, which would then go through the whole writeback stage
Nếu quay lại sơ đồ của CPU RISC-V, trước đây trong trường hợp CPU một chu kỳ, chúng ta dùng đầu ra của ALU để xác định giá trị tiếp theo của PC, giá trị này sau đó đi qua toàn bộ giai đoạn ghi lại (writeback)
and be muxed back into the value of PC. Now note that that requires several cycles of delay now because we have pipeline registers in between.
và được dồn kênh (mux) ngược về giá trị của PC. Lưu ý rằng giờ đây điều đó đòi hỏi độ trễ vài chu kỳ vì ở giữa có các thanh ghi đường ống.
But we want to immediately update to the correct value or to the guessed value of PC on the next cycle.
Nhưng ta muốn cập nhật ngay lập tức sang giá trị đúng hoặc giá trị PC được đoán ở chu kỳ tiếp theo.
So we can no longer rely on the ALU, but we need to then determine how do we compute this.
Vì vậy ta không thể dựa vào ALU nữa, mà cần xác định cách tính giá trị này.
So the way that we go about it, generally speaking, is to create dedicated hardware to compute what the guessed branch address should be.
Cách chúng ta làm, nói chung, là tạo phần cứng riêng để tính địa chỉ rẽ nhánh được đoán là gì.
So one way we could do that is to, one, extend this mux, have another input that is taken from some control logic block.
Một cách làm là, thứ nhất, mở rộng mux này, thêm một đầu vào khác lấy từ một khối logic điều khiển nào đó.
Let's call this calc address for computing the new address for branch instruction.
Hãy gọi nó là calc address để tính địa chỉ mới cho lệnh rẽ nhánh.
Note that its inputs are the PC and the instruction itself.
Lưu ý rằng đầu vào của nó là PC và chính lệnh đó.
So this will go in and kind of decode what the immediate should be, kind of add that to the PC, and use that to serve as the next potential value of PC.
Khối này sẽ giải mã xem giá trị tức thời (immediate) là bao nhiêu, cộng giá trị đó vào PC, và dùng kết quả làm giá trị tiềm năng tiếp theo của PC.
So similar to what we did previously where you would add PC and some immediate to the ALU and use that value, instead we have separate hardware for that.
Tương tự như trước đây, khi ta cộng PC và một giá trị tức thời trong ALU rồi dùng giá trị đó, thì giờ ta có phần cứng riêng cho việc này.
Then in addition, we have another logic that tells us which output to pick.
Ngoài ra, chúng ta còn có một logic khác cho biết nên chọn đầu ra nào.
So in the case that we have a branch instruction, we need to make sure to take this second or this third input that is derived from the calc address.
Vậy trong trường hợp có một lệnh rẽ nhánh, chúng ta cần đảm bảo chọn đầu vào thứ hai hoặc đầu vào thứ ba này, được suy ra từ calc address.
So in other words, this should mainly check: is it a branch instruction?
Nói cách khác, phần này chủ yếu kiểm tra: đây có phải là lệnh rẽ nhánh không?
Again, this allows us to then update the value of PC immediately so that we could at least guess and move on to the next instruction.
Một lần nữa, điều này cho phép chúng ta cập nhật giá trị của PC ngay lập tức để ít nhất có thể đoán và chuyển sang lệnh tiếp theo.
Questions here?
Có câu hỏi nào ở đây không?
Then let's look at a simple example of a branch prediction.
Tiếp theo, hãy xem một ví dụ đơn giản về dự đoán rẽ nhánh.
One simple example of a branch prediction is just to use the previous branch result.
Một ví dụ đơn giản về dự đoán rẽ nhánh là chỉ dùng kết quả của lần rẽ nhánh trước.
The intuition for this is that the typical case where you might have if conditions or any kind of conditional expressions is in for loops, where the idea is you run some same lines
Trực giác ở đây là trường hợp điển hình mà bạn có các điều kiện if hoặc bất kỳ biểu thức điều kiện nào là trong các vòng lặp for, nơi ý tưởng là bạn chạy cùng một số dòng
of code multiple times until you have to stop eventually. But typically when you write for while loops, you are expected to run it more than once.
mã nhiều lần cho đến khi cuối cùng phải dừng. Nhưng thông thường khi bạn viết các vòng lặp for hay while, bạn kỳ vọng nó sẽ chạy nhiều hơn một lần.
So let's see what happens in this kind of for loop case where we just use the previous branch result.
Vậy hãy xem điều gì xảy ra trong trường hợp vòng lặp for này khi ta chỉ dùng kết quả rẽ nhánh trước đó.
So we have the C code on the top and the translated assembly code on the bottom.
Ở trên là mã C và ở dưới là mã assembly đã được dịch.
The first lines are just the initialization.
Những dòng đầu tiên chỉ là phần khởi tạo.
Similar to from setting the balance of I is one and go to 100 and increment by one every time.
Tương tự như đặt giá trị của i bằng một và chạy đến 100, mỗi lần tăng thêm một.
And then we have the actual loop here that corresponds to the branch condition of the for loop.
Sau đó chúng ta có vòng lặp thực sự ở đây, tương ứng với điều kiện rẽ nhánh của vòng lặp for.
So if you were to try to figure out in this example, what is the success versus failure rate? Well, let's see what happens for each value of I.
Nếu bạn thử tính xem trong ví dụ này tỉ lệ thành công so với thất bại là bao nhiêu? Hãy xem điều gì xảy ra với từng giá trị của i.
So we know that I at first starts at zero. So we predict, we'll say we predict taken, which is correct.
Ta biết ban đầu i bắt đầu từ không. Vậy ta dự đoán, giả sử ta dự đoán là taken, và điều đó đúng.
Then if I is one, note that we just reuse the previous branch result, which was that I is taken. Which happens to be correct again.
Rồi khi i bằng một, lưu ý rằng ta chỉ dùng lại kết quả rẽ nhánh trước đó, tức là taken. Và lại tình cờ đúng một lần nữa.
And we repeat until I is 99, which is taken, correctly, and I is 100.
Ta lặp lại cho đến khi i bằng 99, là taken, đúng, rồi đến i bằng 100.
We again guess that it is taken, but in this case our guess is incorrect.
Ta lại đoán là taken, nhưng lần này dự đoán của ta sai.
So in this scenario, you can see that we got 99 successes and one failure.
Vậy trong kịch bản này, bạn thấy ta có 99 lần thành công và một lần thất bại.
So you can imagine that this is a fairly simple way that is catered towards more iterated branch conditions, or in the case where you have a bunch of conditions in series that all should not be taken.
Bạn có thể hình dung đây là một cách khá đơn giản phù hợp hơn với các điều kiện rẽ nhánh lặp đi lặp lại, hoặc trường hợp bạn có một loạt điều kiện liên tiếp mà tất cả đều không được taken.
Because this relies on just a fairly straightforward history of what has been done in the past.
Vì cách này chỉ dựa vào một lịch sử khá đơn giản về những gì đã xảy ra trong quá khứ.
And typically branch prediction engines will come up with, using previous decisions and determining what the next prediction or guess should be based on those.
Và thông thường các bộ dự đoán rẽ nhánh sẽ đưa ra dự đoán, dựa trên các quyết định trước đó và xác định xem dự đoán hay phỏng đoán tiếp theo nên là gì dựa vào những quyết định đó.
So, that's a good question.
Vậy, đó là một câu hỏi hay.
So I, I'm not too familiar with what people have implemented with branch prediction, but I would say it is possible to have maybe different kinds of algorithms or approaches in how you deal with things, and if certain sets of instructions
Em không quen lắm với việc người ta đã triển khai dự đoán rẽ nhánh như thế nào, nhưng em nghĩ có thể có những thuật toán hay cách tiếp cận khác nhau để xử lý các trường hợp, và nếu một số tập lệnh nhất định
might cater more towards one or the other, I think it is probably possible to selectively choose what approach based on the instructions.
phù hợp hơn với cách này hay cách kia, thì em nghĩ có lẽ có thể chọn lọc cách tiếp cận dựa trên các lệnh đó.
The question is, why do we predict taken is equal to zero. This is more of just an initial case.
Câu hỏi là: tại sao ta dự đoán taken bằng không. Đây chỉ là trường hợp khởi tạo ban đầu.
We could have predicted that this is not taken, in which case the first case would be x.
Ta cũng có thể dự đoán là không rẽ nhánh, khi đó trường hợp đầu tiên sẽ là x.
But because this is x, or that we should have taken it, in is equal to one, we will predict that the branch should have been taken.
Nhưng vì đây là x, tức là lẽ ra ta phải rẽ nhánh, với giá trị bằng một, ta sẽ dự đoán rằng nhánh này lẽ ra phải được rẽ.
So, kind of, this is just more of an initialization. So, to be a little bit more clear, we've predicted that this is not taken.
Nên về cơ bản đây chỉ là một bước khởi tạo. Nói rõ hơn một chút, giả sử ta dự đoán là không rẽ nhánh.
Then the first one would be incorrect, but everything else will still remain the same. And it's from I to five, from one to 100, that we compute the 99 successes and one failure.
Thì lần đầu tiên sẽ sai, nhưng mọi thứ còn lại vẫn giữ nguyên. Và từ i đến năm, từ một đến 100, ta tính được 99 lần đúng và một lần sai.
Okay. Now let's look at FPGAs.
Được rồi. Bây giờ hãy xem FPGA.
So, we've talked about how FPGAs are programmable hardware that allows you to quickly design digital circuits.
Ta đã nói về việc FPGA là phần cứng lập trình được cho phép bạn thiết kế nhanh các mạch số.
And for you to have programmable hardware, that means that you need some sort of logic cells and interconnects that can also be programmed to implement most types of logic functions.
Và để có phần cứng lập trình được, nghĩa là bạn cần một loại ô logic và các kết nối liên thông cũng có thể được lập trình để hiện thực hầu hết các loại hàm logic.
So, how do we do that? Well, that uses LUTs or lookup tables.
Vậy ta làm điều đó như thế nào? Ừm, ta dùng LUT, tức bảng tra cứu.
So, a lookup table is just a hardware truth table, which can represent any function. So, here we have a three input LUT: A, B and C.
Một bảng tra cứu chỉ là một bảng chân trị bằng phần cứng, có thể biểu diễn bất kỳ hàm nào. Ở đây ta có một LUT ba đầu vào: A, B và C.
For each input combination, which would then be two to the three, we need to specify what the value of the output would be.
Với mỗi tổ hợp đầu vào, tức là hai mũ ba tổ hợp, ta cần chỉ định giá trị của đầu ra sẽ là bao nhiêu.
The way we do that is we have latches on the left that store values of zero and one, depending on what truth table we want to program and load into the LUT.
Cách làm là ta có các chốt (latch) ở bên trái lưu các giá trị không và một, tùy theo bảng chân trị nào ta muốn lập trình và nạp vào LUT.
And once we do that, the latches hold the corresponding values.
Và khi đã làm xong, các chốt giữ các giá trị tương ứng.
We have a MUX that determines which latch output we should select based off of the actual inputs A, B and C that we got.
Ta có một MUX xác định nên chọn đầu ra của chốt nào dựa trên các đầu vào thực tế A, B và C mà ta nhận được.
So, for example, this corresponds to 0, 0, 0; 1, 0, 0; 0, 1, 0; 1, 1, 0 and so on.
Ví dụ, dòng này tương ứng với 0, 0, 0; 1, 0, 0; 0, 1, 0; 1, 1, 0 và cứ thế.
Just to be clear, for the second row, that's because A is 1, B is 0, C is 0. So, we select this when A is 1, B is 0 and C is 0.
Nói cho rõ, với dòng thứ hai, đó là vì A bằng 1, B bằng 0, C bằng 0. Vậy, ta chọn đầu ra này khi A bằng 1, B bằng 0 và C bằng 0.
So, let's say you're trying to build a large adder, maybe like a 32-bit adder.
Vậy, giả sử bạn đang muốn xây dựng một bộ cộng lớn, chẳng hạn như bộ cộng 32 bit.
Typically, in FPGAs, you don't usually have 32 LEDs or 32 input LUTs.
Thông thường, trong FPGA, bạn thường không có LUT 32 đầu vào.
You often have kind of larger, maybe 5 or 6-bit LUTs, or smaller 5 or 6-bit LUTs. But you still need to be able to implement logical functions that have more than that many inputs.
Bạn thường có các LUT lớn hơn một chút, khoảng 5 hoặc 6 bit, hoặc nhỏ hơn, 5 hoặc 6 bit. Nhưng bạn vẫn cần có khả năng triển khai các hàm logic có nhiều đầu vào hơn con số đó.
So, then the question is, can we build larger LUTs using smaller LUTs?
Vậy câu hỏi đặt ra là, liệu ta có thể xây dựng các LUT lớn hơn từ các LUT nhỏ hơn không?
So, in this case, let's try to think, can we implement a 4-input function out of 3-input LUTs?
Vậy trong trường hợp này, hãy thử nghĩ xem, liệu ta có thể triển khai một hàm 4 đầu vào từ các LUT 3 đầu vào không?
It is possible.
Điều đó là có thể.
One way to think about it is, if you go back to the previous slide, you notice that the LUT contains and consists of a series of latches, one per input combination, and some MUX to select which latch output we should take.
Một cách để nghĩ về nó là, nếu bạn quay lại slide trước, bạn sẽ thấy LUT gồm một dãy các chốt (latch), mỗi tổ hợp đầu vào có một chốt, và một MUX nào đó để chọn lấy đầu ra của chốt nào.
So, we could do that by building a LUT out of these two smaller LUTs, where each one is 3-input, so there are 8 latches on the top, 8 latches on the bottom.
Vậy ta có thể làm điều đó bằng cách xây dựng một LUT từ hai LUT nhỏ hơn này, mỗi LUT có 3 đầu vào, nên có 8 chốt ở trên và 8 chốt ở dưới.
So, total, we have 16 latches, which can cover all 2^4 input combinations for a 4-input LUT.
Vậy tổng cộng ta có 16 chốt, đủ để bao phủ toàn bộ 2^4 tổ hợp đầu vào của một LUT 4 đầu vào.
And then, we effectively have a large MUX that is divided up into two stages.
Và sau đó, ta thực chất có một MUX lớn được chia thành hai tầng.
So, the way that this would be done is, for one 3-input LUT, you set the values as if d is 0, and in the other LUT, you set the values as if d is 1.
Cách thực hiện là, với một LUT 3 đầu vào, bạn đặt các giá trị như thể d bằng 0, còn với LUT kia, bạn đặt các giá trị như thể d bằng 1.
So then, you would do the same programming of the latches.
Sau đó, bạn lập trình các chốt theo cách tương tự.
And note that the first stage of the MUX takes care of the selection from the A, B, and C.
Và lưu ý rằng tầng đầu tiên của MUX đảm nhiệm việc chọn dựa trên A, B và C.
And the second stage of the MUX takes into account the select signal for whether d is 0 or 1.
Còn tầng thứ hai của MUX xét đến tín hiệu chọn xem d bằng 0 hay 1.
And so, this is how you could implement larger LUTs from smaller LUTs.
Và đó là cách bạn có thể triển khai các LUT lớn hơn từ các LUT nhỏ hơn.
Any questions?
Có câu hỏi nào không?
Yes. Yeah. So, I still have a question on the control hazard part. So, can you move to the previous slide?
Vâng, mời bạn. Em vẫn còn một câu hỏi về phần control hazard. Thầy có thể quay lại slide trước không ạ?
Maybe the previous one. Yeah, here. So, I still wonder, after the third circle, we already have the branch result.
Có thể là slide trước nữa. Vâng, đây ạ. Em vẫn thắc mắc, sau chu kỳ thứ ba, ta đã có kết quả rẽ nhánh rồi.
Why do we need to still execute the XOR in the fourth cycle?
Tại sao ta vẫn cần thực thi lệnh XOR ở chu kỳ thứ tư?
Why not we just execute the AND in the fourth cycle? Yeah. Let me try to draw it out a bit more.
Sao ta không thực thi lệnh AND ở chu kỳ thứ tư luôn? Được. Để thầy thử vẽ ra rõ hơn một chút.
So, you're saying, let's say we have the following scenario.
Vậy ý bạn là, giả sử ta có tình huống sau.
You're saying at here, we know what the branch result is. Yes. Yes.
Bạn đang nói là ở chỗ này, chúng ta đã biết kết quả của nhánh rồi. Vâng. Vâng.
You're right that if at the end of execute phase, we determine that the branch condition is this value, and we should...
Bạn nói đúng, nếu ở cuối giai đoạn thực thi, chúng ta xác định rằng nhánh có điều kiện mang giá trị này, và chúng ta nên...
Sorry about this.
Xin lỗi về chỗ này.
Yeah. Okay. So, for us to avoid going into the XOR on the next cycle.
Vâng. Được rồi. Vậy, để chúng ta tránh đi vào lệnh XOR ở chu kỳ tiếp theo.
So, if you instead want to do... What was the other one? The AND. The AND.
Vậy, nếu bạn muốn làm... Cái còn lại là gì nhỉ? Lệnh AND. Lệnh AND.
That would mean that this will require PC plus immediate, right? Yes. To be computed. Yes.
Điều đó có nghĩa là cái này sẽ cần PC cộng immediate, đúng không? Vâng. Phải được tính. Vâng.
Where this is PC, and this is PC plus four. So, what that would mean is in that same cycle, so in one cycle.
Trong đó đây là PC, và đây là PC cộng bốn. Vậy, điều đó có nghĩa là trong cùng chu kỳ đó, tức là trong một chu kỳ.
You would have to do all the following. You would, one, have to compute branch condition.
Bạn sẽ phải làm tất cả những việc sau. Một, bạn phải tính điều kiện rẽ nhánh.
Two is... PC. And three is to...
Make decision to jump to PC plus immediate.
Hai là... PC. Và ba là quyết định nhảy đến PC cộng immediate.
I believe that, generally speaking, this could be a critical path in your RISC-V CPU, just because of the number of consecutive operations that you have to make to apply that change immediately.
Tôi tin rằng, nói chung, đây có thể là một đường tới hạn trong CPU RISC-V của bạn, chỉ vì số lượng các phép toán liên tiếp mà bạn phải thực hiện để áp dụng thay đổi đó ngay lập tức.
Yes. So, in the execution stage, we have the branch comparator and the ALU, right?
Vâng. Vậy, trong giai đoạn thực thi, chúng ta có bộ so sánh nhánh và ALU, đúng không?
So, we could do the first and second operations in one cycle. Yes, that is correct. But generally speaking, I believe the ALU tends to be one of the larger kind of critical paths.
Vậy, chúng ta có thể làm phép toán thứ nhất và thứ hai trong một chu kỳ. Vâng, đúng vậy. Nhưng nói chung, tôi tin ALU thường là một trong những đường tới hạn lớn hơn.
Yes.
Vâng.
So, and the execute stage tends to be longest in general.
Và giai đoạn thực thi nhìn chung thường dài nhất.
So, I think if you try to fit what the execute usually does, and add more kind of decisions to jump to PC plus immediate at that point, that could be more of a bottleneck to how fast you can run the CPU.
Vì vậy, tôi nghĩ nếu bạn cố nhét vào những gì giai đoạn thực thi thường làm, và thêm quyết định nhảy đến PC cộng immediate vào thời điểm đó, thì nó có thể trở thành nút thắt cổ chai hơn đối với tốc độ chạy của CPU.
Does that make sense?
Như vậy có hợp lý không?
So, we move which part of these three operations to the next clock, the third part? Let me go back to... Yeah. Yeah.
Vậy, chúng ta chuyển phần nào trong ba phép toán này sang xung nhịp tiếp theo, phần thứ ba phải không? Để tôi quay lại... Vâng. Vâng.
Effectively, what you would have is... So, you have the branch comparison, you have the ALU, and at that point, you'd have some kind of MUX that goes all the way back here.
Về bản chất, những gì bạn sẽ có là... Bạn có phép so sánh nhánh, bạn có ALU, và tại thời điểm đó, bạn sẽ có một bộ MUX nào đó đi ngược về tận đây.
Yes. And gets updated to PC. I think instead of that, you just stored a branch comparison ALU output to the pipeline.
Vâng. Và được cập nhật vào PC. Tôi nghĩ thay vì làm vậy, bạn chỉ lưu đầu ra ALU của phép so sánh nhánh vào đường ống.
And then you kind of have the following case here.
Và sau đó bạn sẽ có trường hợp như sau ở đây.
So, I guess it's kind of the current implementation is as if, as what we have in the previous case where, yeah, we pipeline the ALU output.
Vậy, tôi đoán là cách triển khai hiện tại giống như thể là, giống như trường hợp trước, khi mà đúng rồi, chúng ta đưa đầu ra của ALU vào đường ống.
And then this is what is actually being fed back into the PC register. Oh, I see. I got you. Thank you.
Và đây mới là thứ thực sự được đưa ngược trở lại thanh ghi PC. À, em hiểu rồi. Em hiểu rồi. Em cảm ơn.
But yeah, you are correct that we could probably do it a cycle earlier.
Nhưng đúng là em nói đúng, có lẽ chúng ta có thể làm sớm hơn một chu kỳ.
But it's just a matter of just designing the processor, trying to determine whether it's better to have an additional cycle of stalling or wasted instruction when you miss a branch versus lengthening the overall critical path
Nhưng đó chỉ là vấn đề thiết kế bộ xử lý, cố gắng xác định xem cái nào tốt hơn: có thêm một chu kỳ bị đình trệ hoặc một lệnh bị lãng phí khi dự đoán sai nhánh, hay kéo dài đường tới hạn chung
and lowering the overall clock frequency of the processor.
và làm giảm tần số xung nhịp chung của bộ xử lý.
I think, generally speaking, if you have a good enough branch predictor, maybe the overhead of that additional cycle being wasted when you take the incorrect guess is not as bad.
Nhìn chung, nếu bạn có một bộ dự đoán nhánh đủ tốt, thì có lẽ chi phí của chu kỳ bị lãng phí thêm đó khi đoán sai cũng không tệ lắm.
So, maybe that's why people usually stick with this approach. I see. Thank you.
Có lẽ đó là lý do người ta thường giữ cách tiếp cận này. Em hiểu rồi. Em cảm ơn.
Any other questions?
Còn câu hỏi nào khác không?
If not, I think that's it for today. Next week, we'll start going over some of the CMOS and transistors.
Nếu không thì hôm nay đến đây thôi. Tuần tới, chúng ta sẽ bắt đầu tìm hiểu về CMOS và transistor.
Đă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.