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ả.
[MUSIC PLAYING] BORIVOJE NIKOLIC: Welcome back to RISC-V assembly language.
[NHẠC PHÁT] BORIVOJE NIKOLIC: Chào mừng bạn quay lại với ngôn ngữ assembly RISC-V.
We have learned eight RISC-V assembly instructions so far. In the next 15 minutes, we are almost going to double that number.
Cho đến nay chúng ta đã học tám lệnh assembly RISC-V. Trong 15 phút tiếp theo, chúng ta gần như sẽ tăng gấp đôi con số đó.
The instructions that we have learned so far deal with addition and subtraction in operations with the memory. We can actually build a computer with that. That will be more like a calculator.
Các lệnh mà chúng ta đã học cho đến nay xử lý phép cộng và phép trừ và các phép toán với bộ nhớ. Thực tế chúng ta có thể xây dựng một máy tính với những lệnh đó. Nhưng nó sẽ giống như một máy tính.
Or a stack machine, we could build a stack machine. Those kind of things were popular, say, in the '60s or '70s. And all the action there happens on the stack.
Hoặc một máy ngăn xếp, chúng ta có thể xây dựng một máy ngăn xếp. Những thứ như vậy từng phổ biến, chẳng hạn, vào những năm 1960 hoặc 1970. Và tất cả mọi hoạt động ở đó diễn ra trên ngăn xếp.
But in order to support modern programming languages, we need to support computer decision making. Example of that in C is the if statement. And in RISC-V, there is no if statement.
Nhưng để hỗ trợ các ngôn ngữ lập trình hiện đại, chúng ta cần hỗ trợ ra quyết định của máy tính. Ví dụ về điều đó trong C là câu lệnh if. Và trong RISC-V, không có câu lệnh if.
But there is its counterpart. I won't say it's an equivalent. It's a counterpart. That is a set of branch instructions.
Nhưng có một lệnh tương ứng với nó. Tôi sẽ không nói nó tương đương. Nó là một lệnh tương ứng. Đó là một tập hợp các lệnh nhánh.
Branch instructions are those that support decision making. They change the order of execution of instructions in the code.
Các lệnh nhánh là những lệnh hỗ trợ ra quyết định. Chúng thay đổi thứ tự thực thi của các lệnh trong mã.
So here is an example of one of those instructions, branch if equal. Mnemonic is beq.
Vì vậy, đây là một ví dụ về một trong những lệnh đó, nhánh nếu bằng. Mnemonic là beq.
And it compares the contents of the registers reg1 and reg2. And if they are the same, if they are equal, then it will jump to a label, L1.
Và nó so sánh nội dung của các thanh ghi reg1 và reg2. Và nếu chúng giống nhau, nếu chúng bằng nhau, thì nó sẽ nhảy đến nhãn L1.
Label L1 is just a symbolic address for another part of the code.
Nhãn L1 chỉ là một địa chỉ tượng trưng cho một phần khác của mã lệnh.
Otherwise, if the contents are not the same, it will execute the next statement, next instruction that is in our program. Next line, that is in our program.
Ngược lại, nếu nội dung không giống nhau, nó sẽ thực hiện lệnh tiếp theo, lệnh tiếp theo trong chương trình của chúng ta. Dòng tiếp theo trong chương trình của chúng ta.
beq has its counterpart, bne, which stands for branch if not equal. It will take a look at the contents of two registers. And if they are not equal, it will branch.
beq có đối ứng của nó, bne, đó là viết tắt của branch if not equal (nhánh nếu không bằng). Nó sẽ kiểm tra nội dung của hai thanh ghi. Và nếu chúng không bằng nhau, nó sẽ rẽ nhánh.
There are two types of branches in assembly. And RISC-V is no different than that. There are conditional branches and unconditional branches. Conditional branches basically evaluate something that we asked them to.
Có hai loại nhánh trong mã lệnh hợp ngữ. Và RISC-V cũng không khác như vậy. Có các nhánh có điều kiện và nhánh không có điều kiện. Nhánh có điều kiện về cơ bản là đánh giá một cái gì đó mà chúng tôi yêu cầu họ.
Examples what we have seen are already branch if equal and branch if not equal. But we can also compare magnitude.
Các ví dụ mà chúng ta đã thấy là branch if equal và branch if not equal. Nhưng chúng ta cũng có thể so sánh độ lớn.
So we have two instructions, branch if less than, which is blt, and branch if greater or greater than or equal, which is bge.
Vì vậy chúng ta có hai lệnh, branch if less than, là blt, và branch if greater or greater than or equal, đó là bge.
And then we have unsigned versions of those, bltu and bgeu.
Và sau đó chúng ta có các phiên bản không dấu của những lệnh đó, bltu và bgeu.
There is an unconditional branch, which in RISC-V is a jump. It is just encoded as j and then a label.
Có một nhánh vô điều kiện, đó là jump trong RISC-V. Nó được mã hóa là j và sau đó là một nhãn.
Whenever we run into that instruction, we basically jump to another location in a program. It's like a go to.
Bất cứ khi nào chúng ta gặp lệnh đó, chúng ta cơ bản là nhảy đến một vị trí khác trong chương trình. Nó giống như một go to.
It is always — as executed, it corresponds to an always statement.
Nó luôn luôn — khi thực thi, nó tương ứng với một câu lệnh always.
Now, when — somebody may ask, oh, can we just make an unconditional branch out of a conditional one?
Bây giờ, khi — ai đó có thể hỏi, ồ, chúng ta có thể chỉ tạo một nhánh vô điều kiện từ một nhánh có điều kiện không?
For example, we say branch if equal, x0, x0, label. Yeah, and that will definitely always jump to a label. But there is one subtlety there.
Ví dụ, chúng ta nói branch if equal, x0, x0, label. Vâng, và nó sẽ chắc chắn luôn nhảy tới một label. Nhưng có một điểm tinh tế ở đây.
The range of that branch, the range of branches, is shorter, because we are limited to 32-bit instructions in RISC-V.
Phạm vi của nhánh đó, phạm vi của các nhánh, là ngắn hơn, vì chúng ta bị giới hạn trong các hướng dẫn 32 bit trong RISC-V.
So these 32-bit instructions, you have to encode somehow the type of instruction, which kind of registers are we comparing, which ones of the 32 registers are we comparing.
Vì vậy những hướng dẫn 32 bit này, bạn phải mã hóa bằng cách nào đó loại hướng dẫn, chúng ta đang so sánh thanh ghi nào, cái nào trong 32 thanh ghi chúng ta đang so sánh.
And then there is a little bit to place the label, which is essentially an immediate value. In jump, we just say jump. And then have some kind of an immediate value.
Và sau đó còn lại một chút để đặt label, đó là về cơ bản là một giá trị trực tiếp. Trong jump, chúng ta chỉ nói jump. Và sau đó có một giá trị trực tiếp nào đó.
So the range of an unconditional jump is longer. It reaches farther. Let's take a look at a couple of examples of how does an if statement translate to RISC-V.
Vì vậy phạm vi của một jump vô điều kiện là lớn hơn. Nó có thể nhảy xa hơn. Chúng ta hãy xem một vài ví dụ về cách một câu lệnh if được chuyển thành RISC-V.
So here is a piece of C code.
Vì vậy đây là một đoạn mã C.
If i equal equal j, compares the values of i and j, then we should say that f equals to g plus h.
Nếu i bằng j, so sánh các giá trị của i và j, thì chúng ta nên nói rằng f bằng g cộng h.
Let's see how does that translate into RISC-V assembly. The first thing we need to figure out if i and j are the same. And their contents are in the registers x13 and x14.
Hãy xem cách nó được chuyển thành lắp ráp RISC-V. Điều đầu tiên chúng ta cần tìm ra là i và j có giống nhau không. Và nội dung của chúng nằm trong các thanh ghi x13 và x14.
And look at this. Here is something that might surprise you, but totally makes sense. Instead of saying branch if equal x13 x14, we are using bne.
Và nhìn vào cái này. Đây là điều có thể khiến bạn ngạc nhiên, nhưng hoàn toàn hợp lý. Thay vì nói branch if equal x13 x14, chúng ta sử dụng bne.
We are inverting this equal equal condition. Why are we doing that? It makes sense.
Chúng ta đang đảo ngược điều kiện equal equal này. Tại sao chúng ta lại làm điều đó? Nó có ý nghĩa.
Because if you think about how does the flow of execution go here, this is what happens.
Vì nếu bạn nghĩ về cách luồng thực thi chạy ở đây, đây là điều xảy ra.
If bne, branch if not equal, if these two, the contents of the registers are not equal, we will go this way.
Nếu bne, branch if not equal, nếu hai cái này, nội dung của các thanh ghi không bằng nhau, chúng ta sẽ đi theo cách này.
If it is not true, we'll go down. So in this case, in the C instruction.
Nếu điều đó không đúng, chúng ta sẽ đi xuống. Vì vậy trong trường hợp này, trong lệnh C.
We would like to add two numbers if i and j are equal, which is essentially what happens automatically on the next instruction if the branch is not taken.
Chúng ta muốn cộng hai số nếu i và j bằng nhau, đó là điều xảy ra tự động ở lệnh tiếp theo nếu không thực hiện nhánh.
So it does make sense, in this case, to flip this around and ask. Oh, if they're not equal, then jump around it, this instruction that we would like to do if they are equal.
Vậy nên nó có ý nghĩa, trong trường hợp này, để đảo ngược điều này và hỏi. À, nếu chúng không bằng nhau, thì nhảy qua nó, lệnh này mà chúng ta muốn thực hiện nếu chúng bằng nhau.
So if they're not equal, we'll jump around, or branch around, to be more precise, go to the exit. If they are equal, then the add will be executed.
Vậy nên nếu chúng không bằng nhau, chúng ta sẽ nhảy qua, hay nhánh qua, để nói rõ hơn, đi tới lối thoát. Nếu chúng bằng nhau, thì phép cộng sẽ được thực hiện.
Hopefully this made sense. This is a very common thing that we'll do. And it is very helpful if you think about it this way, the direction of true and the direction of false.
Hy vọng điều này có ý nghĩa. Đây là một điều rất phổ biến mà chúng ta sẽ làm. Và nó rất hữu ích nếu bạn nghĩ về nó theo cách này, hướng của đúng và hướng của sai.
Here's another example. It's an if else statement.
Đây là một ví dụ khác. Đó là một câu lệnh if else.
And it's exactly the same, that except that we added the x condition here that will take f equals to g minus h If i is not equal to j.
Và nó hoàn toàn giống nhau, ngoại trừ việc chúng tôi thêm điều kiện x ở đây sẽ gán f bằng g trừ h nếu i không bằng j.
Now, this one, you can do in different ways and all look similar. But let's stick to the idea that we always flip this original condition. So we'll have bne.
Bây giờ, cái này bạn có thể làm theo nhiều cách và tất cả đều trông tương tự. Nhưng hãy tuân theo ý tưởng rằng chúng ta luôn đảo ngược điều kiện gốc này. Vì vậy chúng ta sẽ có bne.
And then if bne is true, bne if x13 and x14 are not equal, we will skip to else.
Và sau đó nếu bne là true, bne nếu x13 và x14 không bằng nhau, chúng ta sẽ nhảy tới else.
In else, we'll sub, we'll subtract the two registers. And then we'll exit.
Ở else, chúng ta sẽ sub, chúng ta sẽ trừ hai thanh ghi. Và sau đó chúng ta sẽ thoát.
If bne does not branch, if this instruction doesn't branch, we'll execute the next one. So we'll add the f and j — the j and h and store it in f.
Nếu bne không nhảy, nếu lệnh này không nhảy, chúng ta sẽ thực thi cái tiếp theo. Vậy chúng ta sẽ cộng f và j — j và h rồi lưu vào f.
Now, there is a common mistake. And I've made it a gazillion times. And that mistake is by omitting this j instruction to exit. What happens if we don't have it there?
Bây giờ, có một lỗi rất phổ biến. Và tôi đã mắc nó hàng tỉ lần. Và lỗi đó là quên chỉ thị j để thoát. Chuyện gì xảy ra nếu chúng ta không có nó ở đó?
So then if we don't branch here, we will add the two — the contents of the two registers, and put them in x10.
Vậy nếu chúng ta không nhảy ở đây, chúng ta sẽ cộng hai — nội dung của hai thanh ghi, và đặt chúng vào x10.
Then, if there is no jump, we will execute the next instruction that will subtract the contents of two registers and put them in — put the result in x10.
Sau đó, nếu không có lệnh nhảy, chúng ta sẽ thực thi lệnh tiếp theo sẽ trừ nội dung của hai thanh ghi và đặt kết quả vào x10.
And we'll always do that. And we'll be looking at there, debugging this code, and scratching your head. Why do I never get this add to happen, even though I wrote it in there?
Và chúng ta sẽ luôn làm điều đó. Và chúng ta sẽ nhìn vào đó, gỡ lỗi mã này, và gãi đầu. Tại sao lệnh cộng này không bao giờ được thực hiện, mặc dù tôi đã viết nó ở đây?
Well because it gets overwritten. The contents of a register gets overwritten. So this j, this jump, is a must.
À, vì nó bị ghi đè. Nội dung của một thanh ghi bị ghi đè. Vì vậy lệnh nhảy j này là bắt buộc.
Just a quick words about the magnitude comparison in RISC-V. We said we already have them. We have branch on less than. We also have branch on greater or equal.
Một vài lời nói nhanh về so sánh độ lớn trong RISC-V. Chúng ta đã nói rồi, chúng ta có chúng. Chúng ta có nhánh nhảy nếu nhỏ hơn. Chúng ta cũng có nhánh nhảy nếu lớn hơn hoặc bằng.
But we do not have a branch on less — less than or equal. And we do not have a branch on greater than. Why?
Nhưng chúng ta không có nhánh nhảy nếu nhỏ hơn — nhỏ hơn hoặc bằng. Và chúng ta không có nhánh nhảy nếu lớn hơn. Tại sao?
Because we are trying to save to reduce the number of these instructions. And those are absolutely not necessary.
Vì chúng ta đang cố gắng để giảm bớt số lượng của những lệnh này. Và chúng hoàn toàn không cần thiết.
We get them by flipping the order of two operands, the contents of the two registers that we would like to compare. So they're absolutely not necessary.
Chúng ta có thể có được chúng bằng cách đảo ngược thứ tự của hai toán hạng, nội dung của hai thanh ghi mà chúng ta muốn so sánh. Vì vậy chúng hoàn toàn không cần thiết.
But what is necessary is to have an unsigned version of a branch.
Nhưng những gì cần thiết là có một phiên bản không dấu của một nhánh.
So there is a bltu and bgeu that compare the unsigned versions of the integers.
Vì vậy có bltu và bgeu để so sánh các phiên bản không dấu của các số nguyên.
It's really important to remember which one are we using when. So whenever we are comparing signed numbers into this complement, we are using blt.
Thực sự rất quan trọng để nhớ chúng ta đang sử dụng cái nào khi nào. Vì vậy bất cứ khi nào chúng ta so sánh các số có dấu trong bù đến hai, chúng ta sử dụng blt.
And if we would like to compare unsigned, it is a bltu. Now one thing that is kind of convenient to remember here, which instruction do we have?
Và nếu chúng ta muốn so sánh số không dấu, thì đó là bltu. Vâng, có một điều khá tiện lợi để nhớ ở đây, chúng ta có lệnh nào?
Do we have blt in our instruction set or bgt? Well, the way I remember it is by remembering that there does exist a type of a BLT sandwich.
Chúng ta có blt trong bộ lệnh hay bgt? Vâng, cách tôi nhớ nó là bằng cách nhớ rằng có tồn tại một loại bánh sandwich BLT.
But they have not yet seen BGT sandwich. BLT stands for bacon, lettuce, tomato. All right, let's move on and take a look at a little bit more complex control.
Nhưng họ chưa từng thấy bánh sandwich BGT. BLT là viết tắt của bacon, rau diếp, cà chua. Được rồi, hãy tiếp tục và xem xét một chút điều khiển phức tạp hơn.
So you'll find different types of loops and see, for example, while, do while, and for.
Vì vậy bạn sẽ tìm thấy các loại vòng lặp khác nhau và thấy, ví dụ, while, do while, và for.
They are mapped on exactly the same set of branching instructions that we have seen so far. No difference there. Let's take a look at a little bit more complex example here.
Chúng được ánh xạ chính xác cùng một bộ các lệnh rẽ nhánh mà chúng ta đã thấy cho đến nay. Không có sự khác biệt nào ở đó. Hãy xem xét một ví dụ phức tạp hơn một chút ở đây.
So here is a part — here is a piece of C code that looks at an array of 20 integers and adds them all up.
Vậy đây là một phần — đây là một đoạn code C để xem một mảng gồm 20 số nguyên và cộng tất cả chúng lại.
So color coding here is used to easily identify what goes where, which registers correspond to which variables.
Vì vậy ở đây sử dụng mã màu để dễ dàng xác định chúng tương ứng với biến nào, thanh ghi nào tương ứng với biến nào.
So first, we'll take the pointer to the first element in the array, A0 and copy to register 8. Because we are going to be changing it. And we do not want to destroy it.
Vì vậy trước tiên, ta sẽ lấy con trỏ đến phần tử đầu tiên trong mảng A0 và sao chép vào thanh ghi 8. Vì chúng ta sẽ thay đổi nó. Và chúng ta không muốn phá hủy nó.
That's another good practice that we would like to use in the assembly. We don't want to destroy the content — the starting content of that register, because we may need it later.
Đó là một cách thực hành tốt khác mà chúng tôi muốn sử dụng trong code assembly. Chúng ta không muốn phá hủy nội dung — nội dung ban đầu của thanh ghi đó, vì chúng ta có thể cần nó sau.
Then we need to initialize everything. We'll initialize sum to 0, index i to 0.
Sau đó chúng ta cần khởi tạo mọi thứ. Chúng ta sẽ khởi tạo sum thành 0, chỉ số i thành 0.
And we do need to store the final value 20 in the register x13, because we'll need to compare the i to that value and find out if we have completed our summation.
Và chúng ta cần lưu giá trị cuối cùng là 20 vào thanh ghi x13, vì chúng ta sẽ cần so sánh i với giá trị đó và tìm hiểu xem chúng ta đã hoàn thành phép tính tổng chưa.
Remember, we don't have branching with immediates in RISC-V. Contents of both variables that are going to be compared need to be in the register. So there is no comparison to an immediate.
Hãy nhớ, chúng ta không có nhánh với các giá trị tức thì trong RISC-V. Các nội dung của cả hai biến sẽ được so sánh cần phải nằm trong thanh ghi. Vì vậy không có so sánh với một giá trị tức thì.
So let's start our loop. Here is the start of the loop. And there is one really important thing that I want everybody to remember.
Vậy hãy bắt đầu vòng lặp của chúng ta. Đây là khởi đầu của vòng lặp. Và có một điều thực sự quan trọng mà tôi muốn mọi người nhớ.
Test the condition if you should exit right away, because it's the same logic that we have been following so far.
Kiểm tra điều kiện xem bạn có nên thoát ngay hay không, vì đó là logic tương tự mà chúng ta đã tuân theo cho đến nay.
If the condition to exit the loop is true, we just go to the end, to done. So in this case, if x11, if i has reached 20, we just go to done.
Nếu điều kiện để thoát vòng lặp là đúng, chúng ta chỉ nhảy đến cuối, đến done. Vậy trong trường hợp này, nếu x11, nếu i đã đạt 20, chúng ta chỉ nhảy đến done.
That's yes. If not, we stay inside the loop. So when we are in the loop, we load the next value of the next element of A into register x12.
Đó là đúng. Nếu không, chúng ta ở lại trong vòng lặp. Vì vậy khi chúng ta ở trong vòng lặp, chúng ta tải giá trị tiếp theo của phần tử tiếp theo của A vào thanh ghi x12.
We add it to the running value of the sum, which is in x10. Then we increment the pointer. Remember, we would like to load the next integer. Integers are four bytes wide.
Chúng ta cộng nó với giá trị chạy của tổng, nằm trong x10. Sau đó chúng ta tăng con trỏ. Nhớ lại, chúng ta muốn tải số nguyên tiếp theo. Các số nguyên rộng bốn byte.
RISC-V addresses every byte in the memory. So we need to increment this pointer by 4. This is a very common mistake.
RISC-V địa chỉ từng byte trong bộ nhớ. Vì vậy chúng ta cần tăng con trỏ này lên 4. Đây là một lỗi rất phổ biến.
Always keep that in mind, because you are going to be having a fun time debugging this if you are not incrementing — if you're working with integers and not incrementing memory pointers by 4.
Luôn ghi nhớ điều đó, vì bạn sẽ gặp rất nhiều khó khăn khi sửa lỗi này nếu bạn không tăng — nếu bạn đang làm việc với các số nguyên và không tăng con trỏ bộ nhớ lên 4.
We increment i by 1. And that's basically it. We jump back to the beginning of the loop. When we are just missing one more label, which is done.
Chúng ta tăng i lên 1. Và cơ bản là vậy. Chúng ta nhảy quay lại đầu vòng lặp. Lúc này chúng ta chỉ còn thiếu một nhãn nữa, đó là done.
To say that we have exit in this loop. And that's it. That wraps up our discussion of branches. See you in a bit.
Để chỉ rằng chúng ta thoát khỏi vòng lặp này. Và vậy thôi. Đó là kết thúc phần thảo luận về các nhánh của chúng ta. Tạm biệt.
Đă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.