UCB-CS61c-组成原理中文笔记-一-

UCB CS61c 组成原理中文笔记（一）

P1：Lecture 1： Intro - 这样好__ - BV1s7421T7XR

很高兴你今天能来，我叫丹•加西亚，我们很高兴为你们带来这门课，我们总是从新闻中的计算开始，但让我们从今天的珍妮特·杰克逊的歌开始，会把窗户撞坏，XP笔记本电脑，原来这里面有一定的声音频率。

在珍妮特·杰克逊的歌曲中，不仅让笔记本电脑崩溃，它在继续播放，但它可能会让附近的笔记本电脑崩溃，我喜欢这个，各位今天的家庭作业是找到那首歌，看看你能撞倒多少台笔记本电脑，你的邻居，找点乐子。

所以我们要谈谈这门课，当然被称为计算机体系结构中的伟大思想，也称为机器结构，我要做第一部分，我把它交给了丽莎，最后把它们还给了我，让我做一些后勤工作。

免得你以为我们把这门课叫做，教你关于c语言的知识，那是不正确的，一切都是关于奇妙的硬件，软件接口，计算机是如何工作的，但不仅仅是一台电脑，数据中心的实际工作方式，我们不谈论语言，像C更接近低层硬件。

我们称那些更接近硅的，所以这就是为什么我们用C来教你，否则，你就会在Python中四处漂浮，抓拍和计划。

你从来没有真正使用过真正的硅，所以凯撒真的很好的语言，这是六二一C的老派版本，这是一张假照片，但这就是我们的想法，如果类比是，我们以一种新的奇妙的方式来教授这门课，这是课程的旧版本，六十一c。

这是新的61 C，这是C思考的事实，我们一直使用的，从你的特斯拉到你的无人机，输入你的手机，移动设备和网络边缘设备，今天你们将了解到所有这些是如何在一个大的图景中工作的，它们都在云中与后台一起工作。

在移动设备上与前端一起工作，或者较小设备上的前端，所以后端就是云，这个，我在数据中心的朋友们，我们将讨论这些是什么，以及如何设计它们，有什么限制，所以当你要，如果你说嘿，让我们建一个新的数据中心。

你在想什么，这是这里面的画面，我的另一台电脑是数据中心，每一个社交媒体应用程序在很大程度上都使用它作为后端，那到底是怎么起作用的，今天连电脑都是怎么工作的，今天这门课你将学习所有这些伟大的想法。

所以在旧学校里，我们只关注一台电脑，单线程的单台计算机，一个单一的进程可以运行并进行一些计算，那是老派，这是一个大局课程，太棒了，我的朋友是硬件软件界面，中间那条大黄线叫做指令集架构。

即硬件和软件接口之间的连接，他们就是这样一起工作的，你会知道，到那年年底，在旧学校，60岁的人会看到，你知道从高层，从C申请，一直到晶体管。

制造与电子移动，很酷的东西，那是老派的做法，大学校，有点复杂，所以我们有一个仓库秤，硬件方面的计算机，智能手机被开进里面，其中一个服务器是多核的，带着记忆，也许是缓存，很多不同的缓存，缓存级别。

输入输出设备，在那个核心里，你已经处决了行刑队，主存储器，我们将学习CPU设计，这不仅仅是，我学习如何编程和查看，你在学习如何构建，如何设计体系结构，做一个CPU，多么强大的课程，我喜欢这门课。

在最低层，你了解了逻辑门，就像你从上到下学习一样，从硬件到软件，我们是真正强大的东西。

我们将以五种不同的方式利用并行性，吊杆并行请求，平行线程，你知道这些意味着什么，在本课程结束时，并行指令，并行数据和硬件描述，在那里硬件都并行运行，同时这里很滑。

别滑倒了，这就像肥皂一样的东西，我要把它交给丽莎，接手第二部分，我们走右边，好啦，本课程名为计算机体系结构中的伟大思想，我要向你展示伟大的想法。

他们有六个人，十二月十二日见，为了决赛，下课了，开玩笑的啦，好啦，所以向你展示伟大想法的意义，在第一节课中，就是不断地应用它们，在接下来的14周里继续和他们见面，然后是阅读周，然后是期末考试周。

所以让我们来看看这些，当我们第一堂课介绍他们的时候。

你会开始越来越了解他们，头号抽象，你们都拿了六十一，或者你们中的大多数人都拿了61分，抽象是您在Python中反复看到的东西，我们有点事情，在那里一切都可以是一个名称函数，图书馆价值。

事实证明，这种抽象的想法也发生在硬件中，我们将在头五周使用的最大的抽象之一，所有东西都可以是一个数字位，零和一，这是我们将再次讨论的问题，再一次，是啊，是啊，一路下来都是乌龟，所以数字一直在下降。

所以这实际上是某种模因，在最底层好像有只世界龟，上面有只乌龟，上面的乌龟，想象一下这里的乌龟是一个抽象。

我们将有的第二大想法，这个伟大的想法叫做摩尔定律，所以戈登·摩尔实际上是奶牛的校友，去吧，在1965年就预测到了大海，十七十年左右，在最初的几个计算机芯片被创造出来之后，并说嘿，这个叫晶体管的东西。

它们是所有芯片产生的基础。

他们大约每两年翻一番。

这太棒了，因为这意味着制造的东西越来越便宜，它将超越创新，所有这些在计算机体系结构级别上的东西。

为什么叫摩尔定律，嗯，事实证明，这是一种自我实现的预言，每次芯片制造商想做什么，它们就像摩尔定律，摩尔定律，我们得让这一切，我们一定要做到这一点，所以，因此，你看，摩尔定律一直持续到2005年左右。

对于那些想知道，好啦，不是每两年两次X吗，它不像指数曲线，在y轴上发生了什么，这就是所谓的对数刻度，好啦，所以这里的每一个都是向上，向上，向上的指数，在x轴上我们有年份，这个对数线性图是一条很棒的线。

那实际上是指数级的，这里有一些很酷的薯条照片，以防你从来没有，你以前从没见过他们，回到1972年，这是情报，八千八百三十五个晶体管，不错嘛，二十年后，英特尔奔腾，有多少晶体管，三点，一百万个晶体管。

更好的是。

我们今天在哪里，很多晶体管，这里有一个相关的定律，叫做a定律，那么我们看到了什么，A的数字一直在上升，上升，上升，到了1970年，我们会得到百分百的A，但我们都谈过，我们将在这节课中讨论评分。

丹和我都是伟大的信徒，所以说，如果这是一个学期，我们可以得到所有年龄和61 C，我们很高兴，是吗？那我们稍后再谈，十五分钟左右真的。

让我回到摩尔定律上一会儿，所以这是一个更新的图表，我知道这里有点不稳定，这是一九七万二千零五年，我们之前看到的大概在这里，然后这个是20，让我们来看看这个二五二五地区，好啦。

我们实际上是从摩尔定律逐渐缩小的，我们不再以指数级增长，发生什么事了，还有什么好主意，我们能再多说一点吗，稍后，第三个好主意是局部性原则。

所以为了解释局部性原理。

我将从我们自己的吉姆·格雷的一个不同的类比开始，他也是一个卡勒姆去啤酒，所以吉姆·格雷有了这个想法，上面写着，好啦，让我们想想从内存中检索一些东西需要多长时间，让我们想想我们的人脑，好啦。

想象一下这是我的头，站在这里的这个人，如果我想从我的大脑中恢复一些东西，理想情况下只需要一分钟，通常少一点，也许我忘了什么，虽然，就在房间的尽头，我要走过去，可能就像，你知道的，90秒左右。

也许我现在把什么东西忘在办公室了，如果他们穿过校园，又是十分钟，以此类推，同样的类比也发生在记忆上，所以这个想法是叫做计算机寄存器的东西，我们将在几周内详细讨论，如果我们想从那里取回什么，这将是一纳秒。

十比九秒，但如果我们忘了什么东西或寄存器，我们得回到储藏室，这不会太糟糕，只需要两纳秒，但如果我们忘记了什么，突然需要100纳秒，这里的类比是，也许我在加州大学忘了什么，我得去萨克拉门托。

离这里一个半小时的路程，好吧，也许我需要从内存中的磁盘中得到一些东西，一切都会好起来的，与我相似，去冥王星，试图得到一些东西等等，等等，所以这种事情很接近的想法，花了很短的时间。

这是我们将一遍又一遍地看到的事情。

这是同一张图，只是有点翻转，所以你看，注册在这里的最上面，就在CPU核心之后，这意味着什么，这个金字塔说的是当你沿着金字塔往下走，事情的变化是一个数量级的，所以在最上面，这是极快的，极其昂贵。

当你一层一层往下走时，微小的容量，嗯，东西变得便宜了一个数量级，而东西变得更大了一个数量级，但也会慢一个数量级，所以我们会一次又一次地看到这个原理，局部性原理，你如何访问金字塔下的东西。

最后健身最后被优化。

好主意4叫做平行，我们会在这节课中看到三个不同的版本，其中之一叫做指令级并行，你以前没见过这张图，你就像，这张图是什么，我有个主意，我们将在四周后再次访问它，就是这里的每一个竖条。

这些就像你CPU里的时间周期，时隙，三件事同时发生，有三种不同的指令，一个人在执行指令，另一个人在解码指令和指令，三个开始看到他们有什么指令正在从记忆中提取，这是指令级并行。

因为CPU同时被三个指令共享。

我们将要看到的另一种并行是线程级并行，计算机上的每个线程都在做一件工作。

最后他们又一起回来了，最后是我们会经常看到的最后一个，右边这个叫数据级并行还是中间这个叫数据级并行，这是这个想法的旧版本，然后左边是谷歌文档的想法。

但这样想吧，你有一个庞大的团队项目，然后你有，假设三个小组成员，你把工作分给三个小组成员，他们每个人都可以做一个数据，然后在最后把它合并在一起，这就是数据级并行性--太棒了。

不过，有一个警告，所以这种并行的想法意味着你可以越来越快地做事情，嗯是做法律的，不过，说得很好，事实上，如果你平行行驶，你能加快多少速度是有限制的，我要强调这个词，这里。

它说性能的提高受到软件处理比率的限制，必须按顺序执行，这是什么意思，让我们再想想谷歌Dox的场景，假设你在做一个庞大的集体项目，你就像，但后来，教练说，嘿嘿，你知道你可以让尽可能多的人参与进来，你说好。

好啦，如果我让班上的每个人都这么做，也许班上有一百万人，这就是你喜欢的工人数量，我可以完成，这是超级超级快，但后来教练说，好啦，但我只打算在第七周分配，所以学期过半。

这意味着你所做的连续工作是你50%的时间，即使你有一百万人，一百万工人做同样的工作，你的速度只有2，我就是那些骗子，这种想法是等到所有这些顺序工作完成后，你真的可以优化所有并行的东西。

这是我们将一次又一次地看到的东西。

想法五，这个更微妙一点，这就是所谓的性能度量和改进，到目前为止，你在很多计算课上看到的，这种优化的想法，试图使某事尽可能快或尽可能有效，但这种高效或快速的想法，有点软，这有点像说你有一些艺术作品。

你想欣赏艺术是好是坏什么的，你知道这里缺少一些指标，所以计算机体系结构中的一个伟大的想法是如何改进这个想法，所以我们要把重点放在权衡上，这两个指标，即延迟和吞吐量，延迟是指从你得到任务到。

当你完成任务。

这是我们要优化的东西，这实际上是一个非常重要的指标，其中一个巡回演出奖得主，我们以后会看到的，我想出了这个主意，我就像嘿，你知道的，这是我们真正应该关注的事情，专注于这个指标，并尽可能地优化它。

想法六，所以这是我们将要考虑的第六个好主意，会有很多其他的好主意，你认为会很好，那也不错，你可以有自己的好主意清单，但对我们来说，第六个是通过冗余来实现可靠性的想法。

我是什么意思，嗯，这里有一个例子，也就是说，当我们考虑数据时，当我们思考正在发生的事情，事实证明，只是随机的东西可以打破，所以我要点击这个视频，也许它以前会弹清唱剧，是啊，是啊，是啊，是啊，好啦，岩石。

所以如果你没去过探险馆，这是探索馆的展品之一，叫做云室，云室是一种可视化宇宙射线的方式，就在我们周围，如果你觉得这听起来很古怪，看看这个，让我们看看更刺激的，所以你看到的所有这些不同的东西。

这些正在发生的一缕缕，那些是亚原子粒子，其中一些是电子，当这些电子一次又一次地撞击你的晶体管时，你的跃迁电子会疯狂，他们有时会随机翻转，你就像，我能控制宇宙吗，这就是51C的意义吗，没有井。

61个C是关于适应这个的，只是要知道有些事情即将发生，如果有什么事情要发生。

然后您希望构建冗余，所以我的意思是，假设你，你觉得有些事情非常非常重要，你想要得到正确的答案，你把它给一群人，三分之二的人给了你正确的答案，或者更确切地说，三分之二的你给，给你同样的答案，一加一等于二。

一个人流氓，然后说一加一等于一，你占了多数，你说，好啦，我只接受大多数人的回答，这种冗余的想法又是什么，我们将一遍又一遍地看到，增加晶体管密度降低冗余成本。

允许你创造这些东西，我们要去，所以说，下面是我们将如何一遍又一遍地看到这一点的例子，它适用于从数据中心到存储再到内存的一切，即使是像导师这样的人，让我向你展示这里的数据中心是如何。

你们中有多少人知道亚马逊建立了已经完成的蚂蚁数据中心，好的，好的，我只看到几个人，你就像，所以说，什么是冗余数据中心，甚至意味着如果有一个巨大的雷暴，或者停电了，这样。

亚马逊就不会立即丢失单个数据中心内的所有数据，它实际上在其他数据中心放置了客户数据的用户数据副本，所以如果一个数据中心坏了，整个系统不会瘫痪，它一直在运行第二层，我们将看到，这是冗余磁盘或突袭的想法。

所以这个，呃，这个突袭的想法是说，好啦，嗯，如果您可以在数据中心级别，这在现实生活中并不是这样的，从拉斯特开始，但跟赖特说，好啦，如果我们从这个开始，我们可以有多个磁盘，也许我们会有一个额外的磁盘。

如果其中一个磁盘也坏了，现在可以节省内存，或者你可以保存我们所有的数据，如果其中一个磁盘坏了，最后，在位级别上，我们也有这个，纠错码，所以一个字节是八位，这就是这应该代表的，这是德拉姆，我知道。

我知道八位的时候我们会再加一点以防万一，这样我们就能适应识别，当我们在传输中出错时，但这六个好主意你可能会想得很好，难道不是解决了计算机体系结构，我将谈谈为什么计算机体系结构在今天令人兴奋。

尤其是为什么加州大学伯克利分校。

这里有一个观察，也就是说，用于所有这些不同应用的设备数量正在不断增长，正在发生的事情的不同应用也在不断多样化，所以回到1970年，我们有这些科学计算，我们有一个设备到整个房间，那是一台巨大的巨型计算机。

当我出生的时候，有这些东西叫做个人电脑，那里，还有一个叫做万维网的东西，我们也开始看到某种数据中心的工作，大约在你们中的许多人出生的时候，你看到了个人电脑，但你也看到智能手机出现在不同类型的应用程序中。

然后在未来大约2030年，甚至现在，我们看到云的增长比万维网时期多得多，有史以来，我们看到医疗保健设备，我们看到VR，我们看到AR，我们看到娱乐，我们看到所有这些具有不同应用的设备，的确。

机器学习对他们中的许多人来说是常见的，但不是全部，图形是一个非常不同的应用程序，然后机器学习，因此需要有不同的硬件来适应。

所以原因是这样的，第一名，为什么计算机体系结构令人兴奋，首先摩尔定律有些极限，我的意思是，这是晶体管的数量--它还在增长，所以我把图延伸到这里，所以你看图表是到20点10分左右，我把图表延伸到过去十年。

它在生长过程中逐渐变细了一点，所以人们所做的是说，好吧好吧，如果我们不是每两年得到两个X晶体管，让我们增加核心的数量，增加并行性，然后能够增加我们芯片上的性能，然而，有一些权衡，也就是说。

如果您使用单个线程，单线程类型的系统，单循环系统，然后你实际上受到可以输入芯片的功率的限制。

因为毕竟你们都在运行计算机，而计算机现在并没有着火，所以必须有某种现实的限制，你能以多快的速度或多少东西发送到你的设备上，这就是第二个原因，我们在两张幻灯片前的预科中看到了，就是有这个或CC。

新时代来临了，或者是一个叫做领域特定计算的时代的回归，我的意思是每个领域都需要异构的系统，之前谈到了一点图形，这与机器学习有何不同，Gpus和神经处理单元，Npus是不同的，所以这里实际上是一个15。

苹果，一个15英镑的仿生芯片，那是，呃，它已经部署在iPhone SE中，还有iPhone13和一些iPad，如果你非常非常仔细地看这张图，这里有许多不同的CPU，有一个，有一个GPU设备。

有一个NPU设备，有不同级别的缓存，所有这些不同的芯片都被放在这家潜水店。

所以所有这些不同的应用意味着计算机体系结构是令人难以置信的令人兴奋的，所以这里有一个古老的传统智慧，然后我将向你们展示计算机体系结构是如何革命性的，传统的观点是，你应该把这些通用的架构，由于摩尔定律。

你将继续得到性能，实际上每周会增加一个，用专门的计算机进行设计是愚蠢的，因为当你做完的时候，设计那个美丽的东西，摩尔定律将超越你，下一代通用将会问世，这将比你所能做的任何新的传统智慧都要好。

但是要设计特定领域的体系结构，下面是谷歌的张量处理单元或TPU的一个例子，其实呢，这是谷歌的TPU三号，这是发布的，我想两年前，这是一个专门训练神经网络的引擎，如果你仔细看，这里有四个不同的单元。

它们都是液冷的，这就是这里和那里的银线，仅在谷歌的数据中心可用，所以连接到这些东西并运行这些东西的唯一方法是通过云，谷歌实际上，呃，去年，我想发布了一种叫做TPU Edge的移动类型的TPU，这也很酷。

但对于不同的领域，仍然是机器学习，但现在在移动可携带设备上。

最后，为什么伯克利很重要，几年前，大卫帕特森和约翰轩尼诗凭借他们的思想获得巡回演出奖，围绕平行，以及周围的城市，呃，围绕计算机体系结构，我这里有一个小幻灯片吗，所以他们做的一件事就是。

当每个人都在为芯片设计越来越复杂的体系结构指令集时，如果我们缩减这些指令集的复杂性，做了一个叫做简化指令集的东西，原来他们被嘲笑了，它实际上是风险的概念，你将会看到，我们会我们会了解，风险五。

风险五用在很多芯片上，今天有很多很多的建筑，所以他们几年前获得了图灵奖，有一个想法真的像，无视传统智慧，每个人都像，你为什么不把所有的复杂性都放进去，他们说不，我们希望专注于吞吐量。

我们想很好地关注潜伏期，图灵奖是什么，巡回演出的奖品是什么，好问题，丹耶，所以说，所以术语，你们中有多少人听说过诺贝尔奖，太棒了，所以巡回演出奖就像ecs诺贝尔奖，所以实际上。

你之前看到的几个人吉姆·格雷也获得了图灵奖，图灵奖通常授予那些真正做出重大创新的人，它们改变并革新了计算机的工作方式，革命发生的方式之一是像，呃，从轩尼诗和帕特森这里，其实呢，他们实际上已经写了教科书。

接下来我们会讨论这个问题，关于这门课你需要知道什么，好吧，首先我们需要听听尤达的意见。

所以我们尽量把我们的日程安排好，但总是在运动，未来是，是呀，丹娜的嗓音确实比许多人都好，多年，和许多不同的61 C讲座，关于这门课，我们将简短地谈谈课程中的不同组成部分，今天剩下的课，但首先。

让我承认这门课背后的人类，所以这门课的幕后黑手是丹和我，但更重要的是，是所有的教职员工，但是，因此，工作人员为你创建了一个课程网站，我要做的是，我要点击课程网站看看会发生什么。

是啊，是啊，是啊，是啊，是啊，是啊，我们可以看到一点点，所以说，如果你去CS 61 C点组织，如果你去CS 61 C组织，这是课程的所有信息都很好的地方，除了ED梗，我们稍后会讲到。

所以你可以在这里看到，第一课到了，如果你点击这个链接，你会看到PDF的，我们会尽量在上课前把课堂讲稿寄出去，然后我们有时会在上课前给你们打印输出，如果你想，如果你喜欢硬拷贝，看看这里，有必修课。

哪些是课程政策，我要点击这个链接，您也可以访问这里的链接，课程政策在这里，这是我们的课程大纲，非常重要的是，你要阅读这里的每一个组件，因为如果我们坐在这里讨论整个课程大纲，可能要一个小时。

但我怀疑你们中的许多人阅读东西的速度比，我们需要谈谈，我们会指出课程大纲的重要部分，今天的课，我想让你们注意的第二件事是Ed Stem的想法。

是我们的课程论坛，我们不再使用广场了，我们在用一种叫做ed的东西，所以你们所有人，如果你注册了这个班，您应该收到并邀请参加我们的课程论坛，所有的课程通知都会在这里，所有的任务发布都将被炮轰，在通知方面。

如果你有任何问题或澄清，一切都要经过这里，我们班大约有720人，好多人啊，这就是我们要使用的课程形式，因为当有人和你有同样的问题时，如果你不在这个课程表上，然而，请给我们发电子邮件。

我们的课程工作人员电子邮件在CS 61 C org上，它实际上是加州大学伯克利分校的，第二件事是读数，所以你就像，好啦，丽莎，我要在这门课上做阅读吗，一切都是可选的，除了今天的必读，阅读课程政策。

但我想向教科书大喊一声，因为我很喜欢课本，所以这里有一些，以下是一些读数，我把课本带来了，以防你对它们的样子感兴趣，其中之一出自图灵奖获得者之手，帕特森和轩尼诗，这是计算机组织和设计的风险五版。

这个有两个版本，你可以用任何一个，这里的第二个被称为C圣经，这是开襟羊毛衫和里奇，C编程语言，这是我真的很喜欢纸质的东西，但它也可以在网上免费获得PDF格式，世界上每个C程序员的桌子上都有这本书，是呀。

整本书里的每个人，这就是，但这个其实昨天在我枕头下面，当我在想今天的讲座时，你知道的，只是想稍微进入状态，但同样，这门课并不完全是关于C的，所以可能几周后就结束了，我把这个也放在枕头下面。

第三件可选读物是，它将在课堂上晚些时候出现，它被称为计算机的数据中心，这个也可以在网上免费获得PDF格式。

好吧，几个，合唱部分总结，其中之一就是讲座，欢迎各位亲临现场，欢迎来到Zoom的每一个人，所以这是周一周三和周五一小时，我们会录下来的，对于那些真正喜欢这门课的人来说，你们将永远有这个机会。

当我想回来的时候，我们将在下午四点钟上同样的课，如果你只是想再次感受那种感觉，我们星期五会在这里，从那里开始，我们就有这个十点的时段了，然后其他几个部分，我将成对地讨论，其中之一是讨论和家庭作业。

在这里我们将讨论概念性的东西，所以这门课的家庭作业是，实际上你要把它提交给，这个叫草原的东西，学习，整个学期你就会有很多这方面的经验，第二部分，你实际设计、调试、编码和编程，这将在实验室和项目中，好啦。

所以这是另一个，其他两对作业，只是一个关于讨论和生活的笔记，我们有一些关于井的问题，第一节是什么时候，我已经准备好从61 C开始了，我们下周将在现场直播中开始讨论，但是，我们有一个安装实验室。

只是为了确保你所有的机构账户和东西，一切都在进行，你的GitHub已经设置好了，所有这些事情，这是这将是可用的，如果今天结束前还没有在网站上，这将是应得的，下星期一，如果你对此有疑问。

我们刚发邮件给艾德，我们可以帮你安装，最后期中考试和期末考试都没了，这是课程的最后一部分，我们稍后会和丹谈谈，我想说的第二套课程元素是我们如何帮助你。

我说过教育署的课程表格，这是如何获得异步帮助的一个非常重要的部分，但如果您不需要同步帮助，请亲自帮助，我们会有办公时间，这些叫做项目方的东西，所以在办公时间，我们将有两种类型，我们将有助教类型。

那些将是亲自或混合，这些将是球杆基础，所以你要排队，所有的说明都在我们的课程政策页面上，所以导师是丹和我，这些将以个人和小组为基础，更多的是专注于概念，助教的办公时间是用来分配任务的，实验室。

家庭作业项目，所有这些事情，也为考试做准备，谈论那些考试问题，项目方，第二颗子弹，我们整个学期都有，离项目截止日期很近了，所以这样你就能玩得很开心，嗯是的，我们会在这个项目中玩得很开心，可能是明智的。

是啊，是啊，会是，会很棒的，然后这里的最后一部分是这个扩展形式，然后我们再谈谈这个，还记得我说过的王牌吗，还记得我们说过百分之百的王牌吗，我们在这门课上真正希望发生的一件事，是为了你们所有人的成功。

所以如果你需要什么，如果你赶上最后期限，如果你压力很大，只要六十一，见，你们有多少人，呃，我们的二年级学生，你们中有多少是三年级的，你们中有多少人是高年级，继续摇滚，你们中有多少人是五年级的学生。

硕士生，大一新生，大一新生，重要的是你们所有人都在经历一个非常重要的，就像你生命中的一个非常过渡的时刻，Dan和我希望能让你养成好习惯，我们想在61年养成的一个好习惯就是交流，请让我们知道。

如果我们的政策对你不起作用，如果你需要帮助，如果你需要扩展，只要把它通过表格发送，我们一会儿再谈这个。

是呀，对呀，谢谢你，谢谢你，杰出工作，杰出工作，到目前为止，好极了，好啦，延期表格，所以扩展形式是，它有两个部分。

所有，做这件事的任务，午夜前一分钟，有两种形式。

一个用于正常扩展，这就像你知道不到一周我们过去有一个叫做滑日的东西，你有几天不顺利，你可以用它们，我们用光它们，你被困住了，你真的必须在每个最后期限前完成，我们说你知道生活会阻碍。

尤其是在Covid时代，我们还在继续，所以如果你需要不到一周的时间，填写正常扩展名，就像不用担心，如果你需要更多的时间，也去吧，我们会说不用担心，但我们要好好谈谈，你需要一些支持服务吗。

也许我们可以指引你去心理健康服务中心，身体健康服务，也许是一些Covid的东西，无论你怎么称呼你，并真正与你联系，所以如果你需要一周以上，我们会跟你谈的，但你还是很酷，如果你需要不到一周。

我们想和你谈谈，你还是很酷，但我们只是一种文件，你需要一点，仅此而已，不是翻转，日子总是问，如果你需要支持，所以不要，不要犹豫。

生活发生了，我们是来帮忙的，好啦，我们是站在你这边的，期中考试，我们将有两次考试，第一个将是一个创造性的新事物，我们以前从没做过，这真的很有趣，所以我们将有第一部分，他将亲自出席，我们从来没有这样做过。

闭卷，通常有一张学习表，不再有学习单，闭卷，走进去，但范围比以前小了，以前是一个很大的范围，八个星期的一切，是的，你必须有学习问题才能让你跟上，没有更小的范围，我们要把所有的程序，大C代码。

把问题带回家，那种项目就单干，自己动手，带回家花一整天的时间做这件事，连时间都没有，去吧，去吧，动手吧，只要向我们证明你能做到，很酷，就像面试，如果你有面试，他们会说嘿，教他们C，但我甚至不会给你计时。

你只管去吧，慢慢来，当你完成的时候，它在那里，我们甚至会给你这样的，你知道的，当你完成而不是喜欢，啊，我不知道，如果我做了，否则我会给你所有的测试，当你通过测试，你可以停下来，那不是很神奇吗。

那就是座位，是呀，哼，是呀，是呀，就在那里，就在那里，它是，当你填写那些小调查时，请记住这一刻，记住此刻，好啦，呃，第二个和风险五一样，我们教你如何用汇编程序编程，嗯。

为什么不给你尽可能多的时间来编写汇编程序呢，让它发挥作用，当你得到它的工作，我们会给你测试用例，它的工作原理，所以这些都是期中考试的，现在你只要慢慢来，把他们搞定，但你显然是自己做的吗。

不要指望你的邻居，但你知道谁会相信你，这件事我们相信你，再说一遍信任，伯克利荣誉守则怎么样，挺酷的，交易权，好啦，那我们就说好，那么好吧，一旦期中考试取消了，什么剩下的好。

也许一些叫做同步数字系统的SD，也许数字是如何工作的，可能是一些浮点，简单的东西，也许一些关于比特如何工作之类的C，简单的东西，你得去实验室拿，但是但是没有，没有笔记，你走进来坐在实验室里。

你知道他们会去实验室学习一些东西，我们下去坐下，在那90分钟里学点东西，现在你安静地进去，安静地参加考试，然后你走了，就这样，所以这有点像，我们把你期中考试的所有东西都拿走了，去掉了很多。

现在有一个小婴儿的部分，你必须建造它，你真的得知道，我们给你一个机会，你去做吧，这就是我的想法，所以这是我们正在尝试的新事物，我们看看它是怎么工作的，好啦，好啦，期末考试，还有一件新鲜事，我们意识到。

六一C的期末考试是最致命的，所有这些的期末考试，我相信这就是原因，这就是为什么，丽莎谈了六个好主意，这是一个很大的大约九个模块，我们教你，这九个模块都在决赛中发挥作用，比如你是怎么把这些都保持直的。

喜欢，就像很多事情一样，所以我们说，如果我们真的进了决赛，非累计，意味着你期中考试的所有东西都取消了，决赛，你测试了一次，嘿嘿，我喜欢它，我喜欢这个，六十一见，六十一看到没问题，所以一旦你测试了它。

一旦我们不再要求你考试。

我们在沙子上钓到了一条线，突然之间你就完了。

希望你能在期中考试中取得好成绩，对然后你就走开，你在这方面得到的要少得多，而不是有九件事可以玩，好像有五四个，合理多了，可查找，我们对这种新形式感到非常兴奋，我们希望你能粉碎它，我们现在要考试了。

让我们想出一个硬链接，所以让我们想出最难的问题，否，中间会有一些很温柔很好的问题，但不是把唾沫球和旋转器，然后做一个投球，像一个有曲线的不，我轻轻打，我们来了，我们来了，一个温柔的垒球球场。

然后你敲啊敲，把它敲出公园，我们想让你粉碎我们的考试，我们不骗你，我们想粉碎我们的考试，我们要问你关于这些东西的部分，这不像右段底角的小部分，不是一般的问题，我们只希望你能把它压碎。

这就是我们不打算警告你的想法，我们想让你粉碎这些考试。

好啦，开始了，以下是课程评分甚至不是很好的原因，看起来连百分之五都不到，实验室10%，百分之十的家庭作业，40%用于项目，期中考试二十强决赛，这就是为什么你会得到上一张幻灯片，呃，为了期末考试，是啊。

是啊，是呀，是呀，对不起。

去耶，我们走吧，是呀，所以期末考试，这只需要几个音符，这将是一次定期的面对面考试，但不会累积，有几个关于替代方案的问题，我们在是的问题上看到了，是呀，谢谢你，谢谢，我们会有一个候补。

它很可能是期末考试后立即出现的时段，所以我们的期末考试时间是8点到11点，阿米，星期一，你和我必须选择不，否，从字面上看，最早最可笑的时候，就像谁在琥珀里起床，计算机科学，好啦，我们开始吧。

看起来很可笑，我们将为你们中那些有预先批准的原因的人进行一次备用考试，所以这包括如果你在这段时间有一个课程，我们允许时间冲突，所以如果你在这段时间里有一个课程，在时间里有一个不可移动的决赛。

那你就可以申请候补了，是啊，是啊，那是一种形式，我们将在学期结束时发出一份，但你必须证明，不是很好，我不要不要，你必须证明，就像你需要发送，你得送你的孩子去上学什么的，我们完全理解，我们希望能够容纳。

我们会和你合作的，是啊，是啊，因为考试是，现在这一切都要亲自出马，这是学校的要求，是啊，是啊，就像一切都应该是面对面的，除了期中考试带回家的部分，我说对了，但是，我们完全理解这场大流行病仍在发生。

我们在事故中就是这么做的，因为你知道丹和我不想感染，但我们也尊重你们中的一些人有自己的承诺，所以事情可能会改变，所以如果我们回到尤达的声音，事情可能会改变，这是目前的计划，不不不，非常感谢你，太完美了。

好啦，所以看看我是怎么说的，很平衡，对呀，上面有六十分，底部40分，很容易，好啦，但这也是一个新的，这是全新的，我们过去常常，这是一个老派的C，我们说过，你知道的，项目一，你得证明，你单干就知道了。

人们总是会挣扎，学习C和我对人们来说真的很难，然后你可以加入一个合伙人，在两个合伙人中工作，三和四，我们把它扔了，你可以和合作伙伴一起工作，你知道有些人学别人最好，教你，你可以合伙工作，每一个项目。

好在这里，我们去好东西。

好啦，所以再一次，我们没有弯曲的评分政策，这是典型的，GPA会说A的成绩有一定的百分比，我都签在，至于我们所爱的一切，如果你们都把这门课搞砸了，而不是被我们的分形椅子严厉批评，我们会被庆祝的，扛在肩上。

就像那里，至少在那里，至少是这样，你让所有的学生都得了a，如果我们能做到这一点，我们会受到庆祝的，所以让我们在这学期实现它，那怎么样，还有工作面试，他们会用技术问题拷问你，求职面试中最重要的一堂课。

是B，但是第二道菜，求职面试的第二门课程是cs，但是第三个，第三个最重要的课程，这是一个c所以，确保你知道这给了你说“好”的好东西，说得好。

好啦，快好了，我们的目标是导师，我们想让这成为最有趣的体验，就像我们把那种能量，我们有如此多的热情，两个加州毕业生，我们都上过学，上课，你就坐在这里，所以我很荣幸，就是站在这里和你们分享这门课。

所以我们真的只是为了带来幽默热情，我们要把，带些苹果的客人来，他们可以请苹果的客人，谈GPUS，希望如果我们把这些都对齐，我们对计算机感到兴奋，新闻，每次演讲，我们在今天的新闻中证实了这一点。

就像我们要质疑这堂课，趣味作业，充满乐趣的挑战，你的第一个项目就像蛇游戏，你在开玩笑吧，做反向蛇游戏有多有趣，当你学习所有有趣的东西的时候，趣味作业，真的很亲学生，我想把这个给你，我要你。

你知道他们以前有优惠券说，如果你能找到更好的交易，给我看看，我会战胜它，我来搭配，你会发现我在校园里有一个更支持学生的政策，并把它提交给我们，也许我们会考虑，我不是在开玩笑。

在支持学习方面给我找一个更有利于学生的政策，普及辅助器具，你找到我，我在整个校园里，你给我们看，我们谈谈吧，好的，扩展右，所有的东西都很神奇，好啦，我们将保持优秀的卡利桑，一如既往，项目考试严格。

但不像软化好，免费艾滋病权利，我们不是为所有人做王牌，免费，免费，因为A条不移动，在A中的意思是不变的，但我们要让每个人都在上面，那个酒吧看起来像，这就像手段，每个人都可以在奔跑中通过终点线，你知道的。

障碍赛，差不多吧，所以我们想成为香港的七点零，如果我们不是，如果我们不粉碎它，每节课都有我们的演讲，我们的家庭作业，我们的项目，我们的考试，我们的政策对我们说话，我们会纠正的。

我们以前每周都和61 C开会，学生代表，他们会说你知道这周你有太多的作业，我们说你知道我们听了你的话，我们把任务，所以如果事情不顺利，告诉我们在伯克利大学的ED或6Two和C。

我们会纠正它，修复它，我们想成为有史以来最伟大的班级，好啦，所以现在我得变得沉重，我讨厌这部分，这是我一年中最不喜欢的幻灯片，你得对作弊耿耿于怀，好啦，我们必须谈论的那种授权。

这个项目和实验室可以两人一组单独完成，我们知道那很酷，那完全没问题，但是，你所有的作业都是家庭作业，很明显你所有的考试都是单独进行的，同样的事情--合作伙伴团队可能不会与其他合作伙伴团队合作。

所以就像一旦你找到了你的搭档，你被锁在，这就是你的同伙，他们不能，他们不能分享，鼓励您帮助教人们调试，所以一些其他的合作伙伴或其他人说我不能让这个工作，你不给他们答案，你教他们怎么教他们，如何调试。

教他们如何喜欢开车，教他们如何度过难关，但不要说你的答案就在这里，你知道吗，你想过这个，别想了，总的来说，你是怎么想的，比如教他成为一个更好的人，通过调试，你会成为一个更好的程序员。

我们不想分享方法或想法，或者代码，或者和其他学生一起白板，因为有时候整个想法，哦，我的天哪，这就是它的全部关键--这就是我们试图教的，不是给你的，所以不要做那种谈论，就像走出这里是你能做的。

你拿到了说明书，你就在听讲座，嘿嘿，等着尝尝这个，也许我会试试这个，这是一种需要考虑的谈话水平，也许你会试着，但当它深入到细节之下，不要突然白板，哎呦，这个块应该调用那个块，这个，但你知道。

不要在太低的水平上这样做，从演讲到高层走道，是呀，仅此而已，所以有时分配的重点是算法，如果你分享了这一点，他们就不必和自己在一起了，不允许通过UTER代码工作的香港和辅导课程，事实上。

我们有过你要去香港的案例，香港人不知道我们的作弊政策，他们就像真的很好地解决了这件事，所以这是枪手的密码，我不打算用C语言为你写代码，但这里是伪代码的整个代码，喜欢线和匹配看，就这样结束了，这就是演讲。

在获得该级别的帮助方面，CAN是不允许的，伪代码是，有时整点，请随时回答ED上的问题，帮助他们调试，不要共享代码，甚至片段，他们希望你所拥有的，你交的是你的，我必须很重，这就是问题所在。

所以照搬其他学生的解决方案是不可接受的，从Web复制或启动解决方案是不可接受的，不能接受留下代码，任何一个肆无忌惮的学生可以找到并偷走它的地方，我是公众的Githubs一边离开你自己一边走开。

登录我有多少次作弊案件，哦耶，我拿着笔记本电脑，然后我走到洗手间，然后他们就说人们进去了，这也是你让你的笔记本电脑开着的麻烦，当人们到了那里，你不能把东西乱放，受保护，把打印件留在里面。

我们有多年来开发的工具和方法来检测这种情况，你会被抓住的，因为这些会很严重，我让很多学生不及格，每次我不想那样做都让我心碎，所以让我们都冷静点，最起码发生了什么，所有作业负分，和一封信在你的。

这是最大的交易，你的奶牛里有一封信记录说这种情况发生了，有时候，事实上，学生们必须给学校写一封信，偶尔，你喜欢读点东西，等一下等一下，这就像一个欺骗的忏悔，他认为那个人被抓了，不得不给日报写信，卡尔。

说出他们的名字，他们认为不好，所以不要不要这样做，我们每年都抓人，有时我们有50到100个学生，乡亲们，让我们不要这样做，就是这一年，让我们像不这样做，我们在扩展方面给予了很大的灵活性，如果你卡住了。

只要要求延期就行了，我做不完，你要么欺骗你的邻居，或者只是要求延期，请要求延期，我们会给你的，好啦，只要让分机，给予者和接受者都同样有罪，不只是我从他那里拿的，但如果我把期中考试给你看。

我和你都有责任读它，就像你们两个都有权利，总之，这是总结中的一起幻灯片，丽莎分享，神奇六侠，即使是早期计算机体系结构中的六个伟大想法，允许高性能，你在学习硬件和软件接口，请随意添加任何内容。

你想要的一块是的，所以我们学会了，丽莎提到了摩尔定律，摩尔定律，有人记得摩尔定律吗？业绩指数增长，是呀，不不表现，集成电路上晶体管数量的指数增长，人们总是弄错晶体管，我明白了是那个地方意味着更近，更快。

较小，但更贵，平行，平行，损失，业绩，测量与测量，你好吗？通过冗余来优化和可靠性，我们结束了，太感谢你了，Xc one z，我们周五见，谢谢大家太棒了。

P10：Lecture 8： RISC-V DataTransfer - 这样好__ - BV1s7421T7XR

女士们先生们，欢迎来到，我想是第7课或第8课，丽莎七八，我想是第八课，作为女士们先生们，第八讲，风险五，数据传输。

好啦，所以我们总是从新闻中的计算开始，我发现这个很迷人，这是一个美丽的形象，这个赢得了今年科罗拉多州博览会的一等奖，我通常不看这张幻灯片，但我会读这个，因为今年的天气很好，的，这是从纽约时报。

科罗拉多州博览会的年度艺术比赛，颁发了所有常见类别的奖品，绘画，绗缝雕塑，但是有一个参赛者，西科罗拉多州普韦布洛的杰森艾伦，不是用木刷粘土进入的，他在中途创造了它，一种人工智能程序，可以将文本的行。

这是赢得这样一个奖项的第一批人工智能生成的作品之一，引发了艺术家的强烈反对，他们指责他们本质上是作弊，他说，你看，我告诉过你，我是怎么做到的，我完全披露了，我就是这样做的。

这个类别的名字就像新兴的数字艺术家，就像新兴的数字艺术，就像那种，你知道Photoshop，他们在想的其他事情，使用一些工具，但主要是手工做得很好，这个工具你只需输入单词，就会出现图片，但他一直在努力。

直到他得到一张照片，他喜欢人工智能的有趣之处，如果你观察中途并了解它是如何工作的，它的作用是，它采用了现有艺术家的风格，它从现有的艺术家那里学习风格，然后把它应用到新的东西上。

所以在某种程度上偷了那些风格，他当然必须有创造力，我们不只是创造了自己，如果我们必须对它做些什么，但是在吸收和吸收之间，就像取样一样，对什么，如果我从那里的说唱歌手中取样，然后我做了一个新的东西。

大部分是他们，但以不同的方式聚集在一起，他们到底多少钱，我多少钱，这是一个非常有趣的对话正在发生，为了这种数字的东西，这些大多取材于其他民间风格的人工智能程序，你能用多少，有趣的谈话，真的真的很迷人。

请随意阅读，如果你有兴趣的话，在内存中存储数据，这是你目前在丽莎所知道的，为我开球做得很好，这样我就能开到450码，我们谈到了三个新的指令，现在这些指令与c不同，我们在集合层，我们说的是风险，五个是A。

这是你到目前为止看到的三个，你看到一个广告，顺便说一句，如果你还记得，顺便说一句，这叫做维拉日志，它读起来像C，他们实际上故意把它设计成读起来像C，所以水流从右到左，就像你说的，你说。

R s One是一个指示器，表明您想从哪个寄存器读取，R s 1有这个值，R s 2有另一个寄存器要读取，这些寄存器实际上可能是相同的寄存器，这两个数字可能是你从这两个寄存器读到的相同索引。

你把它塞进我们的目的地，所以源1源2进入由目标寄存器的索引指示的寄存器，这和你说的做减法是一样的，在这里你可以添加一个即时的，所以现在我们可以在那里有一个常数，现在呢，其中一个元的东西被提出来。

你们会在接下来的5节课中看到，我们在讨论这个，你看到的每一条指令，必须以32位存储，那只是生活的事实，你看到浮点，至少周三在诱导浮点方面做得很好，星期三，这意味着如果你在做一个浮动，不是替身。

但是一个浮子，你不知何故在一些新的语义中使用了这三个二位，这种新方式，这些位表示这个特定的浮点数，其中一些意味着无限，其中一些不是数字，但那三个二位意味着什么，现在我们说，最终，我在给你一个小笑话。

两节课之后会发生什么，三堂课，每一个都必须是三个二位，很有趣，所以你在想，哇塞，那很酷，你怎么能有一个比特编码，我都指定了简历，顺便说一句，一个，记住这就像没有免费的午餐，记住我的故事不是免费的午餐。

你得有所收获才能有所收获，还记得我们说过的无符号数吗，可以达到这个巨大的范围，但如果你想否定，你得从积极的方面借点东西给消极的方面，你得向一个人借钱，天下没有免费的午餐，所以现在我在想哇。

我得具体说明一下，想想这个，我只想晚点再给你穿上这个，我想做一个加法，那是很少的一点，也许这不需要太多，相对于减法相对于好，这是一个，我必须具体说明，那个指数是什么，什么是第一，两个是什么，什么是RD。

所有这些都必须以某种方式融入三个两个部分，现在这让你很好地意识到，第一条和第二条都能有多大，会是，不会那么大的，因为我只有3个硬币能装3个看看这里，我必须马上做这件事，所以现在你想得很好。

那个常数能有多大，所以你开始意识到我们实际上会受到很大的限制，我们有多少寄存器，我不确定，至少我相信你明白了，我们还将在我们的直接投资能有多大方面受到限制，所以我只想为思考它埋下种子。

每次你看到指导男孩，其中一些也必须适合32位，我们现在怎么做，三个二位，二对三，二是四十亿。

好似，所以我们会有很多，但想想会很有趣的，所以这是一张很棒的照片。

我想我们以前展示过，但我们会花点时间讨论，在左边我们有我们的处理器，我们的CPU，控制和数据路径控制就像提线木偶，当数据路径是管道时打开什么，我们要看的东西是什么路线。

我们有几堂关于数据路径和数据路径中的控制的课，我们有程序计数器，程序计数器告诉我们，我们目前的计划是什么，我们目前的指示是什么，我们现在就跑，那是我们的柜台，我们会有一套寄存器，可能会有一些限制。

基于我们有多少位，二到我们有的位数，我们要帮助的寄存器数量是多少，你可以使用ALU，算术逻辑单元，做实际机器的东西，做乘法，做加法，做减法，那只是一个简单的alu，我们要建造。

但我们要把所有这些碎片拼凑在一起，这就是令人惊奇的地方，六二和三，我们走在一个高水平上，高级别，低一点低一点低一点，我们实际上建造了一台机器来建造这个Aliu，这将是非常美妙的和注册文件，这是。

这是大脑，这是我们的大脑，有我们的CPU非常非常快，快速访问寄存器，但我们没有太多，我们知道，因为比特数，我们都受限于32位指令，其中至少有三个必须是指数，也不能有那么多，所以我们没有那么多。

如此有限的登记册，在某种程度上，这就像我们的家，记忆是外围的东西，那里比较远，我们的家是CPU，我们是CPU，你想把你的大脑，你是CPU，这是一个非常强大的想法，你不仅可以存储你的数据，你知道。

但是你记忆中的程序，还有，这就是所谓的存储程序概念，计算机体系结构中最大的思想之一，以前不是这样的，但你实际上可以拥有单一记忆的想法，顺便说一下，记忆记忆的抽象观点是什么，记住这一点，我们说过。

丽莎说这只是一个长数组，记住一个长数组是零，这里是所有F的8个F在那里，你就是这么想的，这只是一个长数组，不知何故，它的某些部分是数据所在的地方，它的一部分是我们的程序在内存中的全部。

我们有一些操作将这两个很好地连接在一起，我想从记忆中得到一些东西，写一些读和写这个东西，我想能够读和写我的记忆，所以我要给它发个地址，我可能会传递要写的数据，但如果我只是在读它，这条线上什么也没有。

如果是，那就是垃圾，我不在乎，因为我只是读它，我不在乎，那条线上是什么，我可能会读到它，所以当我读书的时候，我关心下面这个，我正在从，顺便说一下，这很重要，这两个字我希望你非常自我中心，你是CPU。

先想想你自己，所以你要用的单词是从记忆中加载的，所以我在这里，我在右边，在这个屏幕的左边，我望向远方的记忆，我要加载和存储，这就是为什么我们不做另一种方式，因为否则我就会加载到内存中，禁止上传到CPU。

记忆又没有什么作用，记忆是被动的，我在大脑中，我从管子中装载或储存管子，所以那种动作，所以一定要记住这三个，让我们试着从，两个小东西会帮助你的大脑，你不会糊涂的，你不会记得你是CPU。

东西是一个被动装置，有一些有趣的IO，看看i o没有连接到CPU，I O穿过记忆，那不是很有趣吗？我们怎么画，稍后我们将展示基于内存的，我再一次，内存大得多，但是要慢得多，也便宜得多。

好啦，好啦，我们应该好好谈谈，我想丽莎展示了一种观点，对此的看法，我想对这个数据有另一个看法，通常是三个二位，这是一个三位一体的系统，八位块或字节，我们谈过了，在内存地址真正以字节为单位之前。

不是用语言，所以当你访问内存时，顺便说一下，这个词被称为字节寻址内存，您将通过指定字节来访问它，不是这个词，也就是其中的四个，但被咬了，总是关于咬人，你问的是，字地址相距四字节。

单词address与最右边字节的地址相同，最低有效字节，我叫小印第安人，我给你看这个，这张照片和丽莎展示的照片不一样，因为丽莎在谈论它，如果我拍这张照片，请注意这里，我们走吧，让我们只计算字节零一二三。

从右边开始看这个4 5 6 7 8 9 10 11，这是一张有效的图片，如果我这样画的话，或者是这样画的，同一张照片，我只是把它翻过来，当我在数组中存储字符时，像卡尔C字符C字符一个字符L零。

如果我把它放在这里，数组中的第一个是C，第一个，还是零，第一个C右牛，C中的第一个右，零的数组是C，那不是很好吗？如果上面写着，如果它的读数是零，但这里发生了什么，如果我这样写，嗯，C在这里。

然后是A和L，所以这就像，当我看角色的时候，意思是事情倒退了，右C是第一个字符，下面是字符串引号，C l未引用，那是一个c和a，一个l和一个零，记住有一个免费的零，你得到所有的字符串。

所以对于这张图片中的一个视频，右边的独联体，所以这是第0个字符，你知道的，零的数组是C右，来吧卡尔C是第一个，所以我把c a和l，所以是倒过来的，所以丽莎在谈论c阅读和写作，幻灯片在这里，我想耶。

太感谢你了，如果你需要一个滑梯，你需要一个滑梯甲板，请举手，然后我们会给你完美的，好啦，但请继续倾听，当你举手的时候继续听，所以如果你说的是，她说的是C，她说的是读写c数组，所以她是这样画的。

用左边最小的一口，你可以读到它是c a l 0，在这种情况下做她正在做的事情更有意义，但如果我加载，让我来这是我的最爱，这是我最喜欢的一段数据，零x，那只是一个，那只是个数字，如果红色从左到右。

就像在屏幕上一样，最低的一口是多少，谁知道谁知道这一口最低，就在这里就在这里，低，最小咬合力，好啦，那不是很好吗，如果你这样画的话，或者这样红色，就像你阵列里的死牛肉，所以我们在右边画一个零。

这样ES在右边，DE在左边，现在读起来是这样的，如果我想看一个浮点数，我不必不停地翻转每一口，移动它们，浮点数有正弦，记住正弦，指数，右边的尾数，你只想看看这些零件，让他们看看寄存器。

就像他们在记忆中的样子，所以从现在开始，我们将在一个单词中有零字节，在右边，就像这样，没什么不同，你可以用不同的方法画，当你画人物的时候，画路有意义，丽莎用左边的零给他们看，当你画像，从字面上看。

查看内存并对其进行比特，这更有道理，但他们和你一样，你应该可以来来回回，只是更容易看到死牛肉，在记忆中阅读，死牛肉，就是这样。

所以做什么，我要说的是死牛肉，这是我的，这是我的登记簿，这是我的记忆，应该是一样的，关于这个的问题。

所以让我们花点时间来谈谈大印度和小埃尼，这是一个非常有趣的谈话，谁知道格列佛游记，乔纳森·斯威夫特写了一本关于我们所有人旅行的精彩书，你应该知道，有一部杰克布莱克的电影，我觉得最近，他是个巨人。

在小人国的土地上，在这片土地上，乔纳森·斯威夫特创造的奇妙土地，人们为煮鸡蛋的哪一边而争吵，你开门吗，是煮鸡蛋，有小的一面和大的一面，或者小的一面和大的一面，小印第安人想在小端打开。

大结局是想在大结局上打开，我们只是为了一些琐碎的小事而争吵，但这就是它的来源，但现在你意识到一件有趣的事情，哦哦，顺便说一句，我们只是在讨论如何在一个单词中存储字节，它从来不是关于字节中的位。

字节中的位总是相同的，右边最小的，在一口中在一口中，右边最小的，左边最大的，但如果我们讨论的是如何将字节存储到内存中，这里是我在两边画地址零加这个三，记住我们要开始了，但现在我们说的是一些。

地址零到地址三，这里是地址0和地址3，所以在大印度对小印度，会发生什么，我正在加载，以下是我想储存的东西，我要储存在这里，数字十二十五，是零乘以三，零乘二一，零零或四，由一和一在零，有一个四和一个一。

如果它是一个小印度，它真的需要这里的咬，这里有点，数字，好啦，这里是零，一一零一，好啦，所以这是在一个字节内它们是一致的，但如果我有这个东西，十二十五看这个，我该怎么写，这是字面上的十二五无符号，嘿。

伙计们写十个二十五个没有签名，就是那个大家伙，如果你住在小，幸运的是，我们的系统确实有风险，五是一个小印度，然后这个10点25分看起来和那个一模一样，零四一零四一，原来如此，你在这个世界上。

留在这个世界上，它在寄存器里是什么样子的，它看起来像什么，你平时写字的方式，它就是记忆中的样子，如果你把0写在右边，3写在左边，大印第安人被翻转了，大印度人会说，哇塞，嗯，我们要写的小咬，大的。

我们将在单词的大侧写最小的字节，这就是为什么它是一个重要的开始，就像你从这个词从左到右，是大的一面，所以那个，四个零和零，我们在这个世界上，所以让我们从现在开始关注这个世界，即使你现在知道什么是大印度。

我们在一个小，只是让它容易，是的问题，再告诉我一次你的名字，我去耶，所以我觉得你没有一个标准化的超过，我希望看到它标准化，事实上，当你要采取，还记得我们讨论过移植代码吗，你的问题我还没问完。

但我要跳到答案，我喜欢这个主意，为什么我们不能把这个标准化，不同的架构师做不同的事情有不同的原因，所以当你取一段C代码时，你会看到什么，你想把它建在一台新机器上，全新机器，我买了台新机器，是吗。

可能是苹果的m系列，可能是手臂，可能是树莓派，不管是什么新系统，有些人做一些新的硬件，你要用C或者UNIX，你要运行一个叫配置的程序，谁运行过配置这个，你建过软件吗，任何人运行配置，没有人跑的身影。

我应该向您展示运行configure时会发生什么，它穿过来说，你支持吗，我知道，你支持一个几乎大的印度人吗，它会告诉你那是什么感觉，它问了系统的这些问题，系统必须声明它使用的是什么，你支持浮点标准吗。

现在每个人的答案都是肯定的，但在他们说不之前，对他们中的一些人来说，那么在你的C中，太难看了，你得说好，如果大印第安人的定义，如果大印度人，然后做这件事，有点，做，就像这个可笑的东西。

但是您可以询问一个系统，并获得非常可移植的代码，但我百分之百同意UJ的观点，应该有个标准，没有是，这里的问题，告诉我阿拉尼亚，走呀，走呀，那份工作，但让我们回到这张照片，我们再去看看卡尔，阵列牛。

那数组的第一口是什么，那是什么，cal c数组第一部分中的字符是什么，那么你会把它写在哪里呢，某个数组中的第0个拜登是什么，就在右边，右下角会有一个C，一个怎么样，就在它旁边，L怎么样，它会在两个。

零会在三个，所以如果你这样看，我喜欢看记忆的方式，哪个是这个，这就像，它是如何生活在我的大脑中的，我所有的弦都在一个词内向后，所以我有一个三个字符的字符串，它们都是倒着读的，所以露西说，我们把它翻过来。

所以说，我们可以正常的读弦，但当我说到装载浮子时，假设我把一个浮子装进去，我想用这个花车，在哪里，招牌在哪儿？有点在我的在我的在，我左边的彩车，应该是这样的，当我把它写在纸上的时候，左边是同一条路。

所以我宁愿看我的字节，那样从右到左。

如果有帮助的话，让我让我让我继续前进，但也许我们可以问这个问题，我想度过有趣的一天，我做了一些，我把幻灯片拼好了，原来那个大大小小的印第安人，现在你知道了，这是这门精彩课程的一个元点，你看到61。

看到你生活中的事情，你开始拿61 C，并适用于你的生活，现在你已经学会了，你要说，在那里等着，世界上人们做名字的方式要么是大的，要么是小的印度人，那不是很迷人吗？所以说，例如，我的姓，我姓加西亚。

我叫苏丹，如果我是小印度人，我要先说我的小事情，谁是我丹，还有我的姓，我的姓第二，但在中国，他们认为最重要的是你的姓，是你的家人，然后名字就在那里，所以他们会说，加西亚·丹，所以开关的名字，没有价值。

一个人是否更好，那只是不同的喜好，Java包，大的是什么？组织我的包，你好世界，大的那个，ISO 81601中的首次日期，顺便说一下，今天的课结束后，你们都应该用iso 86-1来写你们的日期。

Y Y Y Y破折号mm dd d，1975年，你试着用这些来分类一个文件夹，不是在几个月里，甚至不要排序，就像，一点都不像一月，否，J不比我的意思少，太荒唐了，四月是第一个对吧。

所以这是如此疯狂的美国人，做这种奇怪的事，所以从现在开始每个人都有86个，你的约会零一，顺便说一句，这将工作大约，你知道的，再过八千年，我们做得很好，吃披萨，先把地壳，吃大边倒着吃，小印度人说网络名字。

CS伯克利到U CS比伯克利小，伯克利比EDU人小，世界上有些人写日期、日、月、年，问题是如果我给你看70920，你不知道那是指月日还是日月，所以有点烦人，如果你总是写八十六一，几乎总是一年，月日。

所以这并不矛盾，吃披萨，先瘦下来，好啦，所以这是很多时间在这个大事情的想法上，我在这里告诉你，如何将数据从CPU来回传输到内存。

还记得以前的这张照片吗，我们以前见过，在我们核心的顶端，登记簿离他们真的很近，所以寄存器很小，快，但每比特都很贵，你下得越低，你变慢了，是我们在这个级别存储内存的常见方式，双倍数据速率我们以前见过。

快，合理能力，中等容量，但在更远的地方，所以我们开始了，哦寄存器，有三个两个寄存器，我把它送人了，有三个两个寄存器，两个寄存器，你认为我在指令中的每一个都用了多少位，然后有三个两个寄存器，有多少。

我如何索引三个两个东西，我会用多少位，五位，从0到3 1是我的收银机，好啦，三个两个寄存器，第三个两个字，我要建一个商店，总共128个字节，三个两个四个字节，每三乘四是一二八内存十亿，记住那件小事。

巨大的东西，还记得那个小三角形吗？越小越快，那么寄存器比DRAM快多少呢，哪里有井，以下是它的速度，太神奇了，就像几个数量级，更快的寄存器是惊人的，他们就在ZB上，他们在死亡边缘，就一次访问的延迟而言。

我们喜欢这一点，事情是这样的，接下来的单词我们会看到它有点复杂，得到一件东西需要很长时间，那是吉姆葛雷的照片，我们马上就要表演了，但使用后续的，因为当我去萨克拉门托拿数据的时候，我要带很多东西。

其实呢，所以后续的会很快，但第一个真的很慢，我们会在那里看到的，这是我们以前见过的美丽的吉姆·格雷的照片，他的类比，顺便说一句，我们爱，我在想，如果我和别人和戴维斯分享这些幻灯片，就像我去了萨克拉门托。

就像两分钟的路程，你在说什么，就像伯克利，反正只有演讲幻灯片，关键是寄存器就像我脑子里的东西，我忘记了一些事实，我的密码，它在我的脑海里，真的很快，还有一分钟，也许哦，他们用这个或那个。

但如果我在萨克拉门托写了那张纸，大概一个半小时，真的很烦，这就是我们想要多长时间的类比，基本上尽可能留在我的脑海里，我不想去萨克拉门托，太长了，太多纳秒等着我的CPU，我可以做它做工作，直到我拿到数据。

就是这里了，这个是大的，这是这里的大滑梯，我们在这里有一个新的指示，我们有一百个，这直接转化为风险是什么，一百个中的五个，它转化为什么，只是个声明，它实际上与任何风险五指令都没有一对一的联系，下一个有。

尽管g等于h加上3，顺便说一下，这真的是后面的人的小字体，所以前面有很大的空间，如果你发现，很难看到幻灯片出现在房间的前面，另外，你有讲义，希望g等于h加上3的a，我们在风险五中使用加载词。

我们要做的第一件事，这就是我有这个小东西，到目前为止的数据流，数据流总是从右到左，记住，就像广告一样，把右边的收银机拿起来，东西，在左边的那个人身上，每一个，你知道的，x等于y加上z把y和z填入。

X总是来自左边的右边的东西，这是你所见过的一切，Python 61 a每个类都是把右边的东西放在左边，这里也一样，从某种意义上说，我们是这样做的，让我们试试，我们聚聚吧，其实让我。

甚至可以显示我的使用光标，好啦，我们试试看，所以三个中的一个，我们在那里做什么，称为基寄存器，所以哎呀，刚刚发生了一些事，刚刚发生的事，是啊，是啊，当然不要那样做，在数组的底部x15个点，数组在哪里。

如果我说嘿，带我去哪里？其中a是十五寄存器，十五是什么，我得把截图弄丢，不知何故，啊，那很奇怪，当然屏幕共享，那很奇怪，怎么会这样？谢谢你的轻推，必须躲起来，这是我一直在屏幕上。

或者只是一个非常奇怪的人，是呀，好啦，谢谢你，好啦，所以x 15个点到数组的开始，现在我想要三个中的一个，现在呢，你知道我为什么要证明它是一百个中的一个，为什么，最重要的是什么，一百个不，的。

int说这些东西有四个字节宽，这意味着如果你要三个中的一个，我要跳过零一，二三，那是零的a，四五六七，那是一个中的一个，八九十十一那是二的一，三个中的一个在哪里，三个中a的最低字节在哪里，十二。

所以我拿我的三个，我乘以int的字节数，这就是我得到实际价值的地方，这就是为什么括号里写着x15，哪个是基址，和12字节的偏移量，这是全新的，所以慢慢来坐完这个圆圈，在幻灯片上给自己做一些笔记。

如果你需要帮助，数据流是这样的，这意味着我从这个值中读取，你也知道，因为这是一个负担，我从记忆中加载，让我们从内存中加载并填充到x10中，是的问题，你进来就走，你知道的，我如何定义，所以这是一个。

那是编译阶段，所以问题是，它在哪里被定义，我怎么知道，我是怎么得到的，我去了这里，你开始听到，我写了这个代码和我的信封背面，我是怎么得到这个代码的，这要么是由编译器完成的，要么是手工编译的。

编译过程将C转换为风险五，所以有人说，我需要一点空间，或者是编译器，智能智能系统，或者你在想怎么做，这上面说，我想试着用这些寄存器，不是那些，顺便说一句，试着优化我想做的事情。

您使用的寄存器总数称为您的足迹，你想尽量减少你的足迹，所以也许聪明地重用从头开始的寄存器，这样你就不会把它们都用完了，但你再也不需要他们了，问得好，它是怎么出现的，这是因为你亲手写的。

或者因为编译器这样做，让我去第二行，然后回答问题，我想做g=h加3，所以我我很多人认为在这个讲座之前，如果我想把两个内存值加在一起，我只是说在风险5中加上两个记忆值，事情不是这样的，它是如何工作的。

我去拿第一块记忆，我拿起第二块记忆，他们在收银台，我把它们加在一起，我得把它塞回记忆里，因为我不能直接操作，我唯一能做的就是抓住记忆，从并存储到，这就是为什么我要给你看。

如果我要以某种方式把h存储在本地，就像在寄存器里一样，我想把它加到3的值上，我得先拿个三，放入登记簿，那就做我想做的，第二条指令说把东西加到x11里，这就是g恰好在的地方，我没告诉你，但那碰巧是。

H是x12，x10是临时的家伙，当一个三分被拿着，原来如此，我得去回忆一下，现在抓住它，我把所有东西都登记好了，我能做到，我想把它们减去，当我添加它们时，您想添加一个即时，我可以在这里做，但我得去拿。

用它做点什么，如果我想把它放回记忆中，我得把它塞满商店，我甚至还没来得及，所以说，如果我只是在装货，好啦，我希望这回答了这个问题，是啊，是啊，怎么出来的，这是个好问题，他是怎么做到的，工作怎么样？

CS 164是一门教你的很好的课程，这是如何工作的，我们将能够手工编译，这样你就可以通过说，让我们看看我周围有什么寄存器，哦x x 10是免费的，我用x10，我不能用X，我不能用x12。

因为x12有一个值，我在这里用的，所以你需要留张桌子，当你这么做的时候，你留了一小桌，谁有什么，所以说，如果我已经把h和x12，我不能用x12存储成3，因为我会，否则我就会丢失数据，所以你有点。

这是个好问题，但一个很好的问题，你需要做这项工作，基本上，你可以编程系统自动为你做这件事，或者你可以这样做，保留一张桌子，所以，你不你重击。

你不想告诉我的事，你的名字，要去的工作，所以我们提到了。

就像在一百个会像在集会上什么都不做一样，你难道不想，把它推到堆栈里，就像局部变量一样，这是个好问题，我们稍后会讨论实际发生的事情，所以100是一种说法，我想要一些这个，它可能会移动东西，从这里开始。

就像这不会转化为任何风险5线，这将是你如何思考你的记忆和一件有趣的事情，全都是垃圾，所以它只是说好，不要用那一百块，因为那是留给A的，就在那里，说得好，是呀，更多问题，是呀，告诉我，我开始，你先走。

说它变慢了，为什么舞台上没有零，你什么意思，啊耶，是啊，是啊，是啊，是啊，是啊，是啊，好啦，所以所以对对，所以问题是再告诉我一遍这个基地址，基本上是水生的，问题在这里，这是不是在某个时候出现的。

我需要知道，有人需要填补，X15必须储存，必须塞满基址，不过，那是有效的，可能只是油，这是我的，这是我的一叠，记得它就在上面，所以抓住了，这可能是一个明确的地址，那是在这之前。

我还没有告诉你我们还没有讨论过堆栈，我不得不接受，但不知何故我告诉你，假设，x15知道数组的开始，这就是我所知道的，如果X15知道那可能是你，以后会是你，当你要做整件事的时候，你的填充物，X15的值。

您手动编译一些东西，我们看到的是许多，多行代码，我告诉你，给一个开始的x15分，这里有一个大数组，一百个整数，四百字节，X15有数组开始的地址，连续的内存，我告诉你，如果我给你三分，它看起来像什么。

三个中的一个，我知道x15是基址，三乘四等于十二，所以我要在这里写一个12，仅此而已，所以你的要求就像，一开始是怎么建起来的，答案是你会这么做的，或者编译器一开始就会这么做，我在看右边，一旦它设置好了。

一个x15设置好了，之后会发生什么，这是个好问题，所以x15点，开始，所以有这个，有一个，这是前面的x15点，几乎就像一份学生名单，这里有一份名单，这里是这里是第一个人的15分，所有这些整数都是在。

这段代码指向它的开始，如果你需要一个硬编码的值，你把任何东西乘以4，这就是你在LW命令中设置的常数，我本可以用x16，问题是我能用什么，我是说我只是我只是扔了另一个，我有一个划痕的天空，划痕空间，十五。

我就是这么做的，但是x16与此完全无关，因为那样就不像好了，那么下一个字节是x16，一点关系都没有，只是这碰巧是我使用的基地址指针，那是一张抓伤的脸，会把它储存起来。

十六个或十七个连接到数组没有什么特别的，一切都好，好啦，我们继续走，我很担心，我实际上无法完成，我有两个选择题，顺便说一句，我们有很好的问题，很好的问题，我真的很感激，呃，是呀，低鼓。

好啦，好啦，下一个，存储2号存储的负载，好啦，所以现在正好相反，但现在看这个，看动作，这是一个会打破你的大脑，很难就像英语很烦人，因为所有这些特殊情况。

这是特殊情况之一，其他人从右边被带走，塞进左边。

商店反其道而行之，但是商店有趣的是，它的语法与load完全相同。

看什么区别，看差异准备好了，负载寄存器逗号偏移量基址。

好啦，看看这个商店寄存器逗号偏移量地址，所以实际上他们在英语中看起来一模一样，只是语义学，发生的事情恰恰相反，所以看看这个，在这里，我们有100个10得到h加一个3，所以你已经看到了加载词之前的前两个。

现在我得了10分，得了3分，你见过十之前的第二个，是呀，哦哦哦，看看这个，挺酷的，我在那上面重用了10个好工作，我不必用另一个临时的扣杀速度，我要去喜欢超驰，反正，这就像说x十等于x十加十二，那很酷。

这意味着我不必使用另一个划痕寄存器，为了有更大的足迹，我这样手工编译真的很好，这有道理吗，现在x h加上3等于x 10，我现在要把它，我要把它储存起来在这里看我，我们去储存X10的消息。

里面有一个加3到这里，我们到这里来，我们十人一组，所以很抱歉10是一样的，十和十一点关系都没有，X10是把它放进一个10的临时空间，我的常数是多少？让我们一起做吧，我的恒定基寄存器指针是x15。

我想把这十个点，那么还有多少，第十个家伙是多少字节，这是一个整数，为什么第一行是int，这一切都暴露了，int，如果这是一个结构，那更大，不是那样的，这是一个整数，四点了，我数组中的4倍是40。

那是我的常量，现在我把它塞进一个10，我在那里很聪明地重复使用x10，我只想强调，给你自己留一点笔记，尽量减少寄存器占用。

所有这些东西，啊，那真的很好，好啦，现在还有一件有趣的事，但我们有攀登点击器，我真的很兴奋，这太棒了，我得去滑梯了，这是点击器之前的最后一张幻灯片，我相信除了J之外，文字的转移，把字节转移到。

加载字节存储字节呜呜，相同的格式，你只需把w换成a b我以前看过这个节目，打电话给电力公司，就像莱特曼，它会把毛衣上的W去掉，你会撕开它，在那里做一个B，你可以把这个字母人毛衣上的皮革换掉。

喜欢电力公司的人，没什么好吧，那么这是做什么的这个加载这个咬。

就在这里，我们走吧，在我们开始这个部分之前，这很重要，我们简单地提到，当你读写内存时，内存需要字对齐，你需要在四个数字的整数或倍数上阅读，所以这个基地址最好是4的倍数，这个常数最好是4的倍数。

如果我在阅读和写作，int，我将为，这就是所谓的字对齐，这些东西必须是四的倍数，你拿4的倍数，把它加到四的另一个倍数上，你得到4的倍数，所以这很酷，人们总是问，会不会是一个非数四，那是一个非移动的。

他们只是碰巧增加了布雷特，是呀，但是不要那样做，保持两个4的倍数干净。

但这里发生了什么，我在读一篇文章，一定要四的倍数吗，否，我想吃一口，就在那儿，这就是咬，不是不是那个东西，我在看字节，不再是言语，对呀，不只是一个，然后是第四个和第四个，这些是，但我想要那个字节。

这里的第二个字节，我想要第三个字节，所以x11是单词边界上4的倍数，但这意味着我希望第三个字节在那里，这可能是一个字符数组，我想要，那是第四个字，对呀，零一二三，现在第四个字，有趣的是。

就像负一记住负一是什么然后选择补语，减一的都是一，你知道为什么，因为零就是零，你往回走一英里，你把你的里程表包装成所有的，或者你是负一加一，它都是零，它包装是好的，如果我有这个，所有的，好像减一。

如果我说的是int下划线8，对吗，八位宽的int类型如果我顺便加载这个，这里是什么，它在哪里，那辆自行车在哪里被复制来观察低圈，幻灯片中非常重要的那个圆圈，该寄存器的低字节位置，因为我有一件事。

我被抓住了，听着记住从右边装货，我要带着一个很小的小指去那里，我对一个大词很有一手，有一点小指，有点小指，一点点捏，我在捏一口，这里是捏捏，咬伤，捏一下，你被困住了，但我正在填充一个四字节的东西，2。

我把它塞到哪儿？嗯应该是，是不是应该和，如果是最上面的字节，应该在不的右上方吗，它总是，不管它在哪里，它把低字节位置标准，好啦，所以如果这些都是我减去的一个负荷，我怎么处理另外三口，嗯，把它们变成零。

那看起来像什么，如果我说它是整数，让我们选择补四个字节，什么是低的，四个零的字节，剩下的数字看起来像什么，谁能告诉我，我把数字减一，它应该被保留下来，因为负1就好了，它看起来像什么。

如果我加载了1的8位和0的其余部分，这个数字对你来说是什么，二五五，我的数字从-1变成了2-5-5，因为它把零放在那里是有意义的，我不想那样，我希望它是负一，所以加载字节取那个位，不管那是什么。

这就是标志，在某种程度上有点，记住是零，如果它是零还是正，如果是阴性，就一个，记住这一点，它涂抹了它，所以现在我加载我的负一个，它把所有的都放在右边，那家伙会是一个，就像英式松饼上的一块美味黄油。

但这块黄油和鳄梨涂在吐司上，你把它抹得一干二净，所有这些比特都是从那个比特复制的，很酷吗，结果，现在都是一个了，这就是整型数的二分之一补数，所有的整数是多少？减一。

所以减一来自八乘八位变成了减一和三二位，它工作得很干净利落。

所以这真的很酷，PS，我们也有加载字节无符号，因为如果这个数字是一个无符号的8位，意思是二百五十五，我使用加载字节，突然变成了负1，或者它成为最大的数字，那是个无符号号码，无符号int，所以我不想那样。

所以说，如果我不想让它做得那么低，但是Unsign没有涂抹它，在那里写了所有的零，所以无符号把所有的零，加载字节会将该位涂抹在，所以这里装了一个25，未签名将保持二五五，不会变成负一，或者一些大数字。

如果它被视为a作为a作为int，就像我说的，好的，我的问题是，我得到了三个指示，这个不错，这里，我们顺路走，如果你还记得，呃，在这个上面，上面写着，文本ddg二，我的电话号码是多少？二二三三三。

短信DDG到二二三三三或去投票，EV网络，斜线DDG，我问你里面有什么，十二，我们一起读吧，我们在说什么，加i，X零，我希望你还记得X零是什么，让我们从最后一个开始，她演讲的最后一分钟是什么x零是零。

为零注册的Rezero，总是零，九十三英尺五，那是个有趣的数字，我把它装进x11，那是临时空间，划痕空间，存储单词x十一零x五有趣，x 5个点到某个数组，把这个词储存在最下面，这两个都是四的倍数。

所以我们很好，五个中的一个记住加载字节做什么，如果你抓住一个偏移量，所以我储存了一个词，但我读了一篇文章，我握住你的手，我用拳头塞一个字，我捏了捏我的镊子，我咬紧牙关，x12是什么样子的，应该点击投票。

有很多不同的选择，我把尽可能多的选项，如果我能让尽可能多的人，我想尽可能多地解决这个问题，让这种混乱浮出水面，我想我有时间问另一个问题，在这之后，这将是伟大的，看看这个数字，顺便说一句，不要只投多数票。

那就不好了，只要找到你自己的号码，是呀，问题，是呀，我们有一个小问题，我们有五级危险，我们正在做一个小endian，你是决定画右边的线形还是左边的线形呢？那由你决定，你怎么看，但总是有点，风险五。

在这里之后，我们不再谈论一点点了，从现在开始很少了，除非你在写日期，在这种情况下，你应该把它写成86，零一四，明智的毫米dd，这么好看，我是说，看看看看看看，我在努力让人们有不同的看法，我太高兴了。

这太棒了，这个以前是说右上角的一个数字，右下角，你应该说总共有多少人投票，我不认为这有什么奇怪的，但我喜欢，只是动态的，我没有删除幻灯片，太酷了，好啦，我看到很多人说，九十三，没人抢我的九。

九十九还是九十三，我不知道那个，我应该加一个93的选项，九十三，九十三，九十三，九十三四五，你知道的，我应该有那个的，我忘了那个。

我喜欢它，我可以冷冻它吗，那是之前那个。

我想没有办法阻止它，嗯好吧，我们试试看，这是我的，右边是我的记忆，如果可以的话，镜头可以对着我，这是我拿的93，太感谢你了，九十三华五，我把这个存起来，这将成为记忆，这是呃，这是一个进入内存的指针。

这是记忆，我从右边带来的，这边这个，确保我用正确的东西是x12，对呀，这是我的X12，我在里面储存了什么，九十三四十五九三五右，所以这里是九三五对，那很好，现在我想要x/x 5 x 5。

我应该说这x五个点战斗，只是想让你明白，所以这就像，也是x5这里有一个零，同样的事情那是什么没关系，所以现在如果我说1 x 5，它指向93，我加载那个字节，我把它放在这里，所以就这样了，咬在哪里。

去同一个地方，它去了同一个地方吗，否，它去哪里，最正确的人，九十三谁知道九十九的比特是多少，我的鳄梨吐司呢，把那个涂片，那边那个，上面的都是什么样子，然后呢，它看起来像什么，一个人在九三四年，哦对不起。

我的错，我的错，我的错，不不不，它值我一万K K K，让我们做吧，让我们做吧，我们就这么做吧，如果这些都是，这些都是，如果这些都是，呜呜，我有太多这样的东西，有F F F F和我没有，我做了太多。

一切都结束了，所以我得到六分九十三，好啦，不错嘛，哼，你忘了加载字节，那是那是个骗人的问题，这不是诡计，但它依赖于你记住加载字节，那涂抹，你们都忘了抹黑。

如果你把93，你在想加载字节，未签名，好啦，最后一个做，我有时间，好啦，下次人们会开始的，下次是个好机会，是一个小讲座，这是我做的最后一件事，太感谢你了，这是一个由两部分组成的讲座，我们就继续这个问题。

下次我们要做的第一件事，太感谢你了。

各位，星期三见。

P11：Discussion 3： Floating Point - 这样好__ - BV1s7421T7XR

所以我想我们准备好了，大家都好吗？你们这周有项目要交吗，嗯，所以我们有一种合并的讨论，所以他们用半浮点符号，这是个新话题，然后我们有一半像C内存管理，嗯，好吧，首先物流，我相信你知道，一号项目周三交。

嗯，如果需要扩展，或者任何接触，员工的邮件，嗯，我们星期五照常有一个实验室，今晚我们还有作业要做，所以你需要帮助，有办公时间，嗯，我们要去，我会鼓励大家再次扫描这个二维码，我想感受一下，每个人都想掩护。

不管是种子内存管理还是浮点，我可以判断，所以如果你想检查一下，是啊，是啊，为了澄清大家都拿到了工作表，或者把它放在他们的iPad上，你需要一份工作表，呃，纸质工作表在前面，所以给它几秒钟，是啊，是啊。

Zoom上的人也可以随意填写调查，我可以在聊天中发送链接，如果这能让你，只是想澄清一下，看内存管理真的就像，如果声明数据类型，它在内存中存储在哪里，不管是出于功能，函数之外，我们不打算做。

就像今天的指针崩溃，如果这就是你想关注的，我建议明天去和卡罗琳讨论，她有一个深潜，但看起来大多数人都想再做一次C I刷新，这是现场直播，但你不知道爱，好啦，是啊，是啊，好啦，所以是的，所以我们就。

我们将主要关注C，我们会做一点浮点，差不多是一半一半，所以是的，我们要尝试两者兼而有之，不过，我们会，我们很快就会看完的，嗯，我们的记忆中有四个分区，嗯，我们有一个堆栈，它主要用于局部变量，它是。

它是我们可以修改数据的地方，嗯是的，我认为局部变量，局部常数，函数中的参数，记住C是一个按值传递的过程，所以如果你通过了，说整数而不是整数，指向将复制该整数的函数的指针，然后在该函数的堆栈框架中。

Key最著名的是你的MC，你的卡利，然后是移动东西或调整大小的现实，静态基本上就像一段稳定的内存，它将被代码的所有部分共享，无论你是在一个功能，函数之外，嗯，我们不能作为用户修改，静态内存中的任何东西。

嗯，所以字符串文本，就像你在这里看到的，我们有一个字符指针，S等于字符串文本将处于静态状态的文本，因此，如果您声明一个字符指针并将其分配给一个字符串，也就是说我们不能修改那个字符串，它是不变的。

有一个微妙的地方，如果创建字符数组，我们将看到这些问题中的一个，但实际上我们会解决这个问题，我以后再解释，然后我们还有代码段，也称为数据段，嗯，就本课程而言，你主要只需要关注它包含的事实，嗯说，就像宏。

当您执行标签以查找程序的顶部时，或者嗯，是啊，是啊，这是上学期留下来的，但是呃，稍微谈谈数组，嗯，我觉得我们会有点进展，在其中一个问题中，这是一种区别，我说的是弦，不管是字符数组还是字符指针。

有趣的是如果你创建一个字符数组，字符串文本将被放入静态内存中，但是这个静态字符串文本将实例化您的字符数组，在台阶上，您有该流的两个版本，字符数组允许我们在堆栈上修改它，但是当我们退出一个函数时。

我们正在修改字符串，堆栈数据消失了，嗯，这就是为什么您通常不希望返回字符数组，因为它可能会指向垃圾数据，嗯字符指针，但是，嗯，有人质疑，你刚才说，这两个版本，是呀，是呀，是呀。

所以当我们声明这个字符数组时，假设我们在一个函数中，我们把它设置成你好，嗯，你好将被放在静态，但是这个静态内存被用来创建一个字符数组，到堆栈上，所以我们的堆栈上有Hello和字符。

但在我们不能修改的静态内存中，但因为它也在静电上，我们可以修改那个流，然后字符指针，这只是一个内存地址，直接到静态字符串，从字面上看，所以我们可以把它传递给另一个函数，如果我们需要复制，你看，搅拌。

复制很多，可能在你的项目中，需要两个指针，所以这就是这种，这里的区别，你不能真的改变，有人对此有什么疑问吗，是呀，你知道的，所以当你喜欢的时候，做一条小溪，我喜欢或明星，例如，在函数中。

然后这个函数就消失了，就像事情消失了，那个静态变量就像一个静态变量，哈喽，停留在静态内存中，或者，你知道的，是啊，是啊，这是个好问题，所以静态记忆，就像现在一样，嗯，您可以添加到其中。

当然还有创建更多的字符指针，但它将在你的程序期间保留，所以一旦你的程序终止，那就是，我是说，我们不再担心那个地址了，因为我们的节目结束了，嗯，所以它基本上消失了，但如你所知，我们从来没有真正喜欢。

清除所有内存，它只是坐在那里，没有东西指着它，这回答了你的问题吗，或者是的，我只是在想我们应该，有没有责任，或者类似的事情不，因为这不是热度数据，所以每当我们使用免费的。

那个空闲呼叫对应于某个地方的malloc呼叫，这总是一个很好的练习就像，无论何时使用malloc，我会在它下面写免费，然后找出你以后需要免费的地方，但请记住一次失误，一个电话，相同的功能框架。

我们已经将其添加到静态内存中，也许那个函数我们仍然可以得到指向静态内存的指针，框架关闭，但我们仍然可以参考，是呀，您可以返回指针，嗯是的，是呀，绝对的，如果该指针存在于函数之外，嗯，我是说。

它还在静态内存中，所以肯定，是啊，是啊，那很有帮助，呃，关于动态分配，我觉得你可能已经练习过了，到现在为止，马利克，你会给它一个指定的字节数，你想从计算机中获得，它会给你返回一个指向内存某个部分的指针。

有这么多字节，嗯，但它可能包含垃圾数据可能包含来自另一个程序的剩余数据，所以我们不能假设它是在零初始化的，但是KC C我们做同样的事情，注意calc中的参数有点不同，指定此大小项的编号，你知道。

所以你指定大小，然后是物品的数量，这是一个有点不同的木槌，你只要把字节数传给它，但是calc会把一切都初始化为零，所以你可以相信这一切都是零，是啊，是啊，那么利用这些知识的好处是什么呢，呃。

这是个好问题，嗯，在一些不同的情况下，使用calc可能会有所帮助，就像，说，你很懒，你想初始化一个字符串，您不希望在字符串末尾包含空终止符，你有一个五个字符的字符串，当你实例化时，你必须做五个字符。

加一个右，呃，您可以在calc中执行六个字符，而且已经，你知道的，候补，嗯，这是一个很小的例子，没那么重要，但在有些情况下，你不知道绳子有多大，你要放进热记忆，所以最后你可能会有一点额外的。

你不想担心缩小它，在终结者中完美，所以你可以填写你的角色，你就完蛋了，在现实中，只拿一个指针，分配内存，冻结它并分配更多内存，所以说，或更少内存，呃，你基本上只是缩小，呃，您给出数据分配的窗口。

我想在mc和caleb的区别上加上一点，通常malloc实际上比calc快，你会看到，如果我们决定使用我们以前的优化项目，但是是的，使用malloc更快，在某些情况下，这其实是一个很好的观点。

有人知道为什么它更快吗？没错，所以Kalik是N个字符中的O个，你必须初始化，每一个字符都是零，而mc只是找到初始指针并返回它，这是一个恒定的时间，是啊，好吧，我的意思是说，但你得检查一下那个空间。

这是一个更像面向操作系统的问题，是啊，是啊，那更有方向，是啊，是啊，我跟你说实话，我不知道它是如何确定，比如它会回到哪里，这块内存，那是那是更在，就像操作系统，所以这是硬件引擎的问题，呃就像支票。

和老板喜欢喜欢你是喜欢软件，是啊，是啊，嗯，我是说，Calc也必须做同样的事情，因为它不想清零，对另一个分配实际重要的数据，所以我们几乎不用担心，因为不管怎样他们都得这么做，好吧嗯，让我们进入一个问题。

我觉得很简单，它需要一个内存块返回到另一个内存块，然后你知道，我们今天其实不打算报道，我想那是上周，是啊，是啊，在菜单上，我们加了点东西，所以说气动的，呃，就像五个州，然后我们的反应就像一百个什么的。

在最初的五个州，它没有一百个病例，所以我们得把现有的数据复制到另一个地方，右右，是啊，是啊，是啊，是啊，是啊，是啊，所以嗯，是啊，是啊，你基本上是把分配给你的那块，如果它不能，然后是的。

它会把它带到别的地方，但在更大的窗口，好啦，所以让我们做一些预先检查的问题，嗯，我们一起走过这些，内存扇区由硬件定义，不能更改，有人对此有什么想法吗，也许就不能改变了，我们能改变。

正在堆的内存扇区的扇区，堆栈，静态代码，对耶，所以我们可以改变堆，对这样我们就可以改变温度和堆栈，然后这个问题的另一部分，它们是由硬件定义的，不一定是真的，硬件将指定我们机器中的总内存空间有多少。

但是操作系统会把它们分成相应的部分，是啊，是啊，当我们打电话的时候，我们会更多地讨论记忆是怎样的，这些内存扇区的排序是在运行时定义的，而不是通过硬件，按部门分列的小问题，你指的是堆栈，是啊，是啊。

对于大型递归递归函数，您应该将数据存储在堆栈上的堆上，你们对这个事实有什么看法，假的，假的，你为什么认为酱汁因为本质上你会，您可能会结束许多类似堆栈调用的顺序，因为在递归中，我们有很多类似的电话。

同样的功能在一些如果你想看到，很明显你可以，所以我的意思是，我们可以看到递归基本上是一种um行为，不管怎么说，对呀，我们有一个函数调用，它调用其中的下一个函数调用，它在其中调用下一个函数调用。

一旦n个函数调用终止，这个终止，这个终止，所以它是，它基本上就像一个堆栈，对呀，嗯，所以当我们在这个堆栈框架里，如果我们想到的是记忆，我们希望这一切保持不变，直到所有这些递归的事情都完成了。

然后我们可以摆脱记忆有意义的方式，好啦，嗯好吧，所以我要给你们几分钟来看看这个，让我们试着为所有这些类型的数据找到一个家，是啊，是啊，一个问题是，你是说对于任何我们不应该使用的函数，建议你不要。

你能做到的，但是有一种叫做数据或内存碎片的东西，不断分配内存，中间可能有很多空隙，取决于大小和我们可以依靠的堆栈，你知道的，当我们完成这个函数，记忆消失了，但就像你一样，这个词很好，是呀，是啊，它。

你得花更多的时间，嗯时间，嗯，就我的时间而言，是啊，都是因为你会，您必须分配内存并返回空闲的，但我们喜欢看涨期权，你绝对可以，只是建议你这样做，谢谢你，每个堆栈都是一个好的大小，我是，这是个好问题。

我忘了做那件事，对不起，嗯，这是个问题，他们只会说在中央索引上使用生命是愚蠢的，有指向文件夹和文件夹的链接，我这边有一个很高的东西，你有一个布兰登和，是啊，是啊，是啊，是啊，所以有趣的是，呃，我是。

这是真的，有一个讨论，好啦，我去看看，在同龄人中随意交谈，如果你有任何问题，所以是的，或要求帮助的政策，你还记得我们链接到网站的哪个文件夹吗，就像谷歌幻灯片文件夹一样，啊，一切都是等待，是你贴的吗不是。

哎呦，我想我做到了，是呀，好吧不，我刚才，我是说，这很好，呃是的，所以两边是，呃，对不起，谢谢你，我以为我忘了，我不把那个具体的，虽然我把链接，但我没有把那个特定的幻灯片，嗯，我们击中了链接。

然后当我更新我的，可能会跳过链接，这个问题，有点太多了，所以要花很多时间，这是怎么回事，一个不是一个问题，好啦，为了节省时间，让我们，让我们开始吧，静态，是呀，是呀，这很容易，局部变量，静态堆栈右。

全球，静态静态，这三个人对每个人都有意义吗，这是个骗人的问题，实际上有三个方面，所以常数可以是，可能是一些事情，就像被定义为宏观常数一样，就像，圆周率等于三点，一个，四次罚款，我等于，是啊，是啊，嗯。

在定义宏的代码中，嗯，如果它是编译代码行的一部分，所以说，整数x等于x加一，就像一个可执行文件，C代码，如果一个加一个，实际上会编译并存储成代码，嗯，如果我们有常数整数，指令性常数x等于5。

不管那是什么就像全局变量，所以它是静态的，有人能想到这样的例子吗，是啊，是啊，如果你喜欢在你的主要功能，你说x等于红色，甚至在任何功能中，对嗯，如果您只是用堆栈将变量赋给常量，对不起，你知道的，本质上。

你是说局部变量和全局变量都可以是常数，是呀，是啊，是啊，常量的意思就像常量的常量，这不仅仅是指宏观定义的权利，是啊，是啊，所以是的，它有点大，是呀，好啦，呃，机器说明书，我们刚刚讨论过，代码正确。

我们将，当我们进入装配时，我们也会看到的，嗯，字符串怎么样？我们讨论过这个，关于静态和堆栈的一点知识，因为记住当我们创建字符数组时，是啊，是啊，是本地的，它是储存和静态的，但也可能是，是啊，是啊，是啊。

是啊，但它也可能是成堆的或健康的，是啊，是啊，所以它可以取决于它是指针还是数组，它可以复制过来，也可能直接指向静态内存，嗯我们有这个，是啊，是啊，我想我们有一个充满活力的，那么我们可以有一个动态分配。

呃，所以当我们谈论动态内存分配时，我们说的是malloc和calc，呃，命令，所以这些将返回堆内存，嗯，如果我想在其中创建一个动态数组，我们不能喜欢苹果，呃，堆栈记忆就是你说的，或者像这样。

不是由Malbut反正在那里，你可以创建堆栈空间，就像如果你创建一个字符数组，你想扩展它并添加到这个字符数组中，嗯，它将存储在堆栈中，是啊，是啊，但那不是，嗯，在动态配置方面，那只是静态的，但它会。

是呀，我是说你，您可以在字符串上复制，分配内存，绝对的，是啊，是啊，所以我猜，我想也可能是，我得考虑一下，是啊，是啊，这是一个很好的论点，也是，就像字符串的堆叠版本，难道不一定是字面上的字符串吗。

因为它只是复制字符来堆叠空间，字符串字面意思主要是像一系列带有all终止符的字符，有点灰色地带，是啊，是啊，那感觉好多了，嗯，我们有一个像指针这样的链表示例，但是。

我想这可能符合我们讨论过的每个人的最佳利益，浮点一点点，这些解决方案也在网上，如果你想看看，但是，我对这些幻灯片的想法，我真的希望他们，就像给你们一个好的参考表或备忘单材料，怎么了？演讲者，否，否。

所以我们需要思考，在浮点方面，就像从十进制到十六进制或二进制，嗯，通常使用我三七五四标准，这基本上只是告诉我们有一个迹象，八个指数位和二十三位数字，所以你可以在这里看到，你知道重要的是。

我们有两种主要的浮动类型，我们有一个规范化浮动和一个非规范化浮动，去归一化浮动对应于，非常，非常小的数字，其实呢，如果我们看这张桌子，我们看d范数，指数为零，在我的黎波里标准，我们的偏差是负一二七。

意思是零，加负一二七等于二等于负一二七，那是一个很小的数字，所以无论何时你在想，你知道的，这应该是d范数还是范数浮动，这就是你的数字是否按条件计算的问题，或者2到负的数量级1 2 6到偏的数量级2，嗯。

归一化浮点数仍然可以表示相当小的数字，它们可以表示2以上的数字到负数，两个，六个，或者它可以代表非常，非常大的数2对1 2，六个，当我们做数字表示的时候，我们谈到了偏见公约，我们讨论了无符号表示法，呃。

你可以看到这个指数字段表现得像一个偏置符号，你知道的，我们有1代表负，0代表正，如果我们看看长浮点二进制表示，就不会是这样了，不会像延长的标志一样，因为我们只有一点迹象，好啦，所以这是一个信号幅度。

从某种意义上说，然后重要是有趣的，因为重要，对应这些字段，所以它就像无符号二进制，但向后向右，所以我们有零点一，这些是二进制数，对呀，每个人都这样，如果你有零点五，你想代表这一点，在我们重要的。

我们就不会有零，零，零一，我们不会，我们不会零延长它，我们就会有1 0 0 0 0对，它在另一端延伸，这就是我想说的，对不起，到目前为止关于浮点有什么问题吗，是啊，是啊，你能，呃，在前面的这一边。

你知道吗，我是的，是啊，是啊，是啊，是啊，所以当你认为正常化和反正常化，想想小而大的数字，极小或较小的大数，归一化浮动可以表示小数字或大数字，非正规化浮动只能表示非常，非常非常小的数字，所以符号，啊。

是啊，是啊，是啊，是啊，就在这里，所以非正规化从这个隐式零开始，规范化从这个隐式的开始，然后点你重要的，还要注意，在作业中这里有一个小加一，浮点作业，你会清楚地看到加一在哪里起作用。

但是每个人都忘记了恶魔还有一个伴，它基本上是两者之间的界限，所以没有重叠，好啦，所以我想，这可能更容易，如果我们遇到麻烦，然后我们就可以，我们可以谈谈，我已经写下了你想要经历的程序，从小数到浮点。

和浮点到小数，但是让我们先解决几个问题，第四步是用i乘以3，E标准，我们有这些位场，让我们只是转换，这个数字变成十进制版本，如果可以的话，我给你几分钟时间，对不起，我不知道这张桌子对你来说是不是太小了。

但我包括了十六进制转换和二的幂，我不知道是什么事，你能告诉我，哎呦，我想是关于恶魔的，是呀，是呀，所以请记住很小的数字，一加一，一点七，好啦，让我们开始讨论这个，首先。

我们需要将这个十六进制转换为二进制，所以让我们来填补一些位，所以这是我们的位场，在这里，我们有我们的标志位，我们的标志是，一右，因为我们的前导x字符是f，所以它是1，1，1。

下一个十六进制字符也是s so one one one one two two one one，准确的说是1 0 0 1，我们需要继续吗不不，我知道指数是255，如果我们看看这张桌子。

我们的指数域是2 5 5，我们有两个选择，它要么是我们有效值的无穷大为零，但事实并非如此，所以说，我们有一个非零显著，我们已经可以看到我们有，继续下一个，我们有这个花车。

让我们把它转换成x中的浮点表示法，我希望我能放大这个，假设每个人都记下了号码，我将转到我的幻灯片，它描述了如何从小数开始，很有希望的流动，这很有帮助，从这个开始，有人想让我，我们应该在哪里。

我们从哪里开始呢？我要去，是啊，是啊，是啊，是啊，完全正确，我们可以写下符号位为零，我们有一个正数，我喜欢做的事，至少我不知道，我们有很多方法可以解决这个问题，但我认为最简单的方法是。

让我们把它转换成二进制，这个二进制，如果是阴性，我们做同样的事情，我们只是取它的负位正弦是1，我们把消极的积极版本，有道理，嗯但是是的，只有小数两边的无符号版本，将两者转换为二进制，很快的，所以三十九。

呃，原谅我，我对二的力量很不在行，所以我就这么做了，还是，这里有点，嗯，因此，在不超过我们的数字的情况下，我们的数字中最大的是32，三十九减三，二等于七，第二大的是四个，减去四和七，我们有三个。

结果是2比1，所以是三九，然后这是我的小数点，这里，呃，如果我们看这张桌子，我们从零点五开始，呃，写零点二五会很难，零点一二五，零点零六二五，好啦，你得到他们，我们的号码其实很容易签。

我们有零点五加上零点零六，二五，所以我们可以把这两个部分，那里有一点，零零，那里有一点，这对每个人来说都有意义吗，这可能会变得有点复杂，你必须做相反的事情，所以你会说你知道它是这么大，然后零点五。

如果是的话，你知道你，你检查一个零点五，减去零点五，你找到下一个，下一个，但在这里很容易，我们在零点五，减三，零点五六二五减零点五，接下来我们就在这里，现在我们要把这个小数移过来。

所以我们有两种不同类型的浮子，我们有一个规范和一个D规范，你觉得我们在和谁合作，诺曼底规范和，非常小，是的，是的，是啊，是啊，我们是在和非常小的人合作吗，我们将期待，所以如果我们用一个范数，我们将期待。

还是，就在这里，一个领先的，因为我们希望领头的那个，我们需要多少个十进制移位，五个耶，所以我们要把它移动五次，一二三四五，好啦，所以现在我们有一点，零一零一零一零一，一次，二到五，大家都跟着。

所以我们有点接近我们正在寻找的代表，我们看起来有点像这样，我们有一个2到某事的时间，一分，一些事情，我们现在需要用偏置符号表示五，这可能会变得有点棘手我们的偏见，负1，呃，负一二十七。

所以我们需要一些正负号，一二七等于五，所以我们可以做，让我们做，所以x是5，所以如果偏见，那么5-偏置等于Rx，我就不跟随了，所以这将给我们一，三，二，这就是我们的指数场，记住这是一个无符号号码。

再加上偏见，我们的偏见是负面的，所以它会把我们带回五个，所以我们有两个字段，到目前为止，我们有了我们的符号和指数，我们重要的，我想读出对我的意义，只是在事情上呃，在二进制点的右边，用零填充，在呃。

有衬垫，怎么呃，在左边这么近，但是请记住，这是小数点的右边，所以我们实际上想在右边垫，哦耶，对耶，完全正确，它是，它确实欺骗了很多人，但意义重大，会看起来像零，零一，一个，一个，一个，零，零一。

然后下面的所有这些零都记得这是我们最初，呃，所以让我们一起做这件事，所以我们有零的符号出价，我们有，呃，哦，伙计，一，三，二，指数井，二三四一二三四，不要对我评头论足，一二八位，是呀。

减去我们剩下的四个，好啦，他们不会跟来的，我是怎么做到的，可能更快的方法，但我已经习惯了，好啦，所以让我澄清一下，嗯，签了名，接下来是我们重要的，零，零，一个，零，零，继续，所以让我看看那些。

一至二十二，是呀，我是说，我们可以我们可以这样想，或者我们也可以，呃，把它翻译成十六进制，从左边开始，对呀，我们知道我们会有三个两个比特，所以这一切都将完美地映射成十六进制字符，所以我通常会做的。

如果我们知道它完全转换成十六进制字符，完美转换意义，好像是四的倍数，我们就可以说好，好吧，这里会有四个，所以我们有公牛4号，这将是，让我们做这个真正的快二，呃，就在这里，一个，可能又是我的笔迹。

剩下的就是0了，所以它在32位，表示四字节数，所以一个接一个，我们需要一个零，那里，三个字节，然后第四口，我很快就经历了，所以请提问，有很多东西要跟踪他们，再次，我知道乍一看可能，好像我们做得太多了。

所以我敦促你按照我的幻灯片在中央索引和张贴，看看这些小数，浮点，浮点到小数，所以当你做作业的时候，你得多加练习，是啊，是啊，你怎么认为，嗯好吧，所以我们只知道它不是负的二次方，一点六，所以是的。

对于d规范，我们说的是像这么小的数字，喜欢乘以2到负一点六九，是啊，是啊，但也可能是零点零，一乘以二的负数一二六，但那将是一个，嗯，在你们离开之前，我想已经很好了，我们有三分钟。

我确实有这些问题有点棘手，它会出现在你的考试和作业上，所以我们可以早点离开，或者我们可以过去，就像其中一个，如果你想，好啦，由你决定，但是呃，好啦，让我们来讨论下一个大于2的最小数。

可以用浮点表示法表示，但我想这意味着什么，我只是随便看看，因为我们时间不多，但是我们如何表示2和浮点，我们有消极的，一次，什么是积极的，会是0乘以2，我们知道我们在用规范化的流程工作。

所以会是一分什么的，所以让我们让这感觉太对了，2是我们想要的数字，所以说，我们走吧，是啊，是啊，这就是2的浮点表示法，所以要找到下一个大于2的最小数，我们只需要找到我们可以添加的最小增量，当我把零。

最后一个切中要害的，在那里你解释，对不起，哎呦，所以不是，这有点像，你得了1分0 0 0，所以在最后，最不重要的一个，你只要把它改成喜欢，是啊，是啊，是啊，是啊，没错，我们想把我们的重要性增加一个。

我们可以谈谈，这是一个就在这里，这里是二对二对三对，在我们的重要时期，我们有两个三个比特，所以这是1加2的负2，三次都是两次，因为记住我们这里有两个，所以那是，这就是解决办法。

我们能表示的最大奇数怎么样，我们说的是非常大的数字，所以我们有一个规范或规范规范，所以我们有一个除草的，我们的标志位，它很大，它将是负1到0，这里的诀窍是我们想找到一个奇数，我们可以表示。

意思是最不重要的一点必须是对的，嗯，但是我们需要用浮点表示，所以我们有了重要的部分，两个三比特，我们说的是指数移动的点，小数点后，我们正处于我们重要的，大家都明白为什么，基本上，如果我们修改我们的重要。

嗯，所以我们有一点，想要一个大数字，所以所有这些都将是一个，说是一个零，我们把二乘以二十三，这意味着它要把这个小数一直移过来，最后一点，所以它是一个整数，这一个甚至会是正确的，因为它们的最低有效位是零。

所以我们能表示的最大奇数是这个位为1，所以我们这里有领先的1和23个，所以我们有一个二，四位，数目，实际上这是什么，二除以二十四减去一，n位字符串可以表示0到2到n减去1，那是我们的射程。

请在出发前扫描这个，我们非常感谢您的反馈，如果你有任何我们今天谈到的问题，我可以。

P12：Lecture 9： RISC-V Decision Making Logic Ops - 这样好__ - BV1s7421T7XR

我更喜欢开车，很高兴参加，如果你必须有一个，这是新新闻中的计算，是在上课之前，我会有研究人员使用的第一个字母，德国马克斯的科学家，普朗克大脑研究所使用ml算法分析了三种，六百只鼹鼠在七个群体中鸣叫。

识别每个完整说唱的独特声音特征，以及每个日历的相同方言，看看这个，多种族项目希望决定抹香鲸的交流，通过ml专家的努力，海洋生物学家，机器人学家，语言学家和密码学家，该项目将包括记录鲸鱼的声音和动作。

水下麦克风，机器鱼和声学标签，你看，它起来了吗，迪斯尼起来了，狗有一点，我们可能会到这样的地步，有狗带着你狗身上的小东西，实际上说出他们所做的，我们才刚刚开始，这很令人兴奋，我也很令人兴奋，东西，松鼠。

开始了好的，女士们先生们，欢迎来到cs621c讲座，九险五，决策与逻辑运算，爸爸，你们一直都在这里。

我们上次看到什么是字节可寻址的，我们知道，在你认为内存是一个大数组字节可寻址之前，但你要访问的东西是，通常，当您索引，整数，浮动，那些，好啦，加载字和存储字使用的指针，呃，最好是4的倍数。

如果你在阅读和写作单词，我们谈过了，我们可以对它进行加减，所以你有一个基地址指针，它前面有常量，在它的背后，挺酷的，我们讨论了大印度人和小印度人，我们看到了五种新的读写记忆指令，什么也很酷。

你还记得CPU的咒语吗，你还记得中央处理器吗，我想出了一个新的咒语，CPU你，你是CPU，得到一个CPU，你是CPU，这就是为什么你认为这是一个非常以CPU为中心的对话，主的门，从我是CPU。

我推推搡搡，我不是记忆，如果我记得，全都倒过来了，你是CPU，获取要从。

好啦，这就是我所看到的，我会检讨决策。

这是我们今天学到的新东西，我们得做决定，我们必须使我们的程序智能化，使我们的程序智能化，你得做出选择，如果是这个做那个，你看到了ml算法，那肯定是一千亿，如果考虑神经网络中所有编码成数字的情况。

到目前为止我们已经看到了，加和减，我们已经看到了一些即时的加I，你也看到了五个装载和储存。

所有这些都是新的，所以决策，所以根据计算，做点不同的事，这个核心是一般的，if语句，是if语句吗，就是这样，如何将if语句编码为风险五，你在那里是这样做的，它是，这是你的假设声明，B q代表分支。

如果相等，则寄存器一寄存器二标签，你第一次在标签前看到这些东西，你可能看到过一个标签，如果你以前见过任何风险五代码，它只是一个小标签，你实际上可以有C中的标签，我们不推荐，但是你可以有C中的标签。

所以这一切都表明，有一个无形的标签，这个标签上写着标签名称冒号，如果你手上的两个寄存器，BQ是平等的控制，现在将移动到此分支相等之后的下一条指令，如果他们是平等的，转到标记为r 1的语句。

所以如果它们相等，去那里，仅此而已，如果相等就去，上面说的就是这些，如果相等，如果这里的寄存器R中的值是寄存器1的，寄存器2中的双等于值，如果不是，你说得好，如果不是，如果不是，你就当什么都没发生过。

你进入下一个语句，你总是要下一个声明，正常正常，一切都转到下一个声明，去下一个是你第一次喜欢，喔喔，喔喔，喔慢点，让我们检查一下，我可能想去那边，好的或者往下走或者往上走之类的，好啦，原来是这么回事。

如果不平等，我们也有B E分支，今天之前你第一次学希腊语，你知道5分钟前你还像个，现在那是什么，你知道的，相等的Eq分支，去那里，如果是，b和e表示分支，如果不相等，挺好的，对了，顺便说一句，好处之一。

我只是在想人们，如果你在变焦，哈喽，每个人，我们有很大的演讲空间，但实际上，上课的学生这么少的好处是，六英尺距离，所以我们实际上在保持Covid方面做得很好。

六英尺距离，只是为了让这里一切都好，我们去这样的分支，你想的分支变成了流和分支，我在搬家，我在这里分支，我好想树上的树枝，啊，我本来想这样或者这样拿一根树枝，我在走两条路，条件分支。

所以我们看到了b q b e，你还必须能够比较事物，所以你需要有小于的分支，我有BLT。

看那个，我已经饿了，我站在你和午餐之间。

那件事我很抱歉，我说过了，我在上面涂了又涂，烤得不错，突然之间，发牢骚，发牢骚，向右抱怨，好啦，BLT，你还会有大分店，如果大于或等于，所以BT和BG，现在我已经告诉你了，其中四个你会用同样的想法。

同样的想法，你有两个寄存器，但现在你要看着我，但是丹你有一点，没有类型，没有与风险五相关的类型，我如何知道这些位代表的是无符号数还是有符号数，不要，我在乎，所有1对所有0，哪个更大，所有的都是对的。

你认为所有的人，除非他们签了字，或者所有的都是负的，所有的零都意味着零，现在0变大了，所以你必须，如果你要给我啤酒，你得给我啤酒，你得告诉我我是没签名还是签名，因为它们只是碎片，如果你要有大。

你最好给我一二三，你，以为我给你，啊，顺便说一句，这也是最后一个，就像，你知道的，忘了什么，我不想要它，到那边去，去那边就叫去，我们叫它跳，你就跳过去吧，我不在乎，发生什么事了？

只是跳什么跳跳那是隐藏的游戏，是跳跳，我可以说，跳，至少，那首歌是什么来着？我不知道，现在是90年代，我知道音乐是什么跳，所以现在我给你，这是这一页，B n e c b g e b n，那是两个。

B T B G是四，BTU BG是6，跳跃是七，就是这样，仅此而已，仅此而已，在决策中。

很高兴看到我们如何使用这些，所以说，让我们说，让我们花点时间看一个例子，好吧，我们来举个例子，我得到了一些变量的赋值，F、g、h、i、j和一些x寄存器，仪表由十指定，十一十二十三十四，我得到了一段代码。

如果i=j f=g加h，现在看我在这里要做什么，我要用这个代码建立一个连接，你要说等等，为什么我要拿平等的，为什么我说B和E，让我们来看看这口井的逻辑，事实证明，当我看到双等于时，我经常。

我要你做的第一件事，我告诉过你是比尼，没告诉你，B当量，我想让你想想对不起，我没有告诉你，先烧烤，B、b和e，双等于b和e y，让我们看看这个，我们走吧，如果i是j，我要你这么做。

但你怎么能接触到这个东西，如果他们是一样的，去别的地方，但我想把这个广告放在树枝的正下方，所以我要做的是翻转，我否定这个案子，我是说看树枝，如果他们不平等，每次翻转，它翻过来了，所以说。

而不是说三个相等说，如果他们不平等，然后过去，我无论如何都要做的事，如果让我们再试一次，所以与其说这是在这里，如果这不是，从逻辑上讲，如果它是相同的，那么说它要容易得多，如果我做这个做这个广告。

我真正想做的是，把广告放在正下方，不管我在做什么测试，但我所能做的，这是走开，所以我要说看，如果他们不平等，离开我想做的事，如果是这样，我就翻转这个案子了，而不是成为B，e q i会写a b和e。

当他们不平等的时候，我去出口，就在广告的正下方，现在我只做广告，当他们一二三相等时，有道理，那有点酷，所以你认为双等号，你说呢，一二三b n e w等于b和e，好啦，我看到一个问题，给我一个名字。

它总是给一个指令，否，你跳到你的树枝上，你想去哪里就去哪里，你可以在你上面分支，在你下面，我只分出两个，是呀，出口有多远，嗯，在这种情况下，我只想在这种情况下，如果让我们看看这种情况，如果只有一条指令。

如果我有一个，如果身体里有很多东西，如果顺便说一句，顺便说一句，我要给你看，这是不好的形式，形式不好，你得有花括号，这是老派的C，这只是我想保存幻灯片上的一些字符，但我真的应该告诉你正确的，其中每一个。

如果你想有花括号，为什么谁知道为什么，顺便说一下，谁知道为什么告诉我，完全正确，我说大声一点，如果没有带，如果所有的如果只是做一个指令，我再说一遍，一条指令，所以你在你的C代码中。

你说如果没有花括号对吗，你说我也很酷，我在挖蟒蛇，对呀，所以我写如果没有花括号，然后你有一个缩进的广告，然后在代码中缩进和缩进减法，和缩进函数调用，你说哟，因为它们是凹进去的，因为我在蟒蛇，缩进不不。

如果我们说没有花括号，你得到一个指令，我只做一个，不是所有的不是，就因为你把它缩进了，不是蟒蛇，发明没有语义意义，所以你认为你在读你的C，你就像，哦，像他们都缩进，我在监狱里要做的四件事。

它只做其中一个，即使看起来是对的，那是你要自己制造的虫子，所以你应该一直这样做，如果你说什么，花括号，好啦，所以我应该在这里加上花括号，好啦，有时还好，所以回到问题上来，我的出口还有多远？

它是你想在你的，如果我想做20件事，在我离开前20行，我可以再分出20个人，好啦，你将要看到的一件事，那真是令人着迷，每条指令都将被分成三个二位，所以现在你在想，三二位等我，我得说明这是一个分支。

我的寄存器有五个位，左边的寄存器有五个位，另一个寄存器5个5位，然后一些标签在哪里的编码，所以这个标签不能是任何数字，就像，天下没有免费的午餐，我得到了三个两个比特，得付钱，有些是因为告诉世界。

告诉系统，是树枝，一些人首先决定这将是第一个注册，那是5个比特，有些是2号寄存器，然后这个东西就是剩下的东西，所以不会太远，可以很远，但不会太远，不可能是三点二到三十二，这有道理吗。

因为你需要我的其他部分来做到这一点，我有点落后了，让我稍后再说，只是有点落后，好啦，第二个问题，我们现在开始，我们有一个，如果有的话，更多问题，更多练习，你越看这个，你就像，哦，我明白了，我明白了。

我明白了我们开始吧，我试着用颜色代码，如果我希望这能有所帮助，我试着用颜色代码，所以对于那些从事彩色工作的人来说，顺便说一下，最佳做法，如果你得到了，如果你能做到，拿个药片，彩色小药片。

你可以在它上面做标记，就像我们所有的幻灯片都是提前提供的，如果没有，我们很酷，这项工作没有判断工作，有了讲义，我们有施舍给任何需要的人，我们正在制造，我们做的越来越少了，如果你不接受，那很好。

但最好的练习就在下一张幻灯片的顶部，好啦，所以让我们做吧，我加倍等于，做这个广告，否则，做减法，我们不要翻译了，在这里，我们去分支不平等，让我们做吧，分支不等于其他，好啦，所以现在当他们不平等的时候。

我应该做其他的，你说得对，如果i不等于j，我应该在另一个，所以手表不等于，我甚至会给它贴上标签，我的标签上写着，帮助您从语义上理解正在发生的事情，另一个是减法，如果他们是平等的呢，那么分支就会是假的。

那种比较，他们不是，都是，他们不等于不正确，他们是平等的，所以我不把树枝放在那里，我做我的广告，那是我的，但如果我没有这个j出口，我希望，哎呦，我希望我有一些无条件的东西，穿过潜艇，因为你猜怎么着。

风险五的工作方式，你只要做下一个指令，除非你告诉我，否则，我每次都在做下一个，试着移除这个杰伊出口，会发生什么，它是做什么的，它做广告，它不会减去，很明显你不想，你想要一个或另一个，所以你得跳来跳去。

跳来跳去，跳来跳去，你得绕着精灵跳，让我们停下来提问，这是一张很好的幻灯片，我现在如何使用这个的感觉，你知道怎么分叉，为什么你过去常常，理论上你很自在，我想我可以说这里有一个考试。

我会给你一些简单的事件，你可以让它发生，我想在这一点上你明白了，不太难，但这是一种新的思维方式，这真的是一种新的思维方式，好啦，全新的思维方式，和p，我又犯了错误，没有花括号，再次记住，我要一直说下去。

那是一个糟糕的幻灯片，从最佳做法的角度来看，在then大小写周围的花括号和在else大小写上的花括号，我们之前说过的问题，是啊，是啊，背后碾压，是啊，是啊，告诉我你的名字，现在你真的写了。

你真的把它写在风险五中，这是有效的风险五，那些标签太棒了，顺便说一句，你可以用C来标记，只是C的，我们通常不标记，因为你不会随便跳过去，这是我的问题，请进，没有名字就是一切，那些名字是我起的。

艾尔莎的武断对你来说是有意义的，对你的逻辑有意义，同样的事情，这些名字没什么特别的，就像，就像一个函数调用，给他们留下任何东西，我喜欢它，但是手来了，我爱，这太棒了，是呀，从前面，告诉我你的名字。

斯蒂芬妮，走呀，走呀，这是个很好的问题，这是个很好的问题，我一时不知道我肯定有多少，所以说，让我们确保你和标准英语站在一起，事情会好起来的，但我们应该看看标签的定义，但如果你只有一个词。

但在那里你会没事的，但一定要检查一下，这是个好问题，对于一个能接触到风险的人来说，这是一个很好的问题，五个手册去，去查查，我手头没有，谢谢好问题，那很有趣，那个男孩，这是对安雅的一个很好的问题。

你如何在32位中为标签腾出空间，所以很有趣的是32位没有标签，接下来会发生的是当我们前进并转换，机器代码，这是汇编代码英文，你应该读英语，但是当您从汇编代码转移到C语言时，它比C语言更难阅读。

把复仇者组织起来，组装成机器代码，那时标签就会消失，所以我们要谈谈，还记得我说过c l编译吗，在最后两个组装和链接标签的过程中组装和链接，走开啦，因此，当程序集划线汇编程序将您想要的所有标签。

以确保你不使用任何，不允许贴标签，喜欢关键字，不要用那些，但除此之外，当你把它组装成1和0的时候，那是你翻译的地方，每一个都精确地分成三个二位，然后在这个过程中标签会被移除。

这实际上是在链接过程的组装中，我会说的，这是个好问题，省省吧，我想我想就像四五节课一样，我看到一个关于是的问题，告诉我那种去，这些都是很好的问题，顺便说一下，谢谢你所有的问题，这太棒了。

我不会有多个同名标签，事实上，这将是一个问题，是呀，事实上，他很好，孩子，这是一个很好的，好啦，我不打算去那里，我想去那里，这是个好问题，我告诉过你我们要进行功能分解，其中编译过程有不同的文件名，对。

因为我碰了一个文件来编译那个过程，假设一个函数有foo，顺便说一句，当您调用名为foo的函数时，将调用标签，另一个库中的另一个子例程，谁不知道那个功能也是，现在当你把它们放在一起，它会说你知道吗。

你有两种食物，他们会是一支箭，所以当你编译它的时候，你看，当你说海湾合作委员会的时候，你没有意识到，它在做编译，组装和连接，但在拆掉标签放下的过程中，就像等待，我有两个不酷的东西。

所以提醒我在编译程序集链接课上再问一次这个问题，但问题是，所以不要不要那样做。

但你会知道，但我想我们会在我的伟大问题中给你一个信息，让我们继续前进好吗，所以我们讨论了小于或等于，所以我们得到了分支不太相同的想法，如果注册表1小于retwo，也不知道其中的内容，小于注册表二的内容。

我比大学还少，谈到了那个未签名的，上次我谈到BG B G E U，但没有一个分支大于，没有比你想象的更少的分支了，我不需要，如果我有一个分支比为什么少，我不需要一根更大的树枝，我可以试着拯救所有的东西。

我得处理，我们将要看到的所有指令的总数，每条指令都要花我一些钱，因为我需要说一些话，我在做什么指示，我得到的指示越多，我花的钱就越多，所以我想。

我在冒险，风险代表什么，减少风险的人的风险是多少？

我想要考虑的事情的最小数量，所以我不想要更多的指示，更多的指令意味着我要花更多的钱，因为每条指令都有自己的ID，所以我不想要更多的指示，所以我要在这里救两个，但我怎么做呢，为什么呢？

为什么我能以某种方式编写每个程序，我想在没有bgt和b l e的情况下写作，是啊，是啊，正好相反，只要翻转论点，我比我翻转红色更少，比这更伟大，在你的脑海里你就像，哦，我想做的比。

我没有比翻转这两个论点更伟大的了。

你得到了，好东西好的，所以C中有很多种循环，我们在时间上做得很好，我们真的很准时，我有两个选择题，所以希望我能在最后找到他们，而在其他语言中做野性四，就像打盹和抓挠，你一直重复直到你重复，你得到了永远。

所有这些事情最终都在最低的水平上，你所见过的一切。

从控制流，从字面上看，每个都映射到所有的东西，我刚才给你看的是线以上，在某些语义学中，您可以使任何东西，去找点乐子，语言，JavaScript，抓挠，看右边，Python，加载线路，如果你在冒险。

五件硬件，这就是你得到的，你要跳了，你得到的树枝比树枝少，比不上下面的东西，有点酷，你就像，哇塞，因为每一个都以某种方式被转化为这些东西。

我现在看到当你在VS五个硬件上运行时很酷，那是很酷的东西，每一个都可以重写为另外两个，所以这其实有点有趣，即使在风险五中有多种编写循环的方法，决策的关键是这个条件分支，你只是分支的想法。

当事情发生的时候，是不是小于等于，它等于什么，双等号右，所有这些事情，所以这就是你在这里所看到的关于决策的一切的关键。

我们有更大的麻烦，更大更长的问题，这是20的代码a，Sun is zero int i is zero i小于20i plus，加某个加等于i的a，顺便说一下，这是一种模式，P a t e r n。

谁能说出什么，这个模式的名字是，它就像一个软件，在前门，快进来，给我一个给我这个图案的名字，没人知道图案名，我在对一些，有人在干什么，但它是个动词，给我一个动词，有些人在这段代码中所做的，就像一种进步。

站在它上面十英里，低头看代码，它的尺寸很小，很小，告诉我核心是什么，这个算法的核心是什么，就在那儿左边，我在增加自己，或者我在添加，那我在做什么，我是谁说你给我一个给我，我看到一个，我们说过，高积累。

它在积聚，这是一种积累模式，一种很常见的模式，你等着瞧吧，但是记住这种模式，你等着瞧吧，这就像，哎呦，你知道的，一旦你写了很多代码，你就像，我做过无数次了，是啊，是啊，因为这是一种模式。

你会一遍又一遍地看到这个，写单词积累模式，好啦，现在谁准备好翻译这个了，你猜呢，这需要多少行来吧，只有喜欢是什么，那里有三行代码，没什么来吧，三条线都有风险，五右四，也许五个好吧，让我们看看。

让我们看看怎么样，我做的第一件事，做任何事不，你在努力，只是告诉系统，当您要移动到下一个数组时，我四点就走，这就说明了一切，实际上没有一对一的映射，我们要做的第一件事是记住零的a在哪里。

如果你一定要知道那是什么，八个存储指向数组的指针，让我们假设它，所以X9寄存器9将是我们的事情，那将是一个接一个的移动井，我们从来没有教过你怎么做，我记得加载词，它是一个基本指针和一个恒定的即时指针。

没有我，你不能在里面加"i"，所以我也向你们展示了如何做I，因为我以前没这么做过，现在我向你展示如何做一个i，那么基本指针是什么，我想是割伤了，它是在登记簿上的，八，我们暂存到九号吧，所以顺便说一句。

九个，九会是个临时的人，好啦，所以九现在指向数组的开始，我说从九点开始加载词，它会给我第一个元素，零的A，到目前为止，接下来你必须有一个总数，你得把我的累加器加起来，那将是X十，顺便说一句，看。

我把它弄黄了，所以你们这些正在研究颜色的人，你就像，嘿嘿，它符合，我很高兴，谢谢你，不客气，我需要，我需要一个I，我需要，我需要我的增量变量，好啦，我想知道，当那东西少了，什么时候，什么时候。

它是当它大于二十，所以它从零开始，它将继续上升，到20时停止，所以x11表示，顺便说一下，我真希望我能把灯关小，我希望VSB VSL的人，LLB可以帮我，他们告诉我灯坏了，这样好多了，只是为了。

屏幕上的对比度很好，所以我很抱歉，如果我必须注册，那就太好了，因为不分支我可以比较，记住分支小于右，分支和分支相等，我要做一些比较，我不到二十岁对吧，你得查查这家伙，我在分店不到二十岁。

是不是像分支寄存器常量标签，点个赞，或者你还记得两张幻灯片前的树枝，是树枝，站起来好吗，是分行注册常量标签吗，对那一根树枝竖起大拇指，因为你看，我在检查不到20个，所以我得到了这个，拇指呢？

没有人说什么，拇指朝下，那是什么，语义学的分支是什么，它的分支语法是什么，你在比较，你在比较一个寄存器和一个常量的否，你在比较什么，向另一个寄存器注册，所以这意味着这20个必须坐在收银机里，两个。

这就是我在这里做的，所以我把我的眼睛加载到11，我正在加载我的20个有颜色编码，很好地进入另一个有意义的登记册，所以现在我有20个人在等着我有我的眼睛在等着，我要比较下一个标签循环。

因为这就是我们要去的山顶，哦，我说完了吗，记住我们否定了我们的测试，我不到二十岁，这意味着当它比我少的时候，我就呆在那个循环中，我在循环中，我在循环中，我做得很好，开始吧，我什么时候退出循环。

当它大于或等于，有道理，相反，比我的意思少，当我做完，我在我的循环中，我得跳出来，猜猜我写了什么，就像你写了一些字，编写一些标签来帮助您完成此代码，顺便说一句，自动编译器将写Q17。

但它不知道它不知道什么是英语，但是当你手工创作的时候，风险五，当您执行编译时，编写它的手，然后把它放在一起，用标签是有意义的，有道理，好吧，我们开始吧，我做的第一件事，我得带一个，I。

我要把它放在x12，所以x12是暂时的值，我有很多脚印，顺便说一句，我们在这里讨论的是最小化寄存器，我已经有很多了，我正在用，想想吧，有时候你想再过一次然后说，也许我可以保存一个寄存器，我们以后再谈。

所以我喜欢这个，但是你看，没有，这是我的一个，这是我怎么说的，九的x怎么样，我和你告诉我这将是，我也许我应该把我放在这里，也许我把它，我把x9放在这里，或者一些数字一些，我在哪里，我在哪里谁是我的。

我是x11，我是不是应该把这个词，x 12 x 11 x 9，不应该，顺便说一下，是x 11 x 9，如果我听到自己，我不知道这门课，我想在下一个晚上十一点讲希腊语，好像很好笑。

如果你只是不知道它只是碰巧是一个来访的客人，欢迎欢迎来访的客人，我是希腊人，向美丽的人道歉，好啦，为什么为什么不看看这个不应该是X11在那里，这是一个我，我该怎么办，你能猜到我要做什么吗？谁知道呢。

这个数组有多宽，这个数组的每个元素有多宽，谁知道呢，从哪条线，系统中的顶线，编译器知道这是一个整数数组，因此相邻的整数距离，第四盏灯，所以我所做的就是锁定X9，零分，几分钟后，但我可能会怎么做。

那不是很酷吗，你就是这么做的，我做了一个小圆圈，做笔记，嘿妈妈，只要学会怎么做就行了，你做一个I是因为你会有一个临时的，所以我已经有了X8，我不想失去一个开始，不要覆盖x8，就是那个人。

那就是A所在的地方，我以后可能用得着，我不能移动主要的，我不会把指针弄丢的，引用未引用，但我有一个临时的叫X9，然后我就可以到处走动了，我想，事实上，我要移动四，四，四，下一个继续前进。

这是最简单的一加等于x12，右十等于十，加十二，容易，就在那里，有一个动作是，就在那里的移动，加i，九九一右一，只需移动到下一个数组元素，对不对，在我们的信用位系统中，整数有四个字节宽。

在64位系统中8字节宽，这是说i x 9 x 9 4，这就是我现在的状态，嘿嘿，x 9里有什么，现在是一个，我现在还有四个，我有两个漂亮的，真的很酷，我还有什么可做的，我得到了一个增量，有趣的是。

I独立于指针，就像这一行说的，看一个我在那里一个和我齐头并进的场景，你不能，你不能用那个去找下一个人，我和A在一起说话，否，这是两个不同的计数器，这不是很有趣吗？我上升了一个x，现在是x11。

x9上升了4，所以它只是平行向上移动，而不是以某种方式联系在一起，他们就这样往上走，什么时候，我什么时候在四点前停止下注，当我到20岁的时候，那不是很美吗？看那个吊杆，跳转到循环，那不是很酷吗。

我就是喜欢，这把美丽的东西联系在一起，然后在下面你就完成了，是呀，不不，否，标签，只是一个标签，只是一个标签，函数也得到标签，函数调用函数名冒号，但在这里它只是一个标签，我们只是用它来移动，是呀。

再问我一次，开始了，就在这里，不不不不读，它从左向右的分支，大于等于，x11大于或等于x13，眼睛的对立面，看看那里的颜色映射，如果x11大于等于30，这意味着我不到20岁不再是真的，恰恰相反。

就像当这是暴力的时候，我什么时候被侵犯了不到20次，我什么时候离开那个循环，当i大于或等于20时，当它大于等于，我受够了，正是这样，想想那个逻辑，与那很酷的相反。

好啦，我们还有整整20分钟，所有的一切，就是这张幻灯片，这是一个由两部分组成的讲座逻辑，我也有点击器，所以我们可以看到，我们穿过这条狭窄的小路。

到目前为止所看到的逻辑指令，哇塞，你在学习风险五，非常温柔，它是一个非常温柔的，每节课都比，还不错，这就是我们所看到的，我刚和这些家伙谈过，希望你们都认识。

感觉很舒服，好啦，逻辑指令，希望这将与您思考c逻辑指令联系起来，它们对操作钻头很有用，它们并行地对比特进行操作，同时，所有这些操作都会击中这三个二位，真的很酷，如果您从未玩过按位操作，请开始和他们玩。

因为你知道他们肯定在考试的范围内，他们真的很有趣，他们可以打开包装，把碎片打包成文字，你可以把它们到处移动，这些被称为逻辑运算，所以在C中，它们是单与号和单，或者哪个是竖条，单胡萝卜。

哪个是XOR 2小于哪个意味着向左移动合乎逻辑，和权利写到大于一些变化转移权利逻辑，它们有一一对应的五个逻辑运算，和五个风险，哎呦，如果你从未见过，让我们说底部和这些，这对你来说是新的。

这是同时发生在所有比特上的并行，那只是最低的一点，不只是一点。

它同时是三个二位，所以让我们在这里做这个，如果我也能不只是一起做两个寄存器就好了，但实际上要注册和一个常数，那真是太好了，所以我需要，我需要一个即时的，所以我们把一个即时的，所以我有一个，我会有一个。

我，你有一个，或者你有一个，奥里，你拍了X光片，你得到了一个XI，对着一个数字做是很好的，不仅仅是两个寄存器，如果你想，顺便说一句，你听说过掩蔽这个短语吗，你还没听说，我今天教你们。

一个面具意味着你有一些碎片，你只想要这些，其余的都应该是零，我想掩盖这件事，所以我用的是一种有趣的东西来掩盖它，如果你和它有一个，然后任何不是一个的东西，我想不是，让我们一起思考，在零和任何东西中。

它变成了零，零和任何东西，什么会变成零，对一个和任何东西来说，这变成了什么，所以一个人保存它，零压扁了它，所以看这个，我有些，你知道的，死了，B换一个，二，三，四，五，六，七八，最后一口都是。

那我在做什么，我保持最低的字节，把其他人清零，它不整洁，如果我想保持最高的字节f为6个零，而我就是那么美丽，所以掩蔽意味着。

留一点，其余的归零，这就是掩蔽的意思，这个不不在风险五，没有没有等待，但我需要能够反转位，把血倒过来，所有的平行线都倒在平行线上。

顺便说一下，那是最后一次手术，在一次行动中，32位受到影响，正如我想说的平行，这就是所谓的平行，在最低层，我有三个两个比特，你知道死牛肉什么的，我击中了这个，我立刻在一个指令中，相当于两纳秒，三纳秒。

也许一纳秒你在一台快速的机器上运行，一纳秒，32位并行受影响，这就是酷的地方，在教学的顶端，所有较低的八人都说他们都是什么，较高的二四人都归零了，立即在一个指令中并行，只要记住这不是。

这不是一个接一个地发生的，就像用循环不，只是平行的。

非常强大，好啦，没有没有，我必须能够翻转位翻转，翻过来，但你有XOR，他们就是这么聪明，现在我想让你看看这个EXO，你可能会看到一个XOR，XOR是什么意思，Xor的意思是x或x和y，英文版本是什么。

X或X，Y表示，或者为什么，但不是两者都有，你可能以前见过，这是什么意思，看什么时候什么X，这是一个，当你，但当他们都是，现在上来的不是那个，再过一个半月就是万圣节了，你听到了什么，那个人会敲什么。

当他们敲你的门，穿得像鬼或妖精，他们怎么说，全世界的孩子都怎么说，其实万圣节是一个世界性的节日，不给糖就捣蛋，它们是什么意思，虽然他们的意思是，如果你给他们一个款待，他们不会耍花招的，这就是他们的意思。

所以他们实际上是指其中一个或另一个，但如果你不好好招待他们，他们会做一个把戏，你明白这一点，那么他们到底在说什么，当一个孩子来到你的，你在说不给糖就捣蛋，你说，不好意思打扰一下。

它实际上是特技XOR治疗，对他们有点迂腐，那真是太好了，我说的对吗，我说的对吗，是异或，所以我想让你用一种新的方式来看待这张两张桌子，你以前从没见过这个，我要保持x0，Y与输出有何关系，看看这个表情。

看这里，看上面这两行，下一个零，Y与输出有何关系，所以如果我看XOR，我拿一条线，我把它标为鳍状肢线，当鱼鳍线变为零，会翻转吗不会，当我，当我说x对1时，Y与输出有何关系，正好相反。

我不可能把X变成条件逆变器，它就会倒转，当那个位说倒转时，那不是很酷吗，真的很感激这有多酷，所以让我们一起做吧，当x为1时，无论y是什么，输出都是y的对立面，下一个是零，不管Y是什么，都是Y。

如果我认为x是不对称的，x和y i标记x的一个输入，或者是我倒转还是不倒转，另一方面是我正在看的数据，当那是零，它不会反转，当它倒转的时候，它，那不是很酷吗。

一些好东西，所以这就是为什么我们用，我们就是这样向左移动的，逻辑上说，把这些东西拿过来，左，我要用什么填满它们，就像谁知道这个故事就像有很多是吗，猴子或孩子，都在床上，然后他们翻身一个从床上摔下来。

但谁持有谁填补了空缺，顺便说一下，就这样离开的人，它进入钻斗，左边偏移的那一点就消失了，它没有储存在任何地方，从里面进来的东西，默认为零，几乎总是零，所以左移逻辑幻灯片，左边的所有部分，但是。

你说的很多话，你说多少空格，用零填充它，所以我们开始是两个，和十六进制，二进制中有我的两个，看看如果我向左移动，逻辑由两点，又来了两个零，在顶部，不管是什么碎片都会从上面掉下来，有零。

但它们本可以被估价，他们应该是，他们就这样走开了，每个人都向左移动，用零填充，没那么难，这很容易，好啦，向右移动，逻辑正好相反，降档，在高端放一些零，所以向右移动，在左高移处放几个零，然后向左移动。

把它们放在低按钮上，到目前为止还好，我没看到任何问题。

数字怎么样，虽然，啊哈，如果是负面的，如果我移动一个点，变成了一个很大的数字，现在呢，这一切都很奇怪，所以向右移动，那是负面的，我应该再举一个例子，嗯是的，好吧好吧，所以向右移动，算术向右移动n位。

插入高阶标志，上位意义上的位，所以当你向右移动时，算术，而不是用零填充它，作为左轮班，逻辑，你用上面的东西填满它，然后继续涂抹，右移30，然后那个要涂抹三十个斑点，不管那是什么，这是一个，三十一。

所以是零到三十个零，所以如果寄存器x10包含负25，现在让我们把算术右移四个点，结果是负2，所以实际上这和除以2到n是不一样的，因为它对于奇数负数是失败的，这是它唯一失败的奇怪案例，所以对于正数。

它的工作原理就像它在做正确的事情一样，但顺便说一句，向左移动，我们应该回到，回到这个。

什么在向左移动，真的在做，还剩多少班次，立即真的在做，如果是个数字，我正在编码，如果是无符号号码，我正在编码，它是做什么的，乘以2等于移位量，所以如果我移动两个点，二乘二等于四，那是把那个数字乘以四。

二乘四八是多少？哦快看，产出8，不客气，所以左直接乘以2到移位，两个到动力换档。

会有一些回合和一些东西，但大多数情况下，它是这样工作的，好啦，如果它是完全看不见的，但它并不完全有效，你有奇数负数，所以只是一个小的微妙的例子，移动正确的算术几乎完成了。

这是我们以前看到的大局，我再说一遍，我做点击器，我有十分钟的时间，嘿嘿，我有，到目前为止，我们一直在讨论汇编程序，我拿到了汇编程序源文件，编译器生成这些文件，所以你所看到的风险五，这些是风险五。

汇编程序将这些人类可读的风险转换为五个注释，哪个，当与其他目标文件组合时，是个瓶颈，他们都来到一个地方，它们都被链接到一个可执行文件中，编译器产生我们一整天都在看的代码，我们正在寻找风险五代码。

那是编译器，要么是自动编译器，要么是手工编译，我们很快就会讨论另一个步骤，程序集为创建对象文件所做的操作，链接器放置所有目标文件以使其可执行，这是要做的三步过程，顺便说一句，这一切都瞒着你。

因为你只要输入GCC和奇迹，奇迹般地你得到了一个，但现在有三个阶段，编译器，汇编器和连接器，顺便说一句，错误信息是背面，关于Hey的错误消息，有两种食物，那是链接器，链接器在说。

那是唯一一个说Foo有完整程序的人，那个酒吧有食物，是链接器知道别人不会知道，除此之外，他们都是独立的，只有链接器才能把它们放在一起，是时候做，是时候一起做类似的房间了。

就是这样没关系，你知道内存是一个连续的二到三个字节数组，其中一些字节是数据，其中一些是程序，我之前说过这叫做存储程序模型，程序和数据位于相同的位置，那是个好主意，你知道我以前说过。

我一直喜欢把它链接起来，作为第一张幻灯片。

一份风险提示等于三份，两位，你以前看过这张照片这是我的处理器，这是我的回忆，我有一个特殊的指针，引用未引用，称为程序计数器，它是程序部分某个地方的指针，告诉我，我目前的指示是什么，当我想要下一个指令时。

程序计数器等于程序计数器加4，因为四字节是一条指令，它进入下一个指令，除非我得到一个分支，在这种情况下，这家伙移动到树枝所在的地方，除非我得到了一个跳跃，在这种情况下，程序计数器将成为跳转所在的位置。

所以这就是你如何跟踪，所有的分支和跳跃都是由程序计数器完成的，影响程序计数器的，不是别的。

我在下一条指令中加上四个字节之前说过，好啦，它是有用的，我只有五分钟，这很好，有一些实际的符号寄存器名称是很有用的，到目前为止，我们都在用这个丑陋的，x 0 x 1 x 3 1真的很丑。

让我们实际上有一些语义，也许在上面有一层间接的，所以我们实际上会有一个零到一个七，对于一个函数的所有参数，函数在星期五，不要错过星期五的讲座，这是一个非常有力的演讲，很多好幻灯片。

所以当我而不是用x和x和x不调用时，我将参数称为零，第一个论点，一个是第二个，那是标准，我们会有一个标准，一般的标准都是混乱的，你得有标准，所以标准是0到7，八项指示，你可能没有，是顺便说一句。

我可以用零这个词来表示x零，你见过零这个词吗，那是x零，我也有一些很酷的伪指令，这只是使编写风险五代码的过程更加愉快，例如，如果我想实际复制RS的值怎么办，把它塞进去，我讨厌这个标签，这不是移动。

它是复制移动的意思是我移动它，然后呢，它很早就离开了，对呀，如果我从伯克利搬到阿拉米达，我的东西离开伯克利去阿拉米达，这里不是这样的，在这个指令中发生了什么，从语义上讲，在那条指令中发生的事情。

我们在寄存器RS中的价值，它被加到零，已经被塞进去了，是不是变了，所以这个应该不会动，应该复制一下，所以我继续和他们说话，他们多年来一直说好，它一直在动不，它不动了，是拷贝好的，反正，不要让我开始。

取常数有时是有用的，把它塞进收银机里，在你的代码中很有用，顺便说一下，你会经常用这个，当您编写代码时，你只需要一个值，你想注册，所以说，而不是思考，哎呦，我得补充一句，我和X零不，刚刚叫加载立即。

现在呢，我不担心，事情是这样的，别搞混了，我们不是在谈论从内存存储到内存负载的负载，只是说装货和东西在寄存器里，负载就像放在寄存器里，我不是说凭记忆，所以不要有负担，一定是，我要去回忆，得到不不。

我只是说在收银机上拿一些持续的东西，没有操作说，什么都不要做，丽莎说周五之前，我希望你有一张纸条，没人明白这个笑话，我希望你周末有一个消息，什么都不要做，她希望你能放松不要动手术，什么都不要做。

所以没有操作是添加的，我记得零不能变，所以如果你把i从0加到x 0，输入x零，什么都不会改变，反正不能改变x零。

所以这意味着没有，好啦，所以，如果你没有看到行动或我现在你知道他们的意思，好啦。

让我们做一个选择题，五分钟，三分钟，好啦，我们试试看，我想把x等于y转化为风险5，我左边有八条指示，我该怎么做，有哪些步骤，也许我会放大什么的，如果你需要帮助，哦对了，如果你，如果我在这里做这个。

在这里放大给你看，我们去POV网络com，斜杠PDG或文本，敌机呼叫二二三三，然后说b c d e等，所以我想我试着用颜色编码，所以是一致的，我想用C来翻译，星x等于星y，我该怎么做，我给你做广告。

加载词，我尽量保持一些颜色，与价值一致，为了让它更容易，开始了，是呀，继续投票伙计们，我喜欢它，不要只投票，其他人会投什么，我们上次看到，实际上正确的答案是一个非常小的，像百分之十。

所以你可能是我们理解的人之一，其他人看起来很困惑，希望你不会感到困惑，让我们试试，我喜欢它，我喜欢它，看看这个漂亮的，好啦，继续走，继续投票，实时看电影很开心，那很有趣，所以我们大多认为，基本上。

我们大多数人都认为这是一个听起来不错的，是啊，是啊，是的，是的，我们大多数人认为，或者三个，一个或三个，玩一点，所以我有时间，我想我有时间，好啦，我要叫它，我要叫它血，如果我叫它，我叫它什么，什么事？

哦，那里，我会，我就叫它，它会一直移动，但我会在这里叫它，我们走，星星X我必须进入记忆，星x表示进入记忆对吧，去那个地方，点x是指针，进入指针，那个指针是内存，所以我得有负荷，所以所有的1和2都不对。

所以一定是借的，我得把它暂时放在某个地方，所以我要把它放进罐头里，我可以直接把它分成三个或五个，没有三五个指针，如果我只是加载它并把它放在一个指针，我在猛击指针，我得去装车了，把它放在临时登记簿上。

就像哦五，下一步就是把5，另一个地方我得到了两个指针，我把它装进去磨合然后跟着指针把它放进去，所以是5点到6点。

做最后一个，我会为你做的，开始了，十等于三三三四五开始，这是一个有点复杂的移位，逻辑上是10，十六进制是10，十六进制是它的一半，这意味着x12将包含，我们在十六进制中得到了三个四和四个零。

我移动了一半，三四四零，八点前我马上换班，那是什么意思？把它移到八点是一口，咬了一口，现在呢，我知道下一个十二是多少，现在仍然是，当我和这个和原来的，F与34重叠，其他都是零，其他地方都是零。

所以ff的意思是掩蔽它重叠了三个四个，所以是三十岁，四百块。

我们结束了，谢谢你十一点准时到，我们星期五见，乡亲们。

P13：Lecture 10： RISC-V Procedures - 这样好__ - BV1s7421T7XR

接下来会有一场精彩的演讲，我在星期三提到过这件事，但我会再提一次，我会再提一次，我真希望至少能在下周三的周一提及此事，驱动摩尔定律，这堂课是关于性能的，这是英特尔英特尔的一个很棒的扬声器。

是该领域的有力领导者之一，去讨论摩尔定律，与n kelleher和院长suj king lou的对话，这是计算，新闻新AI工具，看看这个，会写学生论文，要求教育者作为博客文章重新思考教学和评估的权利。

如果你有幻灯片，希望幻灯片会消失，我通常不打印这张幻灯片，但是在右边，你会看到上面写着学习风格，整个就像，你知道的，一页值得一页半的学习风格讨论，整个学生论文都是由一个变形金刚写的。

人工智能程序gpt 3，我给了它提示，学习风格的构建是有问题的，因为，这是用一个参考资料制作的，抄袭软件不会发现变形金刚写的论文，因为文本是生成的，而不是复制的，在谷歌上搜索这篇文章显示，每一句话。

注意它是对done的引用，如果它是正确的，做了一千九百九十七，有一本研究和教育杂志，但没有问题，七，两个在一九九七年，邓恩和邓恩确实发表了我们的学习风格，但不是在那本日记里，GPT 3有激情。

创造了一个看似合理但虚假的参考，它还发明了一项虚构的研究，从实干到批评学习风格，就像一个学生可以在几秒钟内生成一篇文章一样，所以老师可以评估，这里是对学生论文的简短评估，直到论文的结尾。

GPT写了一篇评论，本文讨论了学习风格的概念以及如何随着时间的推移而发展，除了做了又做的研究，这表明学习方式不是固定的，人们可以用不同的方式学习，视情况而定，我的妈呀。

这对社会科学中的论文驱动评估意味着什么，我的老天爷啊，也许丽莎和其他人，也许我会提出AI正在被，也被用来帮助软件开发人员，让我们在接下来的课上讨论这个问题，但想想这个神圣的莫利。

能够生成一篇文章意味着什么，通过键入提示符，通过输入的文章，这是你对这篇文章的简短评价，真的很迷人，这对评估的未来意味着什么，我不会说教育，但是评估，就看学生们是否做得很好而言，女士们先生们。

欢迎来到CS 6，二一C风险，五个程序，星期五快乐，每个人，感谢上帝，今天是星期五，好在这里，我们走到现在，你看到了什么，你知道怎么做跳跃和树枝，你现在可以做，如果你可以做无条件跳跃，你可以四处走动。

你可以很聪明，一切都很好，但你什么不能，你有，你不能写一个过程，你还不能写函数，今天我们来教它，所以如果我展示这段C代码主，它有四个临时变量，我j k和m，我要说乘法，只是一些愚蠢的乘法程序。

显然是J倍，或者我说我等于那个，然后我说m，我在下一行用i，M等于i和i的倍数这是一个愚蠢的小mod程序，对于整数来说，数数很容易，我想让你问问自己，你需要跟踪什么，如果我们一行一行地做，不太好。

它有一个支架，所以它知道怎么回去，这是一个for循环，它知道我们向你展示了如何展开一个for循环，能够在装配工中一行一行地做，我需要在汇编程序中做什么来构建，进行函数调用。

任何我觉得我需要以某种方式设置论点的人，J和K，我觉得我需要去下面的这个部分，这可能是换毛人的另一个功能，当穆里斯都做完了，我必须能够向调用者返回值，到目前为止，一切都好，我得记住，这里是最难的部分。

我必须清楚地记得我在哪里，当我叫它的时候，你怎么可能，你总是想问自己，就是今天，嗯，你会学到，它是如何跟踪知道，蜕皮之后叫做，现在呢，转到代码的另一部分运行Molt，它怎么知道怎么回去，就像你在一个。

我不知道你在迷宫里，你是怎么下隧道的，你怎么知道怎么回家，你不用留下面包屑吗，一定有办法记得怎么回去，所以我们今天就来谈谈，好啦，调用函数的六个步骤，我告诉过你，他们只是第一名。

把参数放在函数将要使用它们的地方，第二，从房间的另一边控制我的点击器工作，现在呢，我不知道为什么转移到控制所有的功能，现在函数有了控制权，所以你要搬家，你要从这里转移到代码的另一部分。

这就是伟大的第三点，嗯，也许那个函数需要一些局部空间，不管你知道什么，它会有一些临时变量，这是伟大的第四，做函数要做的事，五号，一定有一个返回值，也许不是，它可能是一个空函数，所以没有返回值。

但是如果有返回值，你得把它还给我，所以把返回值放在调用者的一个地方，在期待着它，五号返回控制台，你得把这些东西都记下来，我们将明确地看到如何在风险5中做到这一点，这是一种完全不同的思维方式。

当你理解花括号和函数调用的语义时，你认为，哦自动，只是，这就是抽象的美丽之处，点点头，我们抽象就像，我不需要知道它是怎么做的，它只是在这里调用子例程，他知道怎么回去，到目前为止，我们一直在受益。

你的一生，直到今天，没有人需要担心它是如何做到这一点的，让我们来看看它实际上是如何做到这一点的，这是关于六个的事情之一，两个，一个如此丰富和美妙的人，你知道事情是如何运作的，函数调用是如何工作的。

蟒蛇怎么知道回来，C节点是怎么出来的，为什么每个函数，任何语言Java，我们今天就做，好啦，所以会有一些会议，他就像你去拉斯维加斯的大会，你戴着一顶滑稽的帽子，无公约，达成一致的事情，我想那是个玩笑。

排名第一的寄存器速度超快，希望你知道金字塔的顶端，还记得金字塔的顶端吗，所以我们喜欢寄存器，我们实际上要给一些名字，在你知道他们是x10到x17之前，不再美丽不是吗，现在呢，你知道他们是寄存器，同名。

它只是映射一个零是x10，七是十七，但你再也不用考虑x1017了，我们会有一些保留的寄存器，这些寄存器实际上只应该被使用，其实我很难过告诉你这些，因为以前你有三台1号机，你可以用零总是零，你可以用三一。

我告诉你其实，我告诉你，你不能再用这些了，这些仅用于设置参数，好啦，最多传递八个参数，你得用0到7，你说该死的，会发生什么，我做了一个由九个参数组成的函数，答案总是在堆栈上，每个人都过了八点。

我们有一个堆栈和一个指针，不知何故会知道怎么做，你会有，你得亲自动手，但系统不会做任何事情，如果你正在编译一个9参数的函数，你要手动操作，所以有人记得如何用指向堆栈的指针来做到这一点，我们以后再谈。

别担心那个，就目前而言，你得知道怎么回去，我怎么知道怎么回去，会有一个地址记得蜕皮，第一次叫蜕皮，就像i等于多个j和k，一定有一个，把你的手指放在那行下面的代码上，因为那是你回来的地方，一旦你来到这里。

你得回头想想，所以说，R会记住什么，地址就在蜕皮的正下方，不蜕皮的呼唤，尘埃邪教在哪里，对第一次蜕皮的呼唤是记住，我们要告诉你，你可以用，还记得之前我告诉你，你有三个1寄存器，现在我感觉很糟糕。

你有三口井，不再是了，我输了八个，所以现在你得到了，一二三好的，实际上，这是关于你应该在哪里使用它们，寄存器会是，我们称保存寄存器，这意味着当你可能，我来告诉你该说什么，保存意味着当你打电话时，牧羊犬。

下面的家伙，子程序不能乱来，所以你可以把东西放在那里，叫它，他们不会乱来的，那是保存的协议，意思是我有一些东西在S，我得去找，我打了一个子程序电话，子程序可以做他们想做的事情，但当他们回来的时候。

所有那些暂时存放的S还在那里，他们被保存在电话对面，好好使用字母s，这里是很酷的部分，零和一是八比九，二到十一是十八岁到二十七岁，它们不相连，但你在乎吗，抽象，抽象，你在乎吗不，我就用零到十一。

12个临时名额，我不在乎他们实际上在两个不同的地方，零到十一，那个美丽的抽象，间接之美，从零到十一或十二，保存到目前为止我在工作时可以使用的寄存器，这么好，好啦，我们开始吧，现在，忘记蜕皮的召唤。

我们要做一个更简单的，从字面上看，子程序历史上最简单的子程序，你知道它的工作是把两个数字相加，它是如何在x和y的和中做到的，它返回x和y，世界上最简单的代码，现在呢，上面是对一些存储了a和b的调用。

a b的值存储在s 0和s 1中，那是局部空间，我们告诉当地的空间，当你和它一起工作的时候，S是如此的零，一个包含a和b，我要打个电话求和，现在呢，记得我告诉过你，这是你第一次真正受到打击。

每条指令都存储在内存中，存储的程序剪切，我们像第四个想法一样交谈，我说过这个程序和数据都在内存里，在那个大二到三二的数组里，所有的指令都是四个字节，我告诉过你我以前泄露过，所有的指令都是四个字节。

你见过的每一条指令都将适合一个词，四个字节，所以我们要把它们储存在这里，就像数据一样，你看到了我之前给你看的照片，当我画记忆时，零是底部，记得我画了，我记得我在这里拍了一张照片，把摄像机给我。

记住我这样画的是零，我说这是零，第一个字节，第二个字节，第三个字节，第四个字节，第五个字节，第六个第七个看到我做得很好，现在我要把它翻过来，因为我不想看说明书，一条指令两条指令，就像倒着读一样。

往下读很有意义，往下读是没有意义的，所以我们不会把这个翻过来，我们希望你能适应所有这些思考方式，所以现在记忆会下降，为什么看这个，读代码是没有意义的，就像一个行号，一千乘一千，四千，八，有道理一千二。

这其实是在基地，一万零一十六，好啦，这个十进制，所以只是为了让阅读，好吧，你想把代码读下来吗，谁想读代码，往上走，任何人，没人下来了，所以让我们读下来，好了准备好了，这是我的节目，哦，天哪，我吹了。

我让你大吃一惊，我让人大吃一惊，让我们试试在这里，我们去，我在两张幻灯片前就告诉过你了，A是你传递值的方式，但如果你告诉我s是s，第一个是我的A和B，我得把值a和b从s移到a，那是约定好的。

我们之前谈过惯例，所以记得我去，最后一堂课的最后一张幻灯片是一个伪指令动作，真应该叫什么一二三抄，好啦，真的是抄袭，所以说，我把值从s 0和1复制到0和1，现在我已经设置好了，我有一个变性人，哦。

我也有谁，这很重要，我一定要记住，我在的地方是那个曾经经历过奇怪事情的爆米花，霍普在隧道里，他掉了爆米花什么的，我觉得你把爆米花掉地上了，或者像香烟一样，或者什么东西掉了什么东西，因为他在隧道里迷路了。

你得记住你在哪里回来，我不能控制，我不能控制，啊，让我们去跳一些，我不知道怎么回去做下面的线，你知道的，这是一个求和的电话，看到这三个点，在上面一些之后，我得回到下面的地方，开始了，让我们在这里试试。

我们去看这个添加，我是零十六个，为什么是十六个，那是十一六，它是下面的线，在那里我离开去跳到一些，记得跳，我们谈到了跳跳跳，我知道这不是隐藏的游戏，谁知道呢，我忘了这个名字。

所以我只是穿上克里斯·克罗斯是纵横交错的，那种去查查，克里斯·克罗斯跳了起来，好啦，我要跳到一些，嘿嘿，大家跳跳，好啦，所以你现在得跳到一些，加一个零十六个，我给了你一个假指令，谁还记得伪指令。

这相当于我是零十六个，谁记得它立即加载，给我一个击掌负荷立即李，我本可以说李，我只想说把它装进去，把直接的权利加载到寄存器中，把它塞进去，所以让我们一起读吧，我设置了论点，我安排好了我要回来的地方。

也就是，为什么，因为这条线就在跳跃的正下方，然后我无条件的分支，我只是跳过它，你就去吧，那是什么意思，什么变化，我在上节课结束时告诉过你，程序计数器，那个跟踪我在哪里的人，会受到影响的。

所以有一个程序计数器，谁知道我在哪里，这意味着程序计数器将移动，当我说跳，意思是下一行应该是，和标签是，所以现在我们搬家了，那可能真的很遥远，我刚才在上主干道什么的，而我现在真的很遥远。

在这里做一些动作在一些，我希望第一名，律师有我的理由，我希望二号A已经准备好了，这样我就可以回去了，如果这些都不是真的，我现在有麻烦了，顺便说一句，您可以有一个没有参数的函数，所以你不必把任何设置为。

但在这种情况下，有两个论点，一个零和一个一，我们试试看，有些人在这里做什么是另一部分，我没跟你说过，然而，你知道返回值是0和1，为什么我需要两个，因为有时我返回一个不是三个二位的值，但是一个64位的值。

其中下一个是零，上面的通常在这里的一个，我只是回一个正常的4位，四个字节值一个字，所以我在1上加了一个零，把它归零，因为零是回报，我还没告诉你呢，但这是回报，得到了太多，还有人要再来吗？

然后我做的最后一件事是什么，很难看到，红对蓝，上面写着j r r a，那是什么意思，记住每一条指令都适合三个二位，所以这说明这个跳跃标签很不错，三十二位，我对经济学家的说法是什么，天下没有免费的午餐。

一定有一些为跳跃保留的部分来告诉它，这是一个跳跃，这个指令恰好是跳转，所以有些地方，因此这笔钱，那个标签不可能是二对三二，一定要比那小，所以我不能跳到任何地方，它必须是一个有限的地方跳到，但是看看JR。

如果是寄存器，它足足有三十二分宽，你说，不管那家伙在哪，那是个地址，那是一个完整的二到三二地址，去那里，所以我其实喜欢JR，比j好，在某种程度上，因为我用32位指针填满了一个寄存器。

它在整个阵列的孔里的任何地方对吧，整个阵列和现在JR可以去任何地方，所以这很酷，什么是J r效应，什么是JR效应，告诉我一件事，JR效应，程序计数器PC，它将下一行更改为，不管那家伙是什么。

这就是这个权利的意义，我在电脑上移动，告诉我我的手指在哪里，哪根线上有根手指，我在电脑上工作，是那个手指吗，JR，影响手指，下一行是，A在哪里，我们的A1016是多少，我的下一句台词是什么，我跑十一六。

雪橇上的问题，这是你第一次，我的天啊，这其实很酷，我明白了，我们在每一条线上移动，是一个词，那是指示，我得四处走动，而我，R a x和R rais，记住，然后PC J改变PC，JR改变了PC。

分支问题也是如此，你叫什么名字？利亚姆，走呀，走呀，我不知道六，我不知道这是一个关于这件事如何与那件事联系在一起的完整对话，我不知道有什么好问题，好的，好的，所以现在这里有一个，乐趣来了。

我喜欢这个问题，为什么J r，为什么我不能说，跳回某个标签，我从哪里回来，你做什么，你为什么这么复杂，你总是这么复杂，你和你的教授类型，你为什么要这样对我，为什么不能，我就在下面说j。

我可以在2004年说，J，来吧，来吧，我跳下去，你知道的，当PC分支更改PC分支更改时跳转更改，改变手指，你在哪里，为什么我必须JR，为什么不能，我只是给我一个名字，是呀，告诉我你的名字。

你的答案是什么？加油迪伦，走呀，走呀，因为比尔说因为你不能定制行为，为什么因为你必须从子例程回到，你得硬编码，这个子例程只返回一个地方，子程序不是这样的，任何人都应该打电话，只回到一个地方没有任何意义。

就像同一段代码，我想能从Foo和酒吧打电话，你在告诉我，我不能从任何人那里打电话，不，对不起，因为你明确地跳了回来，那没道理，你应该回到打电话给你的人身边，我怎么知道他们打电话到哪里。

我怎么知道去哪里回去，我怎么知道去哪里，我刚刚告诉过你，你回到全国步枪协会，这个子程序说j r r ra，这样你才知道该去哪里，我想你的大脑在一个更大的空间扩张，这是一个像哇哦，令人兴奋的事情。

因为这里很安静，我有一种喜欢的感觉，这很难，有新的东西，这有道理吗，为什么不是J，让我们确保每个人都在同一页上，如果是J，我就回到原来的地方，总是，这意味着这个和总是回到那个特定的线。

但我希望有人能被20个不同的地方打电话，由Foo，按律师资格，作者：巴兹，作者：加利，所以很明显，JR到R A和A是家伙是持有者，A是什么寄存器，记得我回到哪里的三个两个寄存器之一，因为公约权利，哦不。

你知道回信地址，我把它放在十四井里了，例如，没有十四，但这没有任何意义，你想让它永远在同一个地方，所以所有的子程序都在这里说j r r一个问题，告诉我，马修，你先走，我喜欢这个，把爱给我，如果马修问起。

当一个函数调用另一个函数时会发生什么，所以中间的人就像缅因州一样叫我中间的人，我要打电话给一个孩子，所以RA准备回缅因州，如果我要给孩子打电话，不是吗？我要覆盖数组，你当然是，你得保存它。

我们稍后再讨论这个伟大的问题，马修已经三四岁了，也许提前十五分钟，漂亮干得好马修，好了现在，你之前看到的是一种丑陋的东西，我们立即看到了这批货，我是十一六，然后我们看到一些，你知道那种事。

你知道我喜欢什么吗，这就是我喜欢的地方，我不得不硬编码，十六个在我的代码，我不知道我在哪里，我就想等等，我知道我在哪里，我在10点12分什么的，也许十到八点，我得到了一个硬代码，我不喜欢那样。

一千零八年，我不得不硬编码，十六个进入我的风险五代码，所以这意味着我不能写一般风险五，我有风险五，知道它要去哪里，最终降落在存储空间，记住程序生活在它生活的任何地方，你不知道程序将住在哪里。

我应该能把你的程序上下滑动，理论上，有些代码你可以，有些代码你不能，所以说，我首先要说的是，我只是不喜欢你把我锁在里面，这只有在，从字面上看，它写在一千零八年的行上，一定有更好的办法，他们说你是对的。

应该是更好的办法，进入日本航空公司，Ja l代表跳跃并连接这两条线，你看它先变得多漂亮，我保存了一行我喜欢的代码，和b，突然间我不用硬编码了，不再是我的十岁十六岁了，那不是很酷吗，我们在那里很开心。

我觉得那很酷，所以现在顺便说一句，使普通案件快速，我希望在我的生活中做很多函数调用，动作要快，将程序大小减少一行，我也不必知道代码在内存中的位置，现在就爱它，跳转和链接到底发生了什么，是它先跳的吗。

然后设置RA，这是命令吗，这是另一件事，真的不是另一件事吗，吊杆好，让我回到这个跳跃，链接真的应该是链接和跳跃，但是乔尔开头有个j，所以，你认为j跳j r j geo，像这样j，你想在第一个字母里。

即使真正发生的是，它是一个先连接的岩架，然后跳转链接意味着设置返回的家伙，把你的回信地址定在十点十六分，这里是十点十二分，因为你失去了底线，然后做跳跃，在处理缓慢的情况下，跳跃是它做的最后一件事。

如果你看慢动作，慢动作，它是第一个，十六个数组然后跳跃，就是这个意思，所以这是一个慢动作，链接先行，然后跳，我们叫它跳进去，就像J是第一个字母，那是什么，调用跳转函数标签是什么。

所以现在我记得你以前听说过标签，我在做一个类似的分支到另一个分支的循环，记住，在此之前，你会有函数的标签，函数调用的完全相同的标签，你把那些标签粘在一起，你在做一个叫做凝胶标签的函数，Gal函数调用。

那不是很美吗？这是一个功能苹果，你想给马洛克打个电话，我是乔尔马利克，将参数设置为malloc，加尔·马洛克完成，人们总是忘记马洛伊斯，函数调用，周马洛克，这就是你想要的记忆，约翰·马洛克。

你最好把你的零设好，右马洛克，什么是，零里有什么，当马洛克回来的时候，的未初始化数组，不管你有多少钱，或或，无或零，好啦，当你从木槌得到返回值时，得检查一下，好啦，好啦，所以说，还有一件很酷的事。

我给你一个免费的伪指令，在每个子程序的底部，不只是说“好”会很酷，但说回来不是很酷吗，只要返回，它的语义上意味着j r a so，您可以在每个函数调用的底部写r e t，那不是很酷吗。

我们还没有在每张幻灯片上都这样做，但一般来说，您可以作为伪指令为自己编写，函数在u和和中的函数，你们都是零分，设置返回值，就说把这回报还给我，不知何故，它神奇地消失了，现在我们可以再次思考魔法了，对呀。

神奇地，它知道怎么回去，即使你知道它到底在做什么，去一个场景，个人电脑是什么，现在把控制权还给，你说现在就回去，又是魔法，回去吧，我活在魔法世界里，活在魔法世界里，真漂亮，好的，好的，有两个说明。

我刚说了你有个收银台，有标签，JR很有趣，JR所做的是它需要RS添加记住加载单词加载单词说基本指针，然后你加上即时，做那个乔尔，顺便说一句，还有一个想法，你可以覆盖寄存器，不，不，你不只是换一台电脑。

但你实际上也把你要买的东西储存在收银机里，所以这里说的是RS立即，把它放在RD中，它所做的一切，如果你想去那里，但也要记得你刚刚去了哪里，基本指针立即在RS中，与之有多大的偏移量，你把它们加在一起。

你得到了一个新的指针，把它塞进去，你也有同样的想法，顺便说一句，这有点酷，和j，R和return都是伪指令，你知道杰说什么，X零标签，我可以叫你下巴标签，嗯，真的是，它实际上是用寄存器存储的GEO。

个人电脑要去哪里，如果你想记住，加尔也这么做，所以这里x 0被存储在，不管标签是什么，但是x 0是不能改变的，所以谁在乎呢，所以j就像凝胶标签，x 0是不能改变的，所以j是一个伪instru。

在函数调用后，旧的寄存器值保存在哪里以恢复它们，你什么意思，我基本上想说的是，是看，你一秒钟前告诉我丹这些东西是通过电话保存的，如果我桌子上有临时的东西，丽莎，这是我的桌子，我桌上有些东西。

这是我的钥匙，我要出去度周末，当我回来的时候你可以用我的课桌，4。我希望把我的东西放在我的桌子上吗，我离开他们的方式，如果他们的比他们是S意味着得救，所以至少这些都在保存中，你不能乱来，好啦。

所以保存意味着，她必须是我的钥匙，因为我的钥匙不知道怎么用打开我的门，保存意味着我打电话，那家伙不是，但如果是这样，你不会惹S的，子程序和或蜕皮不会影响s，但你叫我等等，我在蜕皮，一秒钟前你突然告诉我。

我有12个临时空间，但如果我换毛或子程序，我必须有一些工作空间，那么我该怎么办，如果我至少是一个需要使用一些工作空间的子程序，我们怎么处理这些最好不要碰的东西，在我看来，这有什么关系。

将它们保存到堆栈中，丽莎会拿走我的东西，如果她需要，移动到堆栈，那就用它，然后是什么把它放回去，所以在我看来，它从来没有移动过，这不是一种很好的类比吗，我把它放在右边了，我就在那里，我所有的S都在那里。

丽莎用了所有的12个，S的，你拿到了，好啦，所以你知道，记住61年的一叠，B主意，就像一堆盘子，这是一个救生艇结构，后进先出，像一堆盘子，你们都知道那个类比P，您可以访问另一个寄存器，三个中的一个。

他们不应该用，因为它绝对是，指针，像手指一样跟踪哪里，堆栈在哪里，当它移动时，记住显示动画堆栈增长，生长生长，然后收缩，心理医生，心理医生，当一个返回返回返回，那是堆栈点，它会跟踪那个。

堆栈的约定从高地址向下增长到低地址，当我说，推，当我说，把东西推到堆栈里，它使堆栈递减，在上面腾出空间，当我弹出它，它增加了工作人员来移除这些东西，利萨，把那东西拿掉，还记得她清除记忆，没有C是快的。

我们永远不会离开，那里有垃圾，不管是什么垃圾，它呆在那里，堆栈在这里，我们去，这是堆栈的顶部，当你向下移动p，你在做这些镜框，每次函数调用，如果函数说我需要三个字，好啦，流血流血。

这里有三个词叫做堆栈框架，你可能以前听过这句话，Java中的堆栈框架，事实就是这样，它向下移动的堆栈，说你需要什么临时的东西，蓝色布洛，在那个函数调用中，不管那个函数调用需要什么，就是那个堆栈框架。

当那个函数释放的时候，它释放了那三个字，它需要他们释放他们，它是怎么做到的，它将堆栈指针向下移动，把它往下移三个字，往后退三个字，就这些，它做得很优雅，好啦，堆栈是连续的，不会乱动，程序结束。

堆栈框架收起来，堆栈冻结内存，但并不会抹去记忆，那些东西实际上还在记忆中乱搞，如果你想捣乱，让我们做吧，让我们看一个例子，让我们做吧，叶婴小程序，四个论点，G h i和J，现在还不到八点。

所以我们可以用0到3，它是做什么的，临时变量，F哦，这里有一个复杂的问题，它把前两个数字相加，从最后一个中减去，从前两个数减去后两个数，好啦，不太复杂，这就是叶子要做的，让我们看看这个代码。

一个接一个在一个非常好的例子上，我说过在所有的争论之前，G，H，I，J等于零，一二三，记住A是我的输入，我的返回值是多少，我的返回值在哪里，去谁记得一个零，也总是一个零，如果我需要返回两个字怎么办。

我该怎么写？1，0，1，大多是，我只是回一句话，他们两个回一句话，但有时我会回报双倍，顺便说一句，替身是两个词，所以一个零和一个一，是啊，是啊，好吧，我们走吧，顺便说一句，让我们假设要进行这个计算。

我至少得用一个工作区，这就是你所说的S，它可以是任何一个，总是从零开始，只使用s one，所以我现在已经用s了，你会知道的，如果我要用S的一个，这个子例程叶子要做什么，记住，S是保存的寄存器。

这意味着丽莎要用我桌子的一部分，只有一个，LISA或者子例程叶子要做什么，它必须做上帝所做的，告诉我，告诉我，罗斯快走快走，罗斯，保存一个，你有丽莎或叶子，得拿一个，在这里继续走，保存一个。

拯救一个人意味着什么，它得把它推到堆栈里，它得为堆栈腾出空间，它得把它复制过来，可能会说移动，但要复制它，实际上它是用来储存的，因为你现在正在回忆，在记忆中移动，然后我可以用它，当我用完它。

我做对了什么，是呀，我把它复原了，我把它还原了，我把它弹下来，准确地说，弹出实际上是指针的移动，恢复是负载对斯托尔的影响，好啦好啦，让我们做吧，这是代码，我只是把它做得又小又大，你知道叶子拖船，H，i。

j，f等于，G加h i加j，你在左边，如你所见，C在滑梯之前是不存在的，我今天想加一条微博，好啦，一线，哎呦，我们可能需要两个位置，顺便说一句，当你写这个的时候，我知道我要用两个位置，但如果你不知道。

你在那里放个数字，然后当你在代码中工作时，你让数字变大，所以当你手写的时候，你可以把数字做得更大，我说我要这么做，这是你第一次看到我真的在控制，我在请求记忆，你怎么问，记住，做这件事花了多快，一行。

运行千兆赫机器的一纳秒，瞬间一纳秒，我有记忆，我要问你一件事，我有没有检查过我是否有堆栈室，如果我正在运行一个非常完整的程序呢，我没有空间留在记忆中，那条线要做什么，将堆栈指针向下移动到，就像我的堆。

也许记得堆长大了，我的堆积如山，有没有支票，哦，把台阶搬下来，如果有房间没有，我真的这么做了，现在系统知道，这里是堆的顶部，这是这堆东西的底部，堆栈现在重叠，你说呢，谁以前见过这个错误？堆栈溢出错误。

它发生在哪里，那堆没有两个字可以增长，就像触摸一样，它碰到了堆的顶部，堆生长，你做了很多恶作剧，你们都是mc mc mc，我不需要释放任何东西，麦克麦克，泄漏泄漏泄漏泄漏泄漏Malmc MC。

这是顶级的，这个东西的顶部坐在这个的顶部，没有，没有两个字，比那还少，然后你把这条线，系统会说嘿，你不能把这堆东西拿去加热，您将调制堆栈溢出错误，你终于知道它是从哪里来的了，很酷吗，谁很兴奋，我接下来。

所以我腾出了一些空间，我腾出了些地方，我要做的第一件事就是，因为我要用，我告诉过你我会用S的，所以首先要做的是救一口井，我的基本指针是什么，我的基本指针是圆括号里的家伙，我的基本指针是什么，堆栈指针。

堆栈指向堆栈的顶部，对不起，堆栈顶部的堆栈向下生长，所以这是堆栈的底部，现在四喜意味着四喜，所以我可以访问零，其中的四个论点，直接的是零，四个是最上面的是零，是下面那个，我给两个人腾出了地方。

所以我说最好的一个，我也会用0，让我们用其中的两个，现在我在做一个子程序，这个问题是什么，我在这里做一个子程序，在这里，我正在做一个子程序调用从叶子是叶子，打电话给别人，不，所以我需要记住，保存。

因为我要用，我正在做的工作，如果我是，我该怎么办，把这个八到十二，还留一个，仅此而已，我会做很简单的，有道理吗，我不是，叶子不是在做叶子，就像一个终端，就像树叶一样，又不是说，不是比我低。

所以叶子没有叫它，我不记得了，我得，我不必记得，Rra，现在看，我已经存储为零，现在我可以使用s零和s一，现在我可以用这些临时的家伙，鲍比·布莱，但蓝色为零，让我们覆盖为零，没关系，那是我不在乎的。

做任何我想做的事，但在我离开之前，我要做的是，但在我离开之前，我将恢复为0和1，所以那个叫利萨的人，我在这里，在这种情况下，丽莎的叶子，我不知道这样零一就会恢复到，好啦，所以让我们做吧，这一切都很容易。

你知道的，设置F设置S一个，我加j他们都在那里，现在呢，3。在寻找答案之前，我把它放在哪儿了，答案在哪里，去一个零，所以你看，减去一个零s零一右，左边的零是左边的两个数字，加g是正确的两个数，我想这是。

我和j减去它们然后把它们填入0，这也意味着你现在正在考虑，等待A在呼叫上没有保留，如果我，如果我认为我是叶的顶级来电者，我有我的临时价值在一个，那是我唯一拥有它的地方，然后我叫叶子，零会发生什么。

呼叫后一个零会发生什么，叶子，男孩静音室，我是打电话的人，我是缅因州人，我要请假了，如果我有一个非常有价值的号码的唯一副本，我花了十个小时，十年计算，坐着一个零，我想请你把它加到其他一些数字上，叫叶子。

只是一个零，叶叫，你设置了一个零，那么我唯一复制的值为零，我叫叶子，叶子能做什么，告诉我看，替换它，这就是答案，首先，这太疯狂了，我会有，我会安排它与，我唯一的副本在我知道目标是覆盖的地方，要读回值。

那没有任何意义，所以也许我想得很好，我把它留到，八分或者七分可以吗，给一个七写信，我问你是一个保存的寄存器，A保存的任何寄存器否，你不知道那是什么，子程序在做什么，你可以称之为其他子程序的人。

我们没有达成协议，我们没有约定，优等生得救了，只有s被保存，所以如果我的键值是6，它不见了，可能不能相信，也许它还在那里，但可能已经走了，那我该怎么办，我恢复为零，我恢复看看看看这个。

所以你有书签和书签，都是对称的书签，商店这上面写着商店是一到四个，商店的零到四，负载S 4 P回到S 1负载，零P回到零风暴，把它们装进书架，它们看起来一模一样事实上人们通常会这样写。

这就像字面上完全相反的问题，我再说一次，亚当走，你不会想把这个想法搞砸的，说国家登记是跨一个叫它，一个同事，你不能碰它，它是可信的，为什么我不喜欢它，我为什么不用我喜欢的不同的寄存器呢，什么什么会。

我用的是什么，我可以用A吗，做什么，是呀，我喜欢它，我喜欢它，我喜欢它，你说过，为什么我必须用s来表示不是，就像临时的空间，我可以用，可能是优等生之类的，是呀，有临时登记册，我用一种复杂的方式来告诉你。

当你是新手时会发生什么，但实际上有临时登记册，T's，我应该用那个，所以我不，我其实没有什么发言权，我只是想告诉你什么是保存过程，所以说，你知道怎么做，但总的来说，如果我在写这个，根本没有本质。

我要用t和喜欢，就像不被信任一样，我可以随便借，S是特别的，我想展示什么是s，所以说，我们可以谈谈，是的问题，告诉我乔纳森，走呀，走呀，是呀，好啦，让我们做吧，什么是，我是谁？I cp。

你是CPU商店商店，从哪个存储区加载，所以我是CPU，我正在推动内存存储加载从好的好的问题，很好的提醒，是啊，是啊，下次再来，马修，是呀，我怎么事先知道，我有点，我有点说，好吧，你看，我在看这个代码。

C代码像左边一样，你知道左边的计算，正确的计算，你得把它们减去，所以提前，我就像你知道的，我把左边的0，正确的一个和S一个，这样写，我们不知道，我们可以假设他们已经很忙，我们不知道我们记得协议是。

本质上，但我得写我的代码，假设某人在论文中有一些数据，我得记住，我经常这么做，在我走之前让我展示最后一行，我恢复添加，我和最后一件事是什么，我做了所有的手术，三个字母，R e t返回，这是JR。

同样的事情，是呀，向我提问，嗯走吧，不不不，我可以装载和储存任何东西，问题是你必须只加载和存储S是，您可以加载和存储任何寄存器，拿任何登记簿，把它放到内存里再读回来，投入任何东西，但在这里。

我肯定会在计算中使用s零，所以我必须能够说出来，并恢复它，s的函数与a的函数没有什么不同，他们一模一样，他们只是一个这样的C像在拉斯维加斯，一个约定，A被覆盖并说，不要说得救了，也是暂时的，美丽，爱它。

所以我们开始了，这里有一张照片，我几乎有一些非常非常漂亮的照片，看嘣嘣，你看这个标普就在这里，无论它在哪里，我把它移下来了，我的台词是什么，让我们在，减去8，这就是它的作用。

在我的堆栈上腾出空间作为第一行，记住，这是我们讲的第一句话，这是一个没有得到，在堆栈溢出中检查，然后我保存它，当我完成后，会发生什么，把它摘下来，我把SP后移，我把它们弹掉，猜猜它还坐在那里。

同样的值仍然坐在那里，无论他们在哪里，他们坐在那里等别人做什么，这是下一个程序，顺便说一下，只是为了好玩，向下移动p，然后说嘿，那值多少钱？突然之间，你不可能偷看里面看看记忆是什么，是呀，潜在安全漏洞。

如果有两个程序在同一个内存空间上运行，他们有保护，但在过去，他们不能运行两个程序，我想做一个巨大的堆栈变化，读取所有这些值，我真的在读你在那个空间里写的东西，它不快，如果你有，我在做一个密码程序。

如果我能和你在同一个内存空间里运行，你在开玩笑吧，我读了一大堆这些东西，如果我可以，也许有一些看，我能读懂S的旧值，如果有其他程序，我们有，我们现在有保护内存保护，多亏了虚拟内存，所以我们没有。

但在过去，我们有两个程序生活在同一个空间，事实上，现在我们有两个线程生活在同一个空间，所以如果一根线是邪恶的，三分之一是好线，邪恶的线索可能是从另一个人那里读取空间，相同的内存足够，我是说。

如果你在运行代码，所以你不会在那里写一本好的电子书，但你可以在这里看到迷人的东西，我们进行嵌套呼叫，现在呢，你就像，好啦，我又回到马修的问题上来了，我想对了，你说过，当我调用嵌套的东西时会发生什么。

那里发生了什么，让我们猜猜，所以这是我的优等生，这里是我的意思是我得到了一些值，我把它们记为0到7，然后我用凝胶控制，好的，我现在做函数调用，我在函数调用中，其中有些是A的权利，假设我留着A。

但我要做另一个函数调用来计算其中的一些，希望他们留在那里，这样我就可以在以后的计算中重用a，我能相信他们吗，我能相信他们会保持A吗，因为我需要他们，因为他们嘿亚亚亚亚，双子程序，潜艇潜艇，别碰A。

因为我仍然要用它们来计算别人给我的，我能相信他们吗，无氮气回火，我该怎么办，那就把我将来还需要的艾滋病存起来，到堆栈的哪里，做我的凝胶，回来，恢复a，然后返回我的值，做我的事情，你说的有道理。

同样的想法，就像一个临时的，或者如果我有我的价值观和t，假设我这里有很多牙齿，我们喝了很多茶，我在用凝胶之前先用茶，如果我需要凝胶后的茶，我该怎么办，也保存TS，如果我的电话中有任何临时存储的东西。

唯一保存下来的是，所以想想它的挑逗，你在工作之前，你得在行动前救他们，因为他们会，那是暂时的，但关键是你不必，但你之前要做什么，如果你要用S和Sub盐水，你得在使用它们之前保存它们。

所以这就像你在保存它，不管怎样，你都在触摸记忆对吧，你觉得很好很好，一个比另一个好，实际上要做很多计算，我可以把它们放在茶里，然后在打电话前保存它们，恢复并使用它们，或者，假设我们用的是。

我得在电话前说s，就是在我之前有办公室的人，然后用是，那就打电话，不用担心他们会被覆盖，所以不管怎样，我都在移动记忆，我是说把记忆中的TS或S，但在不同的时间，这就是这一切的全部意义，所以如果有些。

顺便说一句，我不需要显示这个确切的代码，因为它真的很大，如果和要叫蜕皮，所以主叫和平方，一些广场现在要去，这是一个x和一个y，它将被称为麦芽和Y，所以x是一个零，Y是一个1，我们已经考虑过了。

我们已经知道了，我在麦芽酒里，所以我在某个广场上，我要打电话给莫特，找帮手，我还没用过你，因为y将被用来，不管MOT做什么，它都会去，我要去凝胶蜕皮，如果值为零，我能相信molt有两个参数吗。

所以我真的得给一个1和一个0，嗯，X已经在零右，那不一定要动，但这个Y是在一个，但当我叫蜕皮，我必须覆盖y来设置模式，所以这两个参数是x和x，我得去救你，对呀，这是允许的总数，我得去救你，如果我是。

如果我是个老古板，我如何保存Y，两种不同的方式，让我们过一遍，让我们把Y和S，那我一起做什么，保存推s，把Y放在S里，叫下巴，用它来放，设置一个零，我的返回值，然后恢复S，那是网络世界对吧。

我可以做什么，我可以给员工一个，现在一个现在被记住了，我凝胶和我恢复一个，我一切都很好，所以我可以用S，在那里我必须提前借空间，或者我可以把我需要的推回去，在我做返回值之前，这就是你在演示中看到的。

好吧，我想我在这里说过，啊，我也要做，如果我要打电话给它储存一个太像马修，说我不能就这样打电话给另一个人，因为商店，在缅因州的哪里，我回来，我需要记住，就在这里，在某个广场上，我回来了。

所以我买了一架喷气式飞机，我所说的，乔尔要推翻，一个权利，Jol是Overria，我得保存数组，所以我知道该去哪里，它必须恢复我们的射线，然后J r a现在我知道该去哪里了，所以有一些惯例，哎呦。

点击器问题的三分钟到中场休息，有人打电话来，一只牧羊犬，打电话的人是像缅因州一样打电话的人，牧羊犬是一个子程序，当调用从执行中返回时，调用者需要知道哪些寄存器可能已更改，哪些是保证不受检查的。

我告诉了你这个故事的一半，但官方的说法是，大会说，关于哪些的规则正在改变，在凝胶上没有变化，在这里，我们来减少昂贵的负载和商店，我们不想去回忆，记忆，回忆就像去萨克拉门托，我们不想去回忆，我们可以帮它。

所以它把它们分为两类，保留了所有保存的寄存器以及堆栈指针，这就是为什么当你把它弄得更低的时候，你得把它放回去，它保存在你的电话中，你不能把它放的更低，然后不放回去，你把事情全弄糟了，GP代表全局指针。

TP代表线程指针，你可以读到他们，你不用担心他们，因为这里，为了这次演讲，未保存，你所说的，因为他们可能会这么做，和临时人员，所以得救了，这就像一个R，一个A，一个T，就像一只老鼠。

所有的老鼠都被压扁了，它重击，R A T很好，对吧，所以我做了一个，有一个T在这里，但我们不经常用这个，所以好吧，所以老鼠被压扁，你不能相信他，很容易就能得救，就是它，这就是大局。

这就像第二张最后的幻灯片，我们不再用我的号码了，停止使用数字，我就像嘿，我们不要再用X5了，X5没有更多，你用这些字母和单词，从语义上使这工作，好的是你看，优等生在这里，这里是0 1 2到7。

字母s是分开的，这里是零，这里有一个，这里有两个，我不在乎零三一一，我认为它们在语义上是在一起的，那个美丽的临时在TE点击器，让我们点击一下，我只有一分钟，给我一个遥控器，第一名。

Risk Five使用jol调用jr中的一个函数来返回，顺便说一下，它是ecom、斜杠、ddg或text，ddg二二三三三，然后在这里加入，我们走。

Risk Five使用jol调用一个函数j来返回me joo，节省PC加一个和一个三，调用E可以使用临时寄存器，T注册而不保存和还原它们，呼叫者可以依靠保存寄存器而不必担心牧羊犬，改变它们。

就像我说的那样，但让我们看看你是否能解析我说的话，这里，我们去找，我们正在点击，你在这里投票，我们是，好啦，开始了，让我们去投票吧，我喜欢看这些数字，我们都活着，这句话曾经说过，顺便投票的人数，他们说。

右下角，以前那里有个号码，很奇怪，是一种方法，也许给我看看，因为我不知道，我做得不一样，哇等等，B在这里真的很挤，十一点，为什么是b pc加4，我们靠文字感动，不是靠数字，是按地址来的，但我靠言语行动。

所以是B好吧，我用手点击下一步，就这样了，你就是这么看的，你看到的一切，你所做的，你在开玩笑吧，让我们好好想想，太酷了，你现在可以做任何事，星期一就到这里，至少会谈论，其实呢。

我们用的比特是用来做什么的，每次行动，周末愉快。

P14：Lecture 11： RISC-V Instruction Formats I - 这样好__ - BV1s7421T7XR

这个周末说好坏。

好啦，准备数到三一二三，好啦，我听到一些不好的，呃，我想聊天也能听到我，怎么样，聊得怎么样，周末，可怕，好啦，所以在周一乐观的部分，至少这个月或上个周末确实下雨了，雨下得也不大，因为事实证明。

我是说我们加州正处于极度干旱之中，如果雨下得太大，它实际上长得太像绿色的东西了对于即将到来的夏天来说，所以如果明年夏天超级热，然后所有的东西都会干涸，然后会有更严重的火灾，一种东西的组合现在很好。

我知道你们这周都很忙，尤其是在61年，我们有第二个项目，嗯，那出局了，其实这个项目对一个来说是相当小的，这就是即将到来的，星期三，在…的意义上，我认为风险五的一个特点是它看起来真的很可怕。

因为这是一种全新的思维方式，但是一旦你习惯了参考卡，你适应了，其实喜欢查东西，然后只是想一些事情，程序上，其实也没那么糟，从某种意义上说，有些人对有些人来说，它实际上比c容易，这是伟大的。

我想做的另一个班级通知，我们将开始亲自分配中期计划，所以你要做的那种小实验，但在我们真正向你们所有人释放所有这些物流之前，你得让我们喜欢，通过填写中期可用性表来帮助我们处理物流问题。

所以如果你还没有填写，你们中75%的人，这是伟大的，但剩下的两个5%是这样的，请务必填写，我们将开始把学生分配到期中考试教室，嗯明天晚些时候，我想是的，请务必填写，我想那里有我们。

美国点茎组织并在上面发帖，我们可以从那里开始，你有问题吗，我以为你会举手，不，好吧。

很酷，但是的，呃，让我们从新闻中的计算开始，我受到丹的启发我想做一些有话题性的事情，这是几个月前发布的一篇文章，六月二十二日，麻省理工学院计算机科学和人工智能实验室的研究人员在封面和引用。

苹果上无法弥补的缺陷，M一个芯片，所以它使用了一种不同类型的计算机架构师，它使用不同的ISA集，不是我们知道的风险5或x8 6，但这里的剥削是什么，这是一种叫做指针认证码的东西，实际上利用这一点。

那么什么点或认证码是，这有点超出了本课的范围，但我们的想法是检查看看，是否访问无效内存，或者像不属于你的记忆，硬件做了几次双重检查，所以这种攻击实际上结合了内存损坏，你们现在都看到了，通过做项目。

其中一个将内存损坏与硬件中的投机执行结合在一起，尝试获得更快运行的指令，按种预科，执行一些指令，事实证明，这可以被利用，你不能真的修补它，因为它在硬件中，非常吓人，非常刺激，是啊，是啊。

那么这里的答案是什么呢，答案是如果你学会了风险五，如果你学习计算机体系结构，所有这些事情，你可能会成为下一个，硬件修理工，或下一个硬件探索者，取决于你想去哪里，嗯，新闻中没有计算的一点，但我确实想提出。

我们要在伊丽莎白女王的葬礼上演讲，我只想承认，对于那些表示敬意的人，默哀，谢谢你，是啊，是啊，所以她要迟到了，今天晚些时候她的安息地，所以呃，今天我们要讨论的仍然是风险五，但我们将讨论风险五的部分。

那是机器语言。

到目前为止，我们一直在讨论汇编语言，所以这看起来像所有这些像负载，加载单词，存储单词，平等分支，所有这些类型的事情，现在我们要说好吧，嗯，我们知道，也可能你不知道，但我要重复一遍。

我们所知道的是这里有一条橙色的线，在那个蓝色高亮框下面，那条橙色的线就是我们所说的ISA，所以它是软件和硬件之间的层，我们还需要做一个抽象来获得硬件，这是为了表示我们在组装中的指令，作为0和1作为位。

这里有一点动漫和动画，但这里的想法是，这就像，有点像我们全球支持的第三只乌龟，取决于您计算的级别，假设这个世界是与计算有关的一切，第一个乌龟是编程语言，然后第三只乌龟就到了机器语言，观点，我不知道。

所以我们今天要做的是，我要做一个非常快，就像闪电历史谈话，大约需要五到十分钟，所有这些都来自，然后我们将讨论风险五是如何，实际指定指令在位级别上的外观，但让我们从历史开始，所以如果我们闪回一点，让我。

呃，看看有这个现场曲目章节可用，那太好了，但现在你可以看到标题，现在我们可以看到标题了，让我回顾一下，所谓的电子数值积分器，所以我们通常不记得它被称为积分器。

但我要告诉你任何应用程序都是在1946年创建的，实际上是的，它在1946年投入使用，所以这是二战发展的一部分，这是一项主要由宾夕法尼亚大学管理的努力，这在历史上被吹捧为第一台电子通用计算机。

当时快得惊人，我这么说是什么意思，我是说都是十进制的，但它能将十进制数字相乘，现在只需2。8毫秒，现在我们更接近纳秒类型的东西，但我是说如果我们仔细想想，如果这是第一台电脑，现在是2。8毫秒，真快啊。

乘法是你稍后会看到的东西之一，其实是基准之一，即使在今天，许多计算机体系结构是如何测量的，但是，这里有一个缺点，重新编程花了两到三天时间，为什么好，让我们在这里考虑一下贝蒂·斯奈德。

贝蒂斯奈德是一些斯奈德是她的娘家姓在这里，她实际上是六个程序员之一，它曾经被称为第一台计算机的计算机，所以让我解释一下，在过去，计算很好，你是一台电脑，你是一台人机交互，实际上能够连接这台特殊的午睡机。

为什么我对你们中一些熟悉历史的人是这么说的，你一定想得很好，这就像四十岁对吧，为什么女性电脑，我以为编程是男性主导的事情，就像在二十二，发生什么事了？嗯，事实证明，这一次是在20世纪40年代左右。

交流电是为二战而设计的，因此，我们实际上计算了很多，就像物理学和弹道导弹，轨迹之类的，我们可以长篇大论地谈谈战时的努力，燃料种类，大量技术开发，但这里的重点是，社会认为困难的部分是制定方程。

关于事物如何运行的数学方程，然后用计算机计算其中涉及的实际数字，所以他们说，哦耶，计算部分是女人的工作，所以他们有很好的，事实证明，实际上你在两三周内要做的是，你真的要连上你自己的电脑，事实证明。

这份工作实际上是相当困难的，所以计算机实际上是女性主导的工作，直到二十世纪七十年代左右，它是一种通用计算机，或者个人电脑是，极客文化来了，女人们慢慢地，所以现在情况稍微好一点，但我只是想提出来。

快闪三年了，我们有电子离散变量自动计算机到电子延迟存储自动计算器，这就是我们所说的第一台通用存储程序计算机，在上一张幻灯片中，我们所看到的是，计算一些东西大约需要三毫秒，挺快的嘛。

但重新接线花了两到三天，这个需要大约六毫秒的时间来乘积，但它是一台存储程序的计算机，所以这意味着每次你写一个新程序，你实际上不必物理地连接计算机的所有部分，对彼此，你实际上可以运行它，所以这种编译过程。

又名人类布线现在快得多，在过去，他们实际上不必使用编译器，但我们可以谈谈，然后再闪过五六年，我们有IBM 7，1952年零一，这是第一台商用科学计算机，所以我们还没有接触到个人电脑，这个有冰箱那么大。

我是这么想的，但是乘法现在不到半毫秒，我们有，我想我在上一张幻灯片上跳过了，但是我们有三个6位的，在IBM的案例中，它们被赋予了巨大的规模，这里有些有趣的东西，所以如果你把这个小图放大。

我不知道我能不能放大笔记本电脑上的，没有，那很酷，如果你把这里放大，是啊，是啊，所以好吧，是啊，是啊，只有一次成功了，所以如果你看到这里的这些小点，每一个都是寄存器。

所以有两个编程可访问的程序员可访问寄存器，所以人类可以接近，此处可用寄存器，有累加器可以添加东西，为了节省那里的东西，任何乘数斜线药水注册，这里还有一些其他的寄存器，如果你放大，你可以看到一些东西。

所以这个实际上就像这里的寄存器，它们闪烁着灯光向你展示有什么部分在打开，你就像，啊，会不会很酷，好像到处都在闪烁，你怎么知道发生了什么事，下面这些开关实际上是调试步骤。

所以你可以通过打开和关闭开关来完成代码，你可以看到灯光，嗯继续，这就是老派的gdp，金星的老派，如果我们，如果我们回到70年前，很酷的东西，反正，你可能你可能喜欢，有什么意义，丽莎，有什么意义。

这里的重点是我在上一张幻灯片上简短地提出的这个想法，称为存储程序计算机，所以存储的程序计算机是说，而不是有指令，有点像，你在不同的机器或机器的不同部分之间连接的东西，将所有指令表示为位模式，换句话说。

人数，如果你用比特来表示，数据也表示为位，所以说，因此，整个程序也可以存储到内存中，就像数据一样，这就是大家都熟悉的存储程序概念，这是你从22年的第一天开始就被教导的，但七十年前。

事实并非如此，我想指出的最后一点历史，这个概念是在eniac和edsac之间发展起来的，简单地说，作者：沃恩纽曼，事实上，他才是真正的功臣，但事实证明，这是从他与埃克特和马克利的讨论中产生的。

这里有个有趣的故事，所以这是一份被广泛分发的技术报告，存储程序的这个概念，这叫做报告初稿，原来冯·纽曼的同事，赫尔曼戈尔茨坦收到冯诺依曼的第一份报告草稿，他就像是在穿越美国的火车上，他就像，是啊，是啊。

这很有趣，我们能不能，把这个发给我们的合作者，好好谈谈，存储的程序很好，然后戈尔茨坦就像，哦耶，那是个好主意，把冯·诺依曼的所有作品都打印出来，像拉通宵类型，事情是两个，五页长或四十页长。

然后把它寄给不同机构的30个不同的人，是啊，是啊，这是正确的，就像，就像你给你的学生小组发电子邮件一样，就像嘿，你能再检查一下这封电子邮件的草稿是否正确吗，不管是谁看到的，只是把它炸给每个人，所以是的。

所以多年后，我们仍然没有学会如何，如何进行人际交流，挺有意思的，计算机存储程序的含义是什么？第一，电子邮件非常重要，你应该确保阅读，在你做任何疯狂的事情之前，仔细检查电子邮件。

但这里有两件事与61 C有关，第一个你们都熟悉的是所有东西都有一个内存地址，所以我们有一张类似于堆栈的图片。

还记得我们稍后会讲到的堆栈吗？

但是当指令出现在这个文本区域的时候，在下面，这意味着树枝和跳跃，你在风险5中看到过，现在他们还使用内存地址来引用不同的指令，跳转到那些指令，看看这也意味着什么，C指针只是内存的地址。

所以这导致了很多bug，在Java做一些保护之前，我们已经看到了这一点，C不，然后还有一个特殊的寄存器，所以我们讨论了程序员可访问寄存器，那三个两个寄存器，还有一种叫做程序计数器的特殊寄存器。

你在参考卡上看到的，丹尼斯简短地谈到了这件事，这将保留要执行的下一条指令的地址，所以这里的重点是PC实际上是一个指向内存的指针，它也被称为指令指针，如果你来自不同的建筑，所以所有东西都有一个数据地址。

或者对不起。

所有东西都有一个内存地址，第二件事，这就是我们今天要讲的，因为存储的程序意味着你可以把程序作为数据来编程，然后如果你有它作为数据，然后你可以把这些数据放在另一台计算机上。

所以这里的第二个要点是程序是以二进制形式分发的，换句话说，它们是组装的机器代码，机器代码是0和1，它们都被绑定到一个特定的指令集上，所以这里的指令集不仅定义汇编语言，以及汇编语言的0和1应该是什么样子。

然后更进一步，很多指令集，因为它们在我们的城市里使用，就像每一个指令集都是在一堆不同的设备上使用的，如果您更新了说明，你不希望在那个设备上的工作被落下，所以很多isas实际上是向后兼容的，例如。

这意味着x80，英特尔公司的“六架构”有点来自于“八零式”，八八八八，八十年代的零八，如果有一个程序是在这些机器上编译和组装的，你可以用X80来运行它们，六十四是我们今天的一个，有点酷，但值得思考的是。

我在上一张幻灯片上提到了一些东西，我再明确地说一遍，这里发生的事情是，因为机器作为程序是以机器代码分发的，那台机器编码那些0和1的配置方式，需要在不同的计算机之间保持一致，所以像风险五这样的指令集架构。

它定义了装配代码和机器代码，就不同的指令是什么样子而言，这里的一个例子是广告x18和x19，这里X十，汇编语言实际上变成了比特，你在右边看到的，你真的能做到，你们会在今天晚些时候的课上看到这个例子。

当我们讨论机器代码是什么样子时，这里有一些要点，它实际上是为处理器而设计的，而不是为人而设计的，所以有点看不懂，但在我们开始之前，我想让你知道的一件事，有一件事你应该记得或者你知道，当你继续前进的时候。

你会想到一切都有风险，差不多是三两比特，所以单词是三个二位，整数，我认为在很多架构中，我们看到的是我们的两个部分，指针是三个二位，但指令也是32位，所以风险五，对于不同类型的风险五架构也是如此。

他们都将使用32位单词，所以这意味着每条指令都被表示为三个二位，仅此而已，关于简单性的一个和另一个观点，在我们继续给你看一些机器代码之前，风险5，我们将在这里使用一些术语，所以我讲了一点单词。

你以前见过这个词的概念，但我们还将讨论单词中的字段，我们将定义哪些字段实际上是，它在这里的幻灯片上定义了，字段是一组位。

在这三个中，两个，然后至少在风险五，而不是有一个特定的指令，总是绑着喜欢加，比如说，好啦，我是说，让我往回走一点，风险五号的作用是，它有不同种类的指令，然后它对你见过的所有不同的指令进行分类。

在参考卡上，你看过的讲座和实验室，所有这些它将它们归类为这些R格式，I格式，S格式，而这一切，我们要把它们都检查一遍，但你可能会说，这是很多或者像，不能，我们只是说广告是指导，一和子是指令二。

为什么我们不能，用一个比特表示该指令，事实证明，你实际上想使用这三个二位，因为你想让CPU看起来像什么，我们将在几周后看到这一点，所以风险5的作用是，上面写着，而不是为每一条指令定义不同的字段。

只有大约40种不同的格式，让我们在这里有格式，所以我们今天要讨论前三个，然后我们下次再讨论下三个，准备好了吗，好啦，我听到一个，是啊，是啊，对我来说够了，至少我们今天有很多人，这有点令人兴奋。

我知道也有很多人在聊天，让我们来谈谈第一种格式，哪个才是最有意义的。

然后我们就像过山车一样继续，你就会明白，你就会明白，现在说不通，两周后你就像，哇塞，设计风险五的人实际上在思考事情是如何做的，那么上周我们讨论组装时，我们从风险5开始，在我们开始研究这种结构的前一周。

我们有个行动，所以关闭指令的名称，我们有注册目的地，写东西的地方，然后两个寄存器操作数或寄存器源，一二，那么这看起来像什么呢，这就是我们将在今天的课程中看到的，还有周三的讲座。

但是这个操作数或d one是2或op名，嗯看起来像下面的三个二位，换句话说，所有的r格式都有这些字段，机器码中的指令字段，让我为每个字段稍微解释一下这个图，你可以看到，这里有三排，最上面的一行是字段。

位位位置，所以它从零开始一直到三一，里面的名字，这就是这个领域的名字，然后你要用比特填充它，然后你要用多少位填充它，你要用第三个数字填充它，所以操作码，例如，是一个七位字段，让我们来谈谈其中的一些。

因为你就像，好啦，只是说说而已，这里发生了什么事？首先让我们想想什么，这里的目标是什么，这里的目标是我们想把汇编语言翻译成机器语言，这就是风险五A告诉我们的，这就像，如果你看到这个广告。

你应该把它翻译成这些，那么它是如何做好的呢，上面写着这个操作名称，所以你得到的指示，这里会有三个字段告诉你，那个指令是什么，第一个是操作码，操作码部分指定指令，从某种意义上说，我不想说太多。

但从某种意义上说，它大致告诉你它将是什么格式，这就是为什么它在开始，如果你想到像，这台机器能很容易地读出前7位，然后用操作码一起放克三个和放克七个字段，描述要执行的操作。

所以这里有17位专门用来告诉你什么操作，会有什么指示，我们会解释为什么，为什么他们都在一点点分裂，现在呢，注意这里，我会在另一张幻灯片上重复，是为了我们的格式说明。

这些指令与所有看起来像这样的东西有什么关系，经常是一个两个，这些是这里所有的算术和逻辑指令，所以所有这些像and和xors和向左移动，移动小于他们都将有这个操作码为零，一个，一个，零。

零，一个，一个，这里更有趣的是寄存器的样子，所以你可以看到，这些碎片就像翻转了一点，但如果我们从右到左阅读，我们首先看到的是，然后我们看到一个，然后我们看到RS 2，所以我在这里用了颜色编码。

我会试着在整个幻灯片中保持颜色编码的一致性，但这些都是相同的目标寄存器源寄存器和源寄存器两个，你们在以前的课上见过的，但现在在机器类代码版本中，现在你可能想知道，为什么只有五个像。

我以为寄存器就像三个二位数据，像什么，我们怎么把三个，二位对三十，两个比特像三次，这里发生的事情是，这是电脑指令，所以这条指令到底想说什么，是嘿，CPU访问此寄存器号。

所以你只需要5位来表示3个可访问寄存器，所以这些字段中的每一个都是5位来表示寄存器号，从0到31，我知道丹上周，啊，我们不是，我们不再用数字了，我们要用这个名字，原来机器代码使用数字。

所以我们跳回去登记一下号码，你就像，好啦，我看过定义，但我不完全明白这些片段是在哪里发生的。

让我给你看一个例子，会让事情变得更清楚，这是我之前在几张幻灯片上放的例子，让我们看看这个位模式最终会是什么，你就像，为什么好，就像我之前说的操作码，所以如果我们有这个添加指令。

汇编程序的工作之一是查看这个汇编指令，通过在表格中查找东西来将其翻译成位，这张桌子是你的F卡还是这里的绿卡，嗯，我们首先要说的是，哦耶，这里的操作代码，这是我们所有格式指令的操作代码，好啦。

然后注意这里，我在用寄存器这个词，在这里注册代码，因为我们有两个行动，我们有两个寄存器，然后我们写到的一个寄存器，我们需要这三个寄存器，是机器代码的R格式，第二件事是，如果我们在绿卡上查东西。

或者如果我们在CS 61 C代表卡上查一下，我们会看到放克3号和放克7号，如果它们都设置为零，这十个零位的组合将是汇编指令应用程序的功能，最后这里的三个寄存器是简单的位表示，无符号位表示，登记十八号。

注册十九卢比一注册十卢比二，你就像，哦好吧，好像那还不算太糟，就像我不知道广告是从哪里来的，但我觉得我确实告诉了我关闭代码是什么，我至少可以把这六个领域中的四个，现在这里还不错。

让我告诉你这些操作码是从哪里来的，所以这只是我的复制粘贴，把参考卡上的东西放进幻灯片里，所以不要觉得你必须抄下来，我们还有打印件，所以你也可以把那些捡起来，注意这里，我的意思是，好啦，这些其实是位。

三个二位字，所有十种算术的指令词，或者我们的格式说明处于风险五，所以我把收银机涂成灰色，因为这将取决于，你在看的确切的寄存器是什么，但是请注意这里所有相同的操作码，让我们看看我是否有动画。

所有相同的操作码，不同的放克放克3和不同的放克7，我想让你知道的是，你记得我们说的是，为什么我们甚至有17位来表示所有的信息，嗯，我讲了一点，至少在这里关闭代码，这七位表示指令的格式。

这将是我们拭目以待的事情，有不同的格式，然后这三个比特，函数三，嗯，只有三个比特，所以实际上我们只能代表2到3，就像一个指令，如果我们在这里有这个额外的领域，我们仔细看看这张桌子，有重复的放克3。

然后加和子有相同的恐惧三个字段，然后向右移动，逻辑与右移位算法，有同样的放克三场，你就像，好啦，嗯，我们想做什么，或者喜欢，这样想吧，风险，我想让一切都简单，也在写这些机器代码。

比如为cpu编写机器代码的规范，所以CPU想知道的是我需要把数字加在一起，哪些号码，这个放克七在某种意义上告诉你哪些数字，对，所以要加法，你只需把数字加起来，在r 1和r 2中表示减法。

你加上rs 1和rs 2的两个补数，你只需要一个比特来表示这些信息，与右移位逻辑和右移位算术类似，记住这两件事之间的区别是合乎逻辑的，意思是你把它当成一种没有签名的东西，然后你就像在上面涂抹零一样。

上部或城市向下涂抹零，喜欢用0填充上面的字段，然后在移位右算术中，你想保留招牌，咬，所以你只需要抹上1或0，当你向下移动的时候，同样，你只需要一个比特来表示这个信息，就是你是否需要签名，延展与否。

最后这里有一点，这张幻灯片上可能有一些你没有看到的说明，特别是转移，或者被设置为小于它所做的是它将目标寄存器设置为1，如果r，如果1大于r 2，所以这有点像布尔运算，到目前为止我们一直在冒险。

但是如果你对此感兴趣，你可以看看剩下的部分。

那么这里的重点是什么呢，这张幻灯片的重点是有十个说明，我们不指望你能全部记住，所以你才有裁判证，所以你才有绿卡，但是，了解一点什么，让你记住，就像向自己解释为什么这些位模式会这样工作。

也许你会在生命中的某个时候设计风险，轮到你了，所以我们要说，我们将在这里暂停一下，接受一点纯粹的指导，我们如何编码x 4 x 3 x 2的加法，我们如何对这条指令进行编码，暂时忽略注册表名。

把注意力集中在这里的注册号上，我有一些选择，我也为你准备了查询台。

我会试着到处拉，看看是否有效。

有用吗，或者不像以快速的方式繁殖。

所以我要分享我的屏幕和另一个，哎呀好吧，这个呢。

好啦，让我们花一分钟，稍微考虑一下，看看我们会去哪里，我的POV和舞蹈不一样，所以记住它将是Poll Ev dot，com斜线y a n l yan。

我暂时把投票结果藏起来，这样你就可以不用考虑同龄人的压力来思考事情。

好吧，今天注意力有点低。

我可以把墙变得有趣，我只是想我切换回选择一秒钟，有趣的好，我会回来的，我们这里气氛有点紧张，我忘了做，欢迎回到六十一吴类型的东西，也许我们现在就做，欢迎回到61英尺，对，我们再休息一下，因为再一次。

今天是星期一，现在是早上十点，我们从，这里基本上是台风季节，至少在湾区，我给你们讲个笑话，你怎么称呼住在堆里的爬行动物，一种生活在高温下的爬行动物，住在堆里的爬行动物，堆鳄鱼，我知道你喜欢。

什么是堆分配器，这就像决定，像malloc一样获得哪些内存块，是啊，是啊，是啊，是啊，好啦，所以让我们回到，好啦，你们都放了什么，我很好奇，好啦，所以我们有很多选择。

让我们来谈谈这件事，所以有不同的方法来做到这一点，有时我没有给你足够的时间，因为你就像计算机，您正在将一堆位转换为寄存器字段。

但是让我们在这里用消去法，这很可能是你们中的许多人很快，敏捷的人最终这样做了，我们要做的第一件事，这有点像复制你在家庭作业中所做的，或者你以后会做什么，当你执行你的项目时，你在桌子上查东西。

我告诉过你这是广告指示，你在桌子上查东西，你就像，好啦，那是我的行动代码，我的放克三场，我的放克七场，所以我要把它复制粘贴到32位的指令字里，那些田地应该在哪里，根据风险，我希望。

而不是像翻译所有的东西，我只是要翻译几个十六进制，或者一次几个十六进制数字，例如，我可以我可以翻译第一个，最低的四位是单十六进制数字三，我可以把上面的四位转换为单十六进制数字零。

然后现在突然间我已经排除了很多选择，你好像没事，那不是我只翻译成两个十六进制数字，这真的很好，我们想在这里做什么，请注意操作码有7位长，我们把其中四个翻译成一个十六进制数字。

所以我们离下一个十六进制数字只有一点距离，所以也许让我们翻译一下目标寄存器的寄存器，所以目标寄存器在这里，因为它是4号收银机，是位模式0 0 1 0 0，或者四个的无符号表示。

然后我实际上又创建了两个十六进制数字，因为第3个字段的注册有5位长，所以我们得到了另外三个-两个新的十六进制数字，实际上现在我们突然有了一个合理的答案，如果我们忽略其他选择，所以如果你喜欢，你知道的。

我很确定是别的什么，我们可以在这里翻译剩下的两个寄存器，一卢比和二卢比，他们将是三个和两个，然后你就可以做所有这些文本数字，是啊，是啊，中间有个问题，很好的问题所以问题是。

我还是不明白为什么我们用17位来表示10种不同的操作，之后会发生什么，为什么他们都在三个不同的地方，很好的问题我开始回答为什么我们有17位，至少有一种不同的恐惧，七个代表。

我还没说为什么他们都在不同的地方，事实证明，风险的长期设计原则之一，五个在机器学习级别或机器学习机器代码级别，你希望东西在不同类型的指令中处于相同的位置。

我们会看到的，在我今天谈到的最后两种格式中，很好，所以实际上。

让我们现在看看这个的一个版本，I格式化，这是R格式，这就是我们刚才看到的格式，但是立即呢，好啦，如果我们加i，这里加i和加well有什么区别，汇编指令的最后一部分是即时指令，好啦，好让你知道。

这就像一些常量，你只是提供，你提供的一些东西，如果使用R格式，所以如果你想在这里保持相同的格式，嗯，你可能会试着把你的直接代表，在RS-2字段的五个比特中发现这真的很小，因为你只能表示三个二值。

所以你得喜欢，将即时存储在内存中，或者类似的东西，所以我们要做的是把中间物放入所有，我们只是有不同的领域，所以我们把RS 2和Funk 7分开，创建一个12位长的字段，立即放入，所以我注意到了这个。

R格式基本一致，不过，再想想CPU想做什么，CPU将查看这三个二位，然后执行该指令，不知何故，所以我实际上可以重用，有很多硬件要处理，处理注册目的地的操作码将是处理过程，放克三r等于一。

然后现在到了最后12位，我从操作码就知道格式会不同，指示会有所不同，然后它会说好，接下来的十二个比特将是我的直接，我将代表，我会把这十二位解释为那个数字，我要把它加到R中。

但让我们更详细地看看，所以这是这里的布局格式，我们有和以前一样的寄存器，但现在没有更多的RS，不再有两个商店，因为我们有这个即时的，这个即时可以在一个相对较大的范围内保存值，所以这里要给它赋域来补域。

它将从负2478到正2477，CPU将签署扩展，做三个二位就能把它加到三个二位宽寄存器一个，然后把它存放在32位宽的2号寄存器里，你可能会想，这是我的意思，所以只有十二分之二，我们所有的其他媒介呢。

我们将讨论如何表示即时，比12位要宽，但为了这个，至少对这个代表来说，我敢肯定风险5设计师说2到12，对于大多数计算来说，这是一个合理的范围，我们也会看到这一点，所以让我们来看看这个。

我们这里有一个例子，所以这里的例子是我们有，如果我们想添加，我储存在x15，x 1加负50的结果，记住这里我们不必做减法，我们现在有一个不同的关闭代码，零零一，零零一一，对的那个，是啊，是啊，我想是的。

因此，但我们只有一个放克三个，这就是加i，或者在这种情况下是添加，它与我们在格式中看到的放克三人组非常相似，然后我们有注册目的地，我们有一个，然后我们也有直接的代表，那是二的补语，是阴性的，所以看起来。

好啦，从某种意义上说，我们只是在改变i格式，是啊，是啊，还有一个问题，否。

提出问题的问题，它把它带回到机器--机器代码的表示，所以，还记得在R格式中，我们有十种不同的指令，包括减法，但我们必须用放克3中的2到3位来表示它，然后放克七中的2到7位，现在以i格式，我们只有一个。

二到三位字段，或者一个三位字段，那是放克3，放克7，现在没了，因为它被立即和更早的，就像上一两个星期前，当我说没有潜艇的时候，因为你可以直接加一个否定的，事实证明，这实际上对机器代码表示非常有用。

因为现在我们不再需要代表十个指令，我们只需要代表，不用于i格式的中间体，但是我们仍然试图用同样的两个或三个来表示九个指令，我们有三个位放克领域，那么什么做了什么冒险五。

他们对某些指示说得好吗，我们实际上从来不需要12位媒体，这些是什么说明，移位指令，左移右移，你只会转移，在一个三三两两的单词里，所以你可以移动的最大空格数，你喜欢意味深长的是三零到三十一。

我是说零也是没有意义的，但你知道就像那个范围，因此，让我们只表示移位量，成形场，我不认为实际上有人说移动量字段，让我们把它表示为直接的最下面的五个位，然后用上面的七位，好啦，所以如果你看到61C的唱片。

这些都被认为是i格式，但是在圆锥C参考卡上有一个小i星格式，在移动操作中显示这种差异，就像以前一样，我们有同样的正弦，向右移动位，我们有的算术立即向右移动，算术。

只是看到这种一致性在不同格式之间是非常有用的，好啦，我们继续走，所以我说了一点，你可能在想，现在你就像，好啦，R格式，R和R格式代表寄存器，I和I格式代表立即伟大，但是i和i格式也代表load。

所以加载指令也使用i格式，你说为什么，让我们看一个例子，所以回想一下汇编指令是什么样子的，如果你想加载一个词，所以一个三两位，呃，部分数据从内存进入寄存器x14，嗯，哪个内存地址，你用。

存储在x寄存器的值加上它的偏移量，所以这是在提醒你组装版本是什么样子的，嗯，事实证明，这里的i格式的三个二位格式可以表示，这就是为什么首先你有一个不同的操作码，零零零一，现在你有了一个不同的放克三人组。

因为现在你正在加载一个词，但这些其他的东西在这里有合理的意义，你在写什么？你在写14号收银台，您使用哪个地址来计算这个基地址，或者对不起，使用哪个寄存器来计算基地址，然后加上您使用的寄存器2的即时值。

然后你在存储和注册的任何东西上加八个，这就是我所展示的，示例页面是，我们不需要创建一个新的格式来表示负载，因为把存储在寄存器中的东西加在一起的想法，注册一个或基本地址，在这种情况下，加上一个即时值。

然后用它做点什么，然后将结果存储在目标寄存器中的寄存器中，在负载中仍然如此，唯一的区别是你没有储存，你储存的东西的添加，就像内存中那个位置的数据进入寄存器。

好啦，这里是加载指令，更正式一点，所以我们有这个操作码，所以再次加载指令，他们有一个特殊的操作码，你可以在参考卡上查一下，现在我们有了一个目的地寄存器，和以前一样，有时我们称rone为基本寄存器。

因为它是我们开始寻找的基地址，然后我们有这个直接的偏移，我们添加到基址以在这里创建完整地址的这个常量值。

有一些加载说明，你们可能已经在丹的课上看到过了，但我只是要重复一下，我们在这门课上通常使用加载词，但事实证明，风险五也会加载位和加载半字，让我们来看看这个，我稍后会讲到签名，但由我们来装载，而不是装载。

加载字节和加载半字，但这两个人做的是一个符号扩展，好的，好的，假设您从内存中加载一个字节到寄存器中，嗯，寄存器有四个字节长，所以你在上面的三个字节上重复符号位，好啦，这就是加载字节的作用。

如果你有加载半个字或半个字是半个字，所以是十六位，两个字节，您将两个字节的内存加载到三个二位寄存器中，您仍然需要用符号位填充上面的两个字节，您还可以使用无符号加载字节，加载半字无符号。

但它真正的作用是零倾向，好啦，所以与其像，而不是复制你最上面的符号位，你实际上只是在上面的位上复制零来填充信息，你可能想知道，为什么只有五条指令，为什么没有未签名的加载字，好在，如果你是这样。

如果你从内存中加载三个二位到一个三个二位寄存器中，没有什么比上面的部分更值得考虑的了，因为你把收银台里需要的东西都抄了一遍，所以再一次，思考风险五，他们和教练在一起很舒服，或者至少是简单的想法。

嗯是的，这里有很多信息，但又一次，这堂课的重点是什么，这节课的重点是你可以做很多查找，我试图解释为什么这个建筑被设计成。

他们以前的样子，现在我们终于要回到，我们的第一个问题，或者就像观众中出现的一个问题，就像，是啊，是啊，为什么我们需要三个字段，为什么他们都像，分开一点，我们看到了一点，就寄存器2的去向而言。

但让我们在商店中更清楚地看到这一点--商店格式有自己的布局，它们看起来像这样，你有不同的操作代码，然后我们有rf1和r2，这些是什么，这些就是我们所说的存储在内存中的数据的源寄存器，然后基础寄存器。

在内存中的基址，然后你就像，哦耶，好啦，所以我记得就像加载一样，低基址，加上立即抵消，你仍然有12位的直接偏移量，但现在他们被分成了两个不同的领域，你就像，哦，我的上帝丽莎。

五个人在凌晨两点做什么有风险，他们做得很好，这个立即的偏移量是，与加载地址的偏移量相同，好啦，所以这和你用12位来表示信息是一样的，它恰好被这一区域较高的7位分了，然后下面这个区域的5位，你就像。

他们为什么要这么做，他们为什么不把收银机调低一点，他们为什么这么。

为什么现在是在第二台，在这张幻灯片上，记住我之前说过的话，这里的机器语言，不是给我们的，人类，它是为像这样的处理器准备的，它是为建筑设计师做一些有用的事情，并能够真正喜欢，高效地浏览说明。

即使跨越不同的格式，所以我们想让S格式尽可能接近，我们关心的其他事情，我们真正关心的一件事是，我们会，我们会在接下来的时间里强调这一点，实际上就在期中考试之后，所以我们会强调这一点，教师最重要的是指导。

说明书最重要的一点，读取寄存器在同一个地方，正确的寄存器在同一个地方，那么我这么说是什么意思，我是说，记得以前用R，比如R格式，指示我们有一、二、一、二，你从那里读取值，然后你把它们写进。

商店伙计商店读什么，来自两个寄存器的值，要存储到内存中的值，然后我们出发的地址，也没有收银台，所以说，因此，s格式实际上结合了来自i格式和，这里的r格式，或者i型和r型，也就是说。

我们希望将两个读寄存器从R格式保留下来，从原型，在同一个地方，我们没有地址，所以，因此，我们将把这些较低的位移动到这里的第三个位置，事实证明，实际上，这很像CPU不太关心立即读取和计算。

但它真正关心的是能够正确地访问寄存器，我再回答一个问题，是呀，啊，是呀，所以很抱歉，这应该是立即五和立即四，零，是呀，这里的5位，是啊，是啊，所以谢谢你，我们将看一个例子，下次，祝你星期一愉快。

下课后我会和你谈谈，星期三见。

P15：Discussion 4： RISC-V Intro, Control Flow - 这样好__ - BV1s7421T7XR

它应该像好的那样编辑，每个人，呃，我们现在要开始了，所以嗯，你好，欢迎参加今天的讨论，我们将介绍风险五的介绍部分，所以一个快速的温度检查，让我们看看人们对风险的感受五号上升一半下降，好啦，好啦，嗯。

所以我看到了很多很多，嗯嗯，中下，所以我会尽可能详细地报道，回答尽可能多的问题，所以我们可以这样风险五就有希望变得更多，哦更容易理解，所以所以几个物流，所以第四圈已经结束了，我想说做这个项目非常重要。

因为它涵盖了调用约定，我们今天的讨论将不涉及，那是下周的讨论，但大腿盖住了它，我认为仔细看一下真的很重要，因为是的，然后一个项目二已经发布了，项目二a将于本周三到期，我们会有更多的助教。

在本周本学期的教职员工中使用导师和人工智能，因为项目到期了，第三个家庭作业是浮点运算，今天要交，所以我会在办公时间来，你需要任何帮助，今天我们要讨论，呃，风险五概述，与之相关的指令种类。

风险五到底是什么，从C到风险五的翻译，反之亦然，在我们开始之前，有人有什么很酷的问题要问吗，所以我喜欢用这张照片，因为它恰到好处地显示了手腕5，把它融入了六比一的C课程，所以在这节课中。

我们将使用这个整体的想法，并考虑这个，我们的计算机现在正在处理处理器中的东西，不管我们报道了什么，早些时候已经习惯了，只需提供计算机中实际发生的事情的高级抽象，现在我们要低一点，覆盖一些东西。

在一个叫做数据路径的东西中覆盖东西，我们将在将来更详细地介绍数据路径，呃，讨论情况，但现在只需知道以下项目，所以我们有一台电脑，它是一个程序计数器，它是硬件的一部分。

它存储了我们当前正在执行的指令的地址，然后我们有寄存器，它是小块硬件，方便快捷，它存储cpu当前正在执行的任何值，然后我们有一个算术和逻辑，我们的ALU执行任何算术，所以加减法，乘法，司，或逻辑操作。

如位移位，或者和或异或操作，这就是我们的数据路径中基本上涵盖的内容，然后呢，我们能够使用我们的数据路径与一种内存交互，通过内存指令，根据我们想要的东西写入或读取数据，那么风险五到底是什么。

风险五代表减少教学，顺便说一下，加州大学伯克利分校发明了五台计算机，所以这是一件值得骄傲的事情，风险五本质上是指令集架构，这是一个由CPU和主存组成的系统。

它还使用一种由简单指令组成的汇编语言来完成单个任务，CPU的作用是，它负责计算，如果你，CPU接受一个和指令，并执行任何必要的操作，以确保进一步的指令获得必要的输出，然后是主内存乔丹的长期数据，哪个呃。

我们在前面的图表中提到了一点，但它展示了我们如何，您可以通过使用某些指令来与主存和我们的数据路径交互，然后CPU可以通过寄存器存储内存，登记册，它们是CPU中存储二进制文件的硬件组件，他们在风险5，呃。

我们有三个两个寄存器，它们每个最多存储三个二位寄存器编号为0到3 1，所以x 0到x 3 1，在五号危险区有一个很特别的，也就是鸡蛋0和x 0只存储0的值，它不能储存，您不能修改该值，它总是被设置为零。

要知道的一件事是寄存器不是变量，你不能假设，仅仅因为您之前设置了寄存器值，这还没有完全一样，在你完成一组指令之后，它有可能会被保存下来，或者类似的东西，呃，到目前为止还有什么问题吗，好啦。

所以我们可以去，我们要开始检查说明书，我强烈推荐的是，就像我提到的，早些时候，当人们慢慢涌入，就是看看六一C参考卡，它将包含我们所有的指示，说明的名称，以及每条指令如何工作的描述。

如何和一个叫做操作码的东西，放克三号和放克七号，呃，它没有，如果你现在还不明白，别担心，我们将在以后的讨论中讨论这个问题，好啦，所以冒险五集会，每当有危险的时候，我们通常有指令。

指令通常是在我们有指令名的格式中，然后我们就有了目的地寄存器，然后我们的操作数，可以是两个源寄存器，也可以是一个源寄存器，和一个即时的，从理论上讲，你可以在每一项旁边加上逗号，你在写指示。

你把指令放进去，但是呃，没关系，不管你有没有加逗号，这仍然是我想我实际上会推荐的东西，使您的代码看起来更干净，然后使用哈希符号编写注释，很像Python，然后我们有寄存器呼叫，然后我们有一组寄存器。

它们以某些方式起作用，取决于他们的名字，所以我们有一个零，所以我们有我们的s寄存器，它们都是零，是一点，然后是两点到十一点，它们充当保存寄存器，然后嗯，现在，我们只需要知道它们是保存的寄存器，呃。

他们会的，当我们报道呼叫约定时，会更有意义，为什么它们被称为保存寄存器，然后我们有T 0，两个，三二六，又是临时寄存器，当我们打电话给林大会，那也更有意义，为什么它们也被称为临时寄存器。

然后我们从0到7，呃，通常每当我们调用风险五计划，呃，指示，我们传入函数的任何类型的数据，通常存储在寄存器中，然后我们有r，它是一个回信地址，回信地址基本上是，假设我们把一个内部风险五环。

如果我们想把我们的地址，这样我们就可以回到我们从，我们会把那个地址，那台电脑，寄存器中的程序计数器，然后我们有堆栈指针，哪个是哪个是哪个存储堆栈的地址，正如我们所记得的，我们讨论了堆栈堆代码和静态代码。

这个sp只存储堆栈指针，我们会减少，每当我们想添加更多，我们希望在堆栈上存储任何新变量，所以算术指令我们的第一套指令，我们要复习一下我们的算术，这里有三种主要的算术指令，所以我们有加减法。

几乎就是把两个寄存器加在一起，把这个值放入一个新的寄存器，还有什么，然后耶，我们实际编写和注册的一个例子是这样的，加x三x二x一，因为我们的语法在本例中是我们的目标寄存器，然后源寄存器1和源寄存器2。

我们知道源寄存器中的值是存储在，呃，目标寄存器x3，呃，它将是x2之和的值，或者x 2中的值，加上x 1中的值，然后减法是同样的惯例，只不过它只是用了Sub，然后我们有两种班次。

我们有逻辑移位和算术移位，它们基本上是一样的，只有一个例外，我现在要看一下，我们需要知道的是，对于逻辑转移，每当我们移动任何一种二进制数，从右到左或从左到右，我们会在必要时追加零，然而。

我们不能对算术移位说同样的话，如果我们决定从右向左移动，我们就不能，或者是的，从右到左，那么是的，可以追加零，但是，如果你从左向右移动，你有任何类型的数字，你附加到，MSV必须等于MSB，例如。

如果我们把二进制数，如果我们转移，如果我们做一个向右的算术移位，我们可以做的就是加上我们可以去掉这个零，然后在后面加一个零，但是，在二进制数是1-1-0的情况下，发生的事情是，我们会，从理论上讲。

我们可以从理论上摆脱这个零，我们会代替，但因为我们的MSB是一个，我们必须向MSB预先准备一个，所以这就是我们的转变，两者对乘法和除法都很有用，逻辑转移，尤其是对于无符号数的乘除，然后你有算术移位。

适用于无符号数和有符号数的乘法，但它对正弦数的除法很好，呃，有人对转移有什么问题吗，是呀，你刚才举的一个例子，即使你把它移位了，呃，离开了大，是呀，当最有效的位是1时离开，你也不必加一个，嗯等等。

请您再说一遍好吗？所以这就像，你知道这个例子，你就会得到1 1 0 0，你把它移到那边，是啊，是啊，嗯，你为什么要喜欢，加一个，因为什么时候已经有一个了，不管怎么说，那里，不是我要左移的原因。

这次我们做了一个正确的转变，好啦，是啊，是啊，左移，是啊，是啊，我们会在末尾加上零，否，不管是算术移位还是逻辑移位，所以如果你有一个和一个移动左边三个两个位，所以它变成了负数，所以只有一号，是啊，是啊。

好啦，所以在数字中，如果我们假设它是三个二位，我们可以假设在十六进制中，我们可以很容易地把它写成零x零，零零一，意味着四位数意味着，这意味着每个零等价于四个二进制零，然后你的问题是。

如果我们在4点31分后向右或向左移动，好啦，所以第一个应该是一个，而且MSB变成了一个，所以它变成了一个负面的，是啊，是啊，它本质上确实变得消极，而且是的，似乎你必须对这样的事情保持谨慎。

尤其是当涉及到符号数字时，你转移得越多，很有可能变成负数，如果你自己去做MSB，是啊，是啊，也是为了算术红移，如果你移动32次，第一个是一个，所以它就变成了，否则哪个是哪个不是数字，嗯，数字。

我会说我们在这里表示的数字是二的补数，所以不是数字，我相信是浮点，呃，我们不必为此担心浮点运算，是啊，是啊，有办法实施浮点和风险五顺便，但那超出了课堂的范围，所以呃，呃，这里有个问题，所以我想澄清一下。

所以如果你是负数，如果算术移位，对不起对，它总是会答应，我们只是简单地添加了一个，我们在MSC那边留了一个，这样就保留了它的消极部分，嗯，我想快点，呃，这里有几个例子来说明转换是如何工作的。

算术和逻辑算术移位和逻辑移位，所以我们做算术的指导是正确的，班在哪里，我们的决赛，我们的末端代表着，我们要移动多少位，我们在这里做的是，呃，正如我前面提到的，我们除掉，我们去掉右边的数字，但在左边。

我们准备了一个，因为我们的MSV是一个，我们保持这种状态，是啊，是啊，对于斯里兰卡来说，而不是把它转移到，是啊，是啊，对于斯里兰卡来说，在这种情况下，这是合乎逻辑的右移，我们会，我们不在乎MSV是什么。

我们总是在后面加上零，然后是一个S lli或Sr，我是我们的李或者是的，Lli，当我们轮班的时候，我们也会加上零，然后对于，如果我们也做一个算术左移，是啊，是啊，有人对运输有什么最后的问题吗，好啦。

所以考虑到这一点，我们有一件事我想尽快谈谈，是立竿见影的，正如我们之前看到的，我们在我们的sr ai说明中，我们在最后有一个数字，这个数字就是我们所说的中间数，而直接数是一个数字常数，它是2的补语。

所以这是非常重要的事情，这就是为什么我们报道转移，因为2的补语，它们经常以代码的形式出现，而且对他们有特别的说明，呃，有一种特定类型的指令，在这种情况下，其中一个例子是add i指令。

我们要做的是添加排序，我们在源寄存器中的值上加上十，在这种情况下是x2，然后把它加到x3，语法与add指令几乎相同，但我们可以，但是我们有一个数字，它存储在我们的第二个源寄存器所在的地方，而不是第二种。

举个例子，正如你在这里看到的，加将等于它，如果我们能加x 2 x 1 x 0，或者如果我们想用一个即时的，我们可以加i，x 2 x 1，那么我们的直接等于零，考虑到这一点。

我想复习一下工作表上的一个子问题，我相信这是二号，我想这是第一个，呃，三号中的三号，是啊，是啊，所以花几分钟，请随意与邻居聊天，如果您不确定语法是如何工作的，请随时询问我们，你有什么详细的问题吗。

聊天里有个问题，立即的范围是多少，我现在还不知道，我以为它就像一个32位的价值，但我可能错了，所以它可能是一个三二位二补码，但我想这是三个二位二的补语，因为我是说，如果你决定表示一个二三二位的无符号数。

这很容易被翻译成2的补语，当你做加法之类的，我去查查文件，很快的，我想要两千，我们已经讨论过了，哦，你有吗，好啦，我告诉你的iPhone的名字，好啦，好的很好，如果你想储存一个更大的，比两千块还快。

我们会被称为，有一个伪指令可以为您做到这一点，称为load mediate，那就是我们不会，我们在今天的讨论中可能不会涉及这一点，但这只是要知道的一件事，你们和缩放听到回应了吗，除非你能拿起，确保你。

媒体对前三名其他人有一个更好的，对不起，请您再说一遍好吗？编写代码时，我们可以用什么寄存器，我知道怎么用，类似于临时寄存器，我们也用像，你可以用s，但是有一个特定的语法，你得遵循某种惯例，所以嗯。

我可以简单介绍一下，因为被称为保存寄存器，我们要做的是确保，如果我们从，想要访问S寄存器，调用新函数后，必须是一样的，所以新函数要做的是存储，将s寄存器存储到堆栈中，并将s寄存器的值存储在堆栈上。

如果他们想使用任何特定的s寄存器，最后他们把它们装回去，然后原始函数可以访问与寄存器相同的，像以前一样调用函数，是呀，你说过，寄存器没有数据类型，是自我约定，这是不是像，与那个想法不同，就像一个数据。

我去开会，您可以将开始视为只需要从一个开始，好啦，我想我们现在可以开始了，所以在我们的C代码的第一行，我们有int a等于4，B等于五，C等于6，有谁知道将军，我们会使用指令来做第一行的每一个设置。

我想和我是的，我会工作得很好，所以如果我们决定使用，为a b和c加上眼睛，我们能做的就是，加上i，在这种情况下，如果我们想把a设置为4，我们必须等于零，然后我们希望它等于四，所以我们可以做x 0然后4。

然后我们把同样的原理应用到b和c，所以它是加i s 1 x 0和5，再加上i 2 6 0和6，最后我们有了最后一句台词，在z处等于a+b+c+10 um，我们会有多少不同的指示，会。

我们需要专门用于这条线路，哪个名字，呃，C代码的第二行，是的为了很多指示为了指示，是啊，是啊，我是在暗示像你一样，你得用，添加和添加i，因为您在末尾有一个新的媒体，但是是的，看来你们都明白了。

呃我有个问题，是啊，是啊，我们也能立即装载零号吗，是的，嗯，我会我实际上建议只使用加载立即，因为这比在零x零4处写作要容易得多，对于那些想知道，嗯加载立即是一个伪指令，在伪指令中发现，参考表的一部分。

它是，它几乎只是添加i，你的寄存器，x，零，任何你想要的即时，但可能会有一种情况，你想要一个更大的即时，这种伪吸引力也涵盖了，是啊，是啊，所以考虑到这一点，我可以随便写，这一行被转换为风险五。

所以这将是，我哦对不起，因为我们将在这里使用寄存器，如果我们知道z等于s3，我们做的是3x0，或者实际上我可以让这变得更容易，通过做s 0和s 1，然后我们加嗯三三和二，然后加i。

3等于3等于10对每个人来说都有意义吗？是呀，所以我们需要初始化，嗯你其实没有，因为呃，我们已经知道我们的值在零点和零点会是什么，好像有什么额外的价值，如果从s 3开始有任何值，呃。

s 0和s 1之和将覆盖s 3中已经存在的内容，所以取而代之的是，如果我们不把3等于零，如果我们三等于三等于零，那我们就得排队了，是呀，是啊，是啊，因为这意味着你会假设s3等于零，因此。

我们将继续我们的下一组指令，其中涉及控制，控制的主要思想是，通常在一个，在正常的五险功能中，你会看到，呃，按顺序执行的指令，什么，如果您想确保在某种情况下跳转到不同的指令，或者您想跳转到另一个函数。

它位于程序计数器中，这不是立即，这不像你目前正在使用的指令旁边，这就是控制的用武之地，然后我们有两种不同的控制函数，所以我们有一个分支，它非常类似于，有点像，if else语句，然后它，它会。

分支实际上会工作，它会跳到，呃一个P，它将跳转到一台新的PC上，如果，如果满足条件，所以，例如，我们这里的分店指示是B E Q B G，B g e u d l t和B o tu，所以BQ会分支会去。

标签指向的任何东西都将流向PC，如果RS是1等于，如果rs1的值等于rs2的值，然后对于bge，如果rs 1大于，它就会分支，或者rs1的值大于或等于rs2，然后为了一个BG U，它是，这是一回事。

但它对待中间人在第一和第二我们没有签名，对英国电信来说，它是否会分支，如果rs是1小于rs 2，然后BTU是一样的，除了它假定存储在rs 1和rs 2的即时数据是无符号的。

然后我们有我们的跳转和链接指令，即无条件跳跃，意味着无论发生什么，不管什么情况它都会跳，它将R rd值设置为PC加4，原因是如果我们决定以某种方式跳跃，如果我们决定跳转到另一个函数设置。

Rd到P C加4将保证，如果我们决定跳回我们返回中存储的任何东西，在我们的退货地址寄存器中，当我们跳到那个，它就会变成p等于4，然后耶，它跳到标签，有两个和伪指令存在于。

当我们不需要下一张幻灯片的链接时，我们将更详细地讨论这一点，所以我们有j标签，它等价于凝胶x零标签，这意味着您将跳转到另一行代码，但你不在乎你从哪里来，你只是要去另一个地方，然后是jr x 1。

也就是jer x 0 um，然后让我先看看凝胶和乔，所以通用电气正在加入链接，所以它把我们的rd设置为p c加4，然后它将我们的PC设置为PC加偏移，偏移量是我们标签上指定的。

然后我们有Jer Rd Rone和M，所以rd再次设置为pc+4，但在这种情况下，是啊，是啊，我是说，啊，好啦，所以一台电脑而不是我们的Jer，我们假设我们的回信地址存储在我们要去的地方的A中。

存储在寄存器中，所以我们的电脑将被设置为RS 1加上媒体，是啊，是啊，是啊，是啊，嗯，你提到当指示，呃，喜欢吗？因为那个指示无关紧要，你来自哪里，或者当你知道来自，是啊，是啊，哪里。

但这和这些有什么关系，我是说，它不是开始利用目标，就像我来自哪里，因为有些情况下你需要跟踪，你来自哪里，因为在我们的凝胶教学中，我们有一个RD，如果我们想知道，如果我们想回到我们来的地方。

或者继续从那里走下去，我们实际上必须在我们的RD中存储我们想要的任何价值，这样我们以后就可以跳回它了，如果我们不在乎它从哪里来，Rd简单地设置为x零，我们看到的是一个重要的，你从哪里来，它会自动跳回来。

开始，是啊，是啊，所以嗯，这是假设你要去的地方你的新风险五标签，它有一条指令跳回存储在rd中的地址，嗯，那样的话，难道这不重要吗？无论你来自哪里，因为你无论如何都可以引入跳回标签，就是说。

你总是可以用嗯来结束电话，你知道跳回标签，然后再回去，因此是真的，但又一次，这取决于你的rd是像一个实际的寄存器还是x零，如果是x 0，我们不能修改它，所以我们叫它，我们不在乎你来自哪里。

因为我们不会再回到，我们从哪里调用函数，这有道理吗，你能解释一下，好啦，是啊，是啊，所以凝胶，我们指定rd，呃好吧，其实呢，这两个罐子和罐子是一样的，但是，但最重要的是这是一个相似之处，但不同的是。

在凝胶中，我们提供了一个标签，这几乎是一个即时的，然后我们做的是，我们设置PC将等于PC加偏移量，但对狱卒来说，我们指定了一个寄存器，它将程序计数器的一部分存储到我们要去的地方。

所以我们要做的是把我们的PC设置为rs 1，加上即时，如果有道理的话，就像你在指定一个寄存器，你想去杰里，但你没有，你几乎不需要为凝胶指定任何寄存器，还有其他问题吗？所以你不在乎回来，如果你专门用像零。

当我们看下一张幻灯片时，它会更有意义，下一张幻灯片，所以呃，几个学期前我做了这个幻灯片，这是呃，这就说明了JZhao Jer和JR的区别，因为它们看起来都很相似，但他们也都很不一样，所以嗯，在我们有。

呃，J和凝胶，这将假设我们的标签是提供的，但是我们想用JJ，如果我们打完电话后不想回来，因为j等于gex零，如果我们打完电话后想回来，我们必须使用地理，嗯，因为凝胶凝胶，如果我们只写凝胶。

这相当于凝胶或，这意味着我们的回信地址存储在我们的寄存器中，然后在新的，然后新的标签，你跳到那里，如果有一个登记册上写着j r r a或类似的东西，我们可以回到收银台，好啦，然后呃。

我们有jr和jer的区别，所以主要的，所以现在我们正在使用一个实际提供的寄存器，现在我们得考虑打完电话后是否不想回来，或在通话后返回，所以在这里的情况下，嗯小J几乎等于杰鸡蛋零，我相信呃等于罐子，是零。

我想是的，它在，这是一辆参考车，嗯对于那些好奇的人来说，但是是的，我是，我是对的，是一个罐子x零，或者我不知道，我在试句号，好啦，哎呦，你有一个问题，是的为了确认黄金的归还，仅在风险文件的上下文中。

向右跳跃，是呀，你可以在翻译中说，我可以晚点再看，我正在打回复，我没有，哦不用担心，好啦，然后Jer几乎是假设我们在电话后回来，然后我们的寄存器就提供了，我相信这等于罐子，这个，我相信不要相信我的话。

但我相信这等于贾勒，R a然后什么的，然后你就有了你的任何登记册和即时，我想真正明确的，对用户来说有点不必要，你只需要想想我是不是要跳到一个标签上，把范围缩小到两条指令。

我是不是跳转到一个存储在寄存器中的地址，把范围缩小到另外两个，是啊，是啊，想想你所拥有的，你需要去的地方，好啦，有人对此有疑问吗，是呀，那么我们的，正如我前面所指出的，A是寄存器。

我们三个两个寄存器中的一个，通常A是用来存储我们的回信地址的，如果我们决定，呃，就像跳出来，就像储存我们的RD，我们可以解决，是啊，是啊，几乎是商店，呃，在我们执行完我们的新函数后，我们想回到哪里。

我想回到艺术上，是的通常你会做的，如果你想回医院，我们会用JR RA，这相当于一个叫做rat的伪指令，但就今天的讨论而言，这个Jr a很重要，还有其他问题吗？有一件事我想指出的是，任何直接的，那就是。

在任何跳转指令或分支指令中，是到达下一条指令的偏移量，不是实际的，嗯指令地址，期中考试有个问题，关于期中考试，我把它解释了，我把它，就在考试结束前两分钟，然后我意识到，哦等等，是偏移量。

所以我就像匆匆忙忙地计算，两者的互补，就像，我觉得是负2 4之类的，我没有足够的时间做这件事，一个非常，呃，分支和控制指令的良好使用通常是如果我们想循环，这方面的一个例子就在这里。

所以这里的通用代码是bg e x11x13dun，所以从字面上看，这意味着如果x11，如果x11处的值大于或等于x13处的值，然后我们跳到其他地方，如果我们不，如果我们不跳，我们要做的是把9加到。

我们会把4加到x9，然后我们把1加到x上，我们会在x11上加一个，然后我们简单地调用j循环，这样我们就可以回到循环的开始，继续下去，直到我们到达分支指令，然后在我们完成后跳转完成，是呀。

你需要像杰伊·莫托一样，如果你没有j循环，自动转到标签完成，或者你需要叫什么，简，呃，它会自动完成，好啦，在汇编代码中记住，我们逐行执行，从字面上看，然后耶，如果你想在编码中跳来跳去，明明白白的说。

你需要在公园里写什么吗，嗯，通常在我们想遵守调用约定的情况下，这是完成的标签，退出标签通常用于恢复我们的寄存器并获得我们的RA，如果我们决定拯救它，然后我们一般地跳回来，是啊，是啊，所以对R R A。

通常当我们开始召集会议时，那就更有意义了，还有其他问题吗？这是风险五如何使用的第二个最重要的部分，我们要讨论的第一个最重要的部分，在我们做完这个问题之后，这里的这些问题，好啦，在第一个问题的左边。

我们有几个C代码，我们想通过，然后在底部这里，我们有风险五代码，应该翻译回C，去吧，和你的邻居谈谈，如果你得到的代码有点不稳定，为了嗯，为了风险五看，不用担心，有一种方法可以让它变得更简单，是啊，是啊。

你画画的原因，就像这个例子中的j一样，有什么原因，A，嗯，我想就今天讨论的目的而言，我们想强调使用凝胶和Jer，你可以很容易地使用，J，很抱歉有人看了录音，我完全忘了继续录音，好啦。

然后这里我们要做的主要事情是如何做，s 1等于s 1，加一个，正如我前面提到的，等于s 1乘以2，然后耶，我们就是这么做的，作为for循环，那里有，是啊，是啊，等等，你能重复一下我们为什么用。

或者喜欢它的样子，为了下巴，像女孩一样，就像，那是什么来着，好啦，所以呃，像零一样，正如我提到的，相当于J，每当我们有J的时候，基本上意味着我们要跳到任何，我们的任何地址都是由我们的标签指定的。

但我们不一定要储存我们来自哪里，我们不想我们不会储存我们的回信地址，因为我们只想继续这个循环，我们再次，我们不在乎我们从哪里来，我喜欢用这个比喻，呃，对此有什么问题吗，我不知道你有没有提到这个。

但为什么下一个零，哦，是的，嗯，所以记住凝胶会在争论中，我们的第一个论点是一个寄存器，在这种情况下，寄存器就是我们的回信地址，因为它是零蛋，请记住，我们不能在x零寄存器中存储任何东西，它总是被设置为零。

所以这就是为什么，呃，当我们做凝胶像零，我们有点忘了，事实上，我们是从这里来的，我们把这个寄信人地址，好像那是我们遗忘的方式，我们从哪里来，我们不存储回信地址，是啊，是啊，为什么不说，简，是啊，是啊。

我们也可以说j循环，它等价于jx零，是啊，是啊，Jo就像一个双手伪指令，是呀，J jr是伪指令，连接得怎么样，你不能用它们，只是如果你在原始风险五代码中看到它，它会被翻译成像零或乔尔零这样的凝胶。

这就是发生的事情，是呀，你可以在金星上看到这个，对就像实际上，是呀，嗯嗯，如果你写得像j循环，然后你把它组装在金星上，你会看到的不仅仅是Jagzero，但你也会看到，我相信你会看到实际的，呃。

存储循环的偏移量，就像你是一成不变的，即使你是，嗯，他们实际上是继续通过它，不会抛出错误，数据路径的结构是这样的，所以任何东西都不会被修改到外部，不可变，是呀，所以调用函数，你要用其他JA吗，是呀。

理论上你会使用凝胶或Jer，因为如果你只是你，如果你做一些直接的凝胶循环，这几乎相当于说凝胶或循环，所以几乎把我们的回信地址存储在我们的A中，然后我们完成这个功能之后，嗯哦是的，在你们离开之前，嗯。

我们有正常的，呃，反馈表，所以请花一点时间填好这张表，我们真的真的很感激你的反馈，我们可能正在修改我们进行讨论的方式，所以说，那实际上是下周的，是啊，是啊，今天的讨论也将被加载和存储，但是是的。

我们没有足够的时间，我可以问一个，是啊，是啊，所以我是你们第一个，为什么我们有，所以说，我确实想要一种感觉一根树枝，如果他上了，是呀，我们还是去上学吧，如果这不是正在发生的事情，为什么实际上，哎呦。

差不多就这样定了，那只是设定零的一种花哨的方式，零x零零到零，我能不能简单地修改为0到0，随你喜欢添加。

哦耶，你可以做的加载中位数指令。