Minecraft Wiki

除另有声明,转载时均必须注明出处若簡繁轉換出錯,請以遊戲內為準请勇于扩充与修正内容有兴趣逛逛我们的微博沟通交流,欢迎到社区专页需要协助,请在告示板留言

了解更多

Minecraft Wiki
Advertisement
Clock JE3 BE3.gif
此条目需要更新。

条目中某些信息已经不符合当前版本情况。

此条目的内容需要改进。

这些内容因翻译质量较低而违反或未达到条目标准
你可以帮助我们来改进此条目。

Ic translate.svg
此条目的(部分)内容需要翻译。

你可以帮助我们来翻译此条目,但请勿使用机器翻译

本文旨在探讨Minecraft中计算系统的设计和实现。

第一节, 建造一台计算机,这是一个关于如何在Minecraft中建造计算机以及如何扩展与改进的详细教程。不需要读者了解大量的计算机科学方面的知识。尚未完成

第二节, 红石计算机的规划,提供了在Minecraft中设计与理解一个红石计算机的基本概念。不需要读者了解大量的计算机科学方面的知识。

目录

概述[]

计算机促进了人们通过编程与其交流的想法的实现。

这篇文章将会为在Minecraft中设计与建造计算机打下基础,假定读者相当熟悉红石并且有基本水平的计算机知识。

 事实上在不了解计算机是如何工作的情况下是无法建造计算机的。此教程旨在解释你需要知道的所有内容,但也确实需要一点对计算机科学的了解。涉及的最深层次达到IGCSE[注 1] CS(计算机科学)。

所有的计算机系统都至少有一个处理单元。在运行时,处理单元执行存储在计算机内存中的指令。为了在Minecraft中建造计算机能有一个良好的开始,你应该学习计算机科学。有非常多的资源与教程可以用来学习计算机科学,但是推荐观看Crash Course on Computer Science作为入门课程,尤其是1-8节。尽管它不够透彻,但其内容可以作为你理解计算机的基础。

在Minecraft中,大多数计算机是由红石粉红石火把以及红石中继器组成的,以引起黏性活塞或者红石灯的变化。 它们被一系列的按钮拉杆压力板等等所控制。另外一些方法(本文没有涉及)利用了漏斗矿车与红石。

第一节 建造一台计算机,这是一个关于如何在Minecraft中建造计算机以及如何扩展与改进的详细教程。不需要读者了解大量的计算机科学方面的知识,因为教程会对其进行解释,但是会深入研究。

第二节 红石计算机的规划,提供了在Minecraft中设计与理解一个红石计算机的基本概念。不需要读者了解大量的计算机科学方面的知识,因为教程会对其进行解释,但是会深入研究。

实现[]

计算机与计算器的区别在于计算器在没有用户输入时无法连续执行复杂的指令,而计算机可以连续比较并处理指令来完成任务。计算机可以被用在很多方面,从创造一个智能房屋到运行一张冒险地图。但是,由于Minecraft对于计算机的限制(将会在后文说明),它们仍然只是个抽象概念,但也是理解CPU结构与嵌入式系统的良好工具。

由于Minecraft中的红石计算机非常慢并且臃肿,很难为它们找到实际应用。即使是最快的红石计算机也要花数秒来完成一次计算,还有着数千方块大的体积。因为命令方块的速度快且有着清晰且高级的指令,所以它们相比于红石计算机有很大的优势。

有一些Mod可以改变计算机的速度,比如TickrateChanger能改变游戏刻速率。

第一节 建造一台计算机[]

介绍与条件[]

红石的逻辑紧密地反映了二进制逻辑,应为红石可以是激活或非激活的,可以被解释为0或1.在本教程中,我们将提到基础的二进制逻辑与众多简单的计算机科学术语。这里有一篇文章,很好地解释了二进制以及如何转化到二进制。请读Architecture of the Computer一章节,因为接下来我们对于计算机的设计是基于此的。

这一章会关注于知识的运用与红石的操作,以来创造一台简单的8位计算机, 并且会解释如何建造以及它是如何工作的。

所有的主题被分为了(理论)与(实践)两部分。理论部分会深入解释会发生什么,而实践部分会说明如何在minecraft中建造,它应该是什么样子,以及可能的存档。

在Minecraft中,为了让你的红石计算机最适合你手头的任务,需要有以下三个主要的设计目标。而有些得失需要进行考虑,比如当计算机的规模越大时,运行速度就会更慢,因为红石中继器的数量会随着距离的增加而增加。越多的内存,意味着速度就越慢,体积越大。

紧凑程度

这台计算机的规模有多小?在Minecraft中,设计一台生存模式的计算机很大可能会强调这一点。所需的重复次数将随着大小的增加而增加。

内存大小

它能容纳多少的内存?它可以计算多少数字和字节?这对于大规模的计算机来说是很重要的,如那些可以完成更复杂算法和更大规模指令集的计算机(例如说,计算平方根或是三角学)内存大小或者位体系结构越大,计算机越复杂。

速度/性能

它能以多快的速度执行操作呢?它是否达到了最大优化的程度以执行工作呢?使用定制设计构建一个计算机可以将更多的任务和分配给硬件,从而大大地提升计算机的性能。这在现实世界中的某些超级计算机中表现得很明显,这些超级计算机可以非常高效地进行一些操作。Minecraft中的红石计算机速度是非常慢的,一些模组,例如 TickrateChanger 可以更改Minecraft游戏客户端的游戏刻速度,以提高计算机速度。

MASIC计算机[]

我们将在本教程中制作的计算机拥有8比特、16字节的内存。我们将要制作的输入输出系统是一个七段的数字显示器(以显示十六进制数字)和一个控制面板。

7-segment display

MASIC计算机旨在成为一种适合所有人的计算机,并且不专门从事一项任务,因此它可以通过读取其自己的内存进行完全编程(在第2节:指令集中进行了说明)。 简单的I / O非常适合多种用途,并且存储器大小足够。 它以相当快的速度运行(由于其体积小)。

步骤1:内存和地址解码器(理论)[]

解码器将二进制的数字转换为小数。例如,看着8位解码器,00点亮代表0的第一个灯。01点亮代表1的第二个灯。10点亮第三个2的灯。11点亮最后一个3的灯。

步骤1:内存和地址解码器(实践)[]

地址解码器[]

0000 0000(注意第一条输出已亮起)

0000 0001(注意第二条输出已亮起)

0000 0010

0000 0011

这是我们要构建的地址解码器的设计。

B.png C.png

上面是一个简单的2位状态,因此它有两个通过中继器的输入(左和右)。 输出是红石线,在上面的红石线将在满足状态时关闭。状态是红石输入是否会关闭上面的红石线; 如果是,则状态为红石输入。 在上述情况下,必须将左侧的OFF(0)断开,将右侧的(blue)接通(1)才能在顶部的红石线上产生OFF。 因此,它期望状态为OFF ON(又称二进制01)。

它们的颜色为蓝色,应设为ON(1),以便停止为顶部的红石线供电。 一旦每一位停止为红石线供电,然后将其关闭。

这些基本上是一个或两个非门馈入或门,然后是非输出。


Screenshot 2019-07-15 at 10.19.28 am.png Big not.png

上面是一个8位状态,它期望8个输入的顺序完全是00001101。所以它期望的状态是00001101。所以红石火把为输入供电,所以我们看到顶部的红石线变为OFF(仅当精确地按照0000 1101的顺序放置三个红石火把时)。

现在,如果将它们中的多个放在一起,我们就可以用蓝色位以二进制数进行计数,以获得8位的所有255个状态。 下面的一个是8位,并具有四个状态期望。 查看正确的图像以查看实际效果。 现在,每个绿色输出可以是一个存储单元,如果我们继续以二进制进行计数,它将达到255。

Screenshot 2019-07-15 at 10.30.13 am.png

输入为0000 0011(有关输入,请参见红石火炬),蓝色位与当前状态匹配时,绿色输出为ON。

  • 0000 0000-第一个信号输出(在右侧的图像上)
  • 0000 0001-第二个信号输出
  • 0000 0010-第三个信号输出
  • 0000 0011-第四个信号输出

因此,现在我们继续以二进制数进行计数,直到0000 1111并停止在此为止。 现在我们应该有2 4 (16)个状态期望值,这就说明我们完成了地址解码器。由于指令集的局限性,我们不会继续计数到1111 1111,如第3节所述。

步骤2:构建算术逻辑单元(理论)[]

称为ALU的算术逻辑单元将比较并执行带有二进制数的数学运算,并将结果与控制单元,计算机的中央组件(和中央处理单元)进行通信,但它将与计算机本身一样大 )。 许多教程都希望读者首先构建ALU,因此该主题在Internet上被广泛涵盖。

我们将要构建的ALU可以在两个输入上执行四个重要操作,并返回正确的输出。 A,B均为8位输入

  • A + B(将A添加到B)
  • A >>(右移位(与二进制除以2相同))
  • << A(左移一位(与二进制乘以2相同))
  • 不是A(与A相反)

由于某些程序需要大量操作才能运行,因此计算机内部还可以有多个ALU,这些操作不依赖于先前的操作(因此可以进行线程化) 因此将它们委派给不同的ALU可以显着加快该程序的速度。

二进制加法器

两个数字相加[]

在一个加法单元中,每个位(对于我们的计算机,我们需要四个,因此需要4位),有一个完整的加法器。 完整的加法器将接收三个输入,每个输入可以是1或0。前两个将是用户的输入,第三个将是“进位”输入。 “进位”输入是先前完整加法器的输出,稍后将对此进行说明。 加法器将输出两个语句:首先是输出,然后是“进位”输出,该输出作为输入发送到下一个完整加法器中,即占位值。 例如,我希望将数字0101加到1011。第一个全加法器将把第一位的值1和1作为它们的两个输入(我们从右到左阅读)。 由于之前没有完整的加法器,因此没有“进位”输入。 完整的加法器将加1和1; 它是0,并携带1到下一个位置值。 下一个全加器将加0和1,进位输入将是1,这是前一个全加器指出的。 0和1的输出将为1,但进位输入为1,因此将0与1和1相加,即0,并在下一个位值上携带1。 复查二进制文件中的加法应该解决任何混淆。

全加器

为了执行加法运算,所有ALU都需要多个加法器。 每两位将送入一个加法器,与其他加法器连接时,将产生输出,该输出是两个字节加在一起的总和。 加法器具有一个输入,一个输出和两个进位输入/输出,就像执行9 + 1或01 + 01的加法操作一样。加法器由逻辑门构成,这可以通过二进制的命名法实现。 教程/算术逻辑给出了全加法器和半加法器的非常详细的介绍,目前,有一个构造方法的示意图。 它提供四个输入/输出,应与其他加法器连接以创建一个单元。 对于此示例,我们将在四位计算机中将四个加法器连接在一起,以便我们可以将所有四个位都取为输出。 第一个加法器将缺少输入进位,这是因为之前的位(第一位)没有任何进位。 输入进位将保持为零。 第四加法器还将缺少输出进位,并且由于我们只能支持四个位,因此将忽略该输出。 附加的第四个进位输出连接到溢出标志,表示无法完成该操作。 这称为二进制溢出。

因此,基本上,进入Minecraft并构建一个完整的二进制加法器(如图所示)并将其连接起来。 应该有八个输入和输出。 尝试将杠杆和红石灯分别放在两端以测试您的创作。 因此0010 + 0011应该产生0101(2 + 3 = 5,我们读的是右而不是左)。

分数数字[]

计算机通过浮点算术的形式处理小于1的数字,仅在较大位计算机(16-64位)和需要使用小于1的计算机中有用。 Floating-point arithmeticarbitrary-precision arithmetic 有两种方法可以实现此目的。另一种更简单但效率较低的方法是为所有数字分配2的幂,以使它们被选定的2的幂“累加”。 玩家必须对每个数字都执行此操作,并假设该数字是您选择的两个数字的幂的一倍。例如5 = 101 2 ,因此5×2 3 = 101000 2 ; 五被三撞了。 因此,现在,新系统中的值为1×2 3 = 1000 2 ,这将为0.1、0.01或0.001留下空间; 0.01 * 2 3 = 10 2 。 这将导致您的计算机设置更为复杂。

减去两个数字[]

一个全部带正负符号的加法器(加减混合计算元件)

数字减法非常简单。 ALU首先必须更改第二个数字(该值减去),然后将其从正数转换为负数。 二进制补码是当您反转二进制数(以便所有0均为1且1s均为0)并将其加1时。 示例:10减去9

1. 0000 1001 (二进制为9,我们希望为-9,而不是9)
2. 1111 0110 (将9取反,以便所有0均为1,而1均为0)
3. 1111 0111 加一(这是9的二的补数)
4.
0000 1010 (二进制10)
+1111 0111 加2的9的补数(aka -9)
----
0000 0001 结果(10 +(-9)= 1)(存在溢出,这仅意味着结果不是负数)

这带来了带符号数字的复杂性。这是对二进制数字的权重,将其分配为正数或负数。 结果是负数还是正数由溢出标志确定。 如果有溢出,则表示数字为正,否则为负。

两个数字相乘[]

乘法是重复加法,因此最简单(效率低下)是将A加到可变B的次数上。

这是它的伪机代码

  • C = 0
  • D = 0
  • (Set A to) << A (bitshift A to the left)
  • JUMP IF (BIT (D) OF B == 0) TO LINE 6
  • (Set C to) C ADD A
  • (Set D to) D ADD 1
  • JUMP IF (D < LENGTH OF B) TO LINE 3
  • RETURN C

不要忘记:

<< A (bitshift to the left) is effectively, A * 2

and

>> A (bitshift to the right) is effectively, A / 2

假如这些数字是唯一确定的或者CPU必须做大量的相似数字处理,可以考虑使用一个可查的穷举表来加快频繁的计算,这也是乘法。这通过硬编码的方式来得到你的答案,推荐在极端情况下使用。

1bitALU-layer0-6.png

步骤2:构建算术逻辑单元(实践)[]

步骤3:指令集和机器结构(理论)[]

对于我们正在建造的MASIC计算机,有一个8位的系统,所以这意味着在堆栈内存的每个插槽上的每条指令都是8位。堆栈内存是存储任何信息并存储在RAM中的内存。所以将会有一个计数器,称为程序计数器,它每周期递增1次。循环是指CPU获取指令,解码指令(找出该指令该做什么)和执行指令(执行它让它做的事情)。然后,通过递增程序计数器并在堆栈内存中读取位于该位置的信息,移动到下一个程序计数器。

因此,堆栈内存中的每个字节都有8位供我们使用。有些指令需要一个地址,比如将内存加载到寄存器中,这样我们就可以对其执行操作。每条指令将被分成两部分,每部分4位。第一种是类型。类型将指定计算机必须做什么,地址将位于我们将执行操作的值所在的位置。

操作码/操作数

凭借这个4位数据组,我们可以有24种操作码,即代表16种不同的操作。我们的电脑将有两个寄存器,所以因此操作码的一位用于指定操作将在其上执行的寄存器,并在下文用x表示。

指令与内存将被放在同一位置,由于指令的地址部分只有四位,我们只能从1-16行引用内存,需要一些巧妙的编程来适应更大的程序。每个程序的内存也限制为16字节。值和指令本质上是相同的,因此,如果您编写一条指令将其存储到先前存储指令的行上,这将有效地用一个值覆盖该指令。

意外执行值是一个问题,因此必须设定并使用STOP命令来防止任何错误。这需要理解的东西太多了,所以自己去找找基础教程吧。 另外,不要忘记为您的IGCSE同时使用客户端/服务器端和信息和通信技术。

必要条件[]

本节将介绍计算机中常见的简单主题和组件。 看懂下文你需要:看懂第2章中的信息,如ALU、RAM、寄存器和二进制操作。

MASIC指令集[]

因为这里的计算机是指令集的草稿,只有基本要素。这是基于其他汇编语言的,但经过更改以适应我们的体系结构。有两个寄存器,所以我们需要指令在两个寄存器上执行操作。

二进制码 操作码 效果注释
0000 LOAD R1 将地址加载到寄存器1中
0001 STORE R1 将寄存器2的内容存储到该地址中
0010 JUMP R1 IF Jump to line ADDRESS if register 1 is equal to 0
0011 ADD R1 将地址处的内容添加到寄存器1
0100 <<R1 在寄存器1中向左移位
0101 NOT R1 按位非寄存器1(对寄存器1按位取反)
0110 JUMP Jump to line OPERAND
0111 STOP 终止程序
1000 LOAD R2 将地址加载到寄存器2中
1001 STORE R2 将寄存器1的内容存储到该地址中
1010 JUMP R2 IF Jump to line ADDRESS if register 2 is equal to 0
1011 ADD R2 将地址处的内容添加到寄存器1
1100 <<R2 在寄存器2中向左移位
1101 NOT R2 按位非寄存器2(对寄存器2按位取反)
1110 OUT R1 输出寄存器1
1111 OUT R2 输出寄存器2

解释:

1000 0011表示将地址3的数加载到R2寄存器,因为1000为加载到寄存器2中,0011为3。

这些可以在一个过程中进行,以便可以执行功能。

编写程序[]

这个做斐波那契序列:(0,1,1,2,3,5,8……)

斐波那契
指令行数 二进制指令 实际指令 注释
1 0000 1110 LOAD R1 14 将寄存器1设置为0(第14行的值)
2 0011 1111 ADD R1 16 在第16行添加值
3 1110 0000 OUT R1 输出寄存器1
4 0001 1111 STORE R1 16 将其放入第16行
5 0011 1110 ADD R1 15 在第15行添加值
6 1110 0000 OUT R1 输出寄存器1
7 0001 1110 STORE R1 15 将输出放回原处
8 0110 0010 JUMP 2 我们不必重置寄存器,因此我们循环回第2行
...
14 0000 0000 0
15 0000 0001 1
16 0000 0001 1

前面是低级汇编语言的一个例子。如果它是用高级语言编写的,比如C++,它看起来更像是这样:

#include <iostream>
using namespace std;
int main()
{
    int n, t1 = 0, t2 = 1, nextTerm = 0;
    cout << "Enter the number of terms: ";
    cin >> n;
    cout << "Fibonacci Series: ";
    for (int i = 1; i <= n; ++i)
    {
        // Prints the first two terms.
        if(i == 1)
        {
            cout << " " << t1;
            continue;
        }
        if(i == 2)
        {
            cout << t2 << " ";
            continue;
        }
        nextTerm = t1 + t2;
        t1 = t2;
        t2 = nextTerm;

        cout << nextTerm << " ";
    }
    return 0;
}

Instruction Cycle[]

Rounded squares are components, squares are registers. Green arrows are busses

The instruction set is the lower assembly language, so we want to integrate that more with the hardware side. This revolves around the fetch-decode-execute cycle (explained above). In the CPU, there will be 4 important registers,

the Program Counter (PC), keeps track of which program the computer is currently on

the Memory Address Register (MAR), keeps track of where the next memory location will be

the Memory Data Register (MDR), keeps track of what the memory AT the location is

the Current Instruction Register (CIR), keeps track of what instruction is currently being worked on

and the ALU Accumulator (ACC). keeps track of the input and output from the ALU

There are also four components to keep in mind, the Address Decoder, the memory, the Instruction Decoder and the ALU.


FETCH The program will get the next instruction.

  1. PC sends the instruction number to the MAR
  2. PC increments by 1, to prepare for the next instruction
  3. Address Decoder decodes the address, and requests information at that address from the memory
  4. MDR receives the requested information (in the case of the picture, if the MAR is 0001, it receives 'LOADR1 1')

DECODE The program will identify what the instruction is

  1. CIR receives the information from the MDR, through the information flow
  2. Instruction Decoder decodes the instruction and what to do

EXECUTE The program will execute the instruction

  1. In the case of the picture, the program receives 'LOADR1 1' as the instruction, the Instruction Decoder splits the instruction up into the opcode and the operand.

The opcode is 'LOADR1' and the operand is '1'.

  1. Operand is sent to the MAR, to get the information at that address
  2. MDR receives the information at that address (in the example, it is the same line)

Now four things could happen depending on what the instruction is.

If the instruction is an ADD instruction, the ACC will be told to receive the information from the information flow and the ALU will perform operations on it, outputting it to the ACC again.

If the instruction is a LOAD instruction, the CU will load the instruction to the register.

If the instruction is a STORE instruction, the CU will instead SET the data at the location specified by the MAR in the memory.

If the instruction is a OUT instruction, the CU will send the instruction to the output peripheral.

REPEAT The instruction cycle repeats itself until it reaches a STOP instruction or runs out of memory

步骤3:指令集和机器结构(实践)[]

第二节 红石计算机的规划[]

红石计算机可以像真实计算机一样运作,遵循计算机设计和硬件架构中的原则。有几个关键的设计决策会影响架构;你对计算机预期的大小和功能应该在构建部件之前具体确定。 Building a redstone computer will require an understanding of these five concepts and consider the most suitable approach, which would be most practical for your computer.

一些事情需要考虑:

  • 执行模型(内存的计算机组织与程序存储和执行)
  • 字节大小(信息的大小,你的红石计算机用这些执行命令)
  • 命令集(红石计算机的一个结构)
  • 内存大小(数据可以存储在内存中,可存储数据多少取决于内存大小)


有一个选择决定将提供强有力的指导在各种组件的设计你的电脑。

and we will be applying this knowledge and plan the architecture of our CPU in the last section. This CPU will then be built in the next chapter.

Fundamentals of a Computer[]

A computer is a machine which has the ability to

  • Read and write from a memory which can be addressed
  • Perform comparisons on the state of the memory, and perform an operation as a result of that. These operations include rewriting memory.
  • Start functions based on content written in the memory. We call such content "programs + data", and the act of writing them programming.

A very notable example of this is the most basic concept of computing, a Turing machine, where the machine will read from one infinite line of code and instruction set in order to complete a function.

Designing and building a Turing machine in Minecraft is possible. This however, is not covered as we will be designing something more basic.

Machine-Architecture[]

There are five fundamental components in a basic modern computer. These are essential in order to produce a functioning computer and manipulate data by performing computations.

five components of a computer

Arithmetic Logic Unit (ALU) (optional, but is normally present)

  • Perform adding and subtracting
  • Compare booleans using logic gates

Control Unit (CU)

  • Perform/Execute instructions sent to it
  • Communicate with all components

Data Memory

  • Store and return data from memory

Instruction Memory

  • Return instructions, sent to the CU
  • Can be set, but doesn't need to be as often as the Data Memory

Input/Output devices (I/O)

  • Allows the computer to communicate with the world and the player.
  • Can input information the computer (button push, daylight sensor)
  • Can output information from the computer (redstone lamp, note block)

Computer Data Storage[]

There are many methods of storing data, in Minecraft or in real life. The states of memory usually are binary, either on or off and can be computed with boolean logic.

On a computer, there are three types of storage. Keeping in mind that increasing the device's capacity would increase its size, each type would have speed and capacity appropriate to it.

Primary Storage[]

These are the storage which directly accessible to the CPU, referred to as memory and is fastest to access but usually is smaller in capacity for it to be addressed quicker.

Registers & Flags[]

Fastest is the memory stored within the CPU. These are registers and flags as they can be set almost instantaneously and do not require any address sent to it as there is only one byte stored in each register. Redstone bits that can be toggled are extremely large but can be toggled within 2 ticks. This requires a very large amount of space but is perfect for caches and registers. The redstone is also required for logic gates (not shown) to set the bit, as in the images, sending an input would cause the bit to flip. The gate would take up more space. Registers could also utilize locking redstone repeaters and timing them correctly. This is explained below, in RAM). With the use of a computer clock, it may not be necessary to build registers. Registers are useful when the data goes through the line before either the CU or ALU is ready to process it. It would save it to the register and wait until the CU or ALU can perform its function.

A Bit made with Sticky Pistons A Byte made with Sticky Pistons

Caches[]

Second to those are caches, which feed information into the processor. In real life, they are separated into levels, each one with separate speed and capacities. It is useful for the same reason as the registers.

Random Access Memory (RAM)[]

Thirdly is Random Access Memory (RAM), this is much slower than the caches and registers as they have address systems. They are connected to three busses, data bus, control bus and the address bus. The data is sent through the data bus, either setting the RAM or getting values from the RAM. The control bus tells it whether it is being get or set. The address bus tells the RAM where the byte is. Refer to the Architecture of the Computer to understand this more in-depth. RAM is very useful and could fully replace tertiary memory (explained below) because of its non-volatility in Minecraft. Volatile means that when power is lost, it will lose information. The RAM will not lose information unlike in real life, and therefore in an excellent method of storing information.

The RAM in the first case is utilizing the locking redstone repeaters with the correct timing. This requires a bit of a plan but is very space-efficient. The conversion of a bus to the lines in order to lock the redstone repeaters also requires setting timings. This is time-consuming, much more than the registers, however, it is very compact and efficient. The address bus (green) would turn in binary to unlock a certain byte, either to be read or set by the control bus (second line, on the left).

RAM with Timer Component

Most often, making it volatile has no use in Minecraft, so the easiest way to make some is to use d-flip-flops and to add a reading and writing function. The bottom image shows instead of locking repeaters, it uses d-flip-flops which is much more space inefficient but simpler to build. D-flip-flops work more or less like locked repeaters, one input - if on, unlocks in until the input is off and the other will set it once unlocked. The output can be read as a bit and with a NAND gate, be ignored or put onto the bus. This is gone over in detail in the second chapter, Tutorial on building a Computer. Excuse the texture pack.

4byteRAM default.png

Random Access Memory also known as RAM is a kind of memory used by programs and is volatile. Volatile means that when the power is lost, it will lose information. Most often, making it volatile has no use in Minecraft, so the easiest way to make some is to use d-flip-flops and to add a reading and writing function.

Secondary Storage[]

These are equivalent of HDDs and SSDs. There is a very compact storage technique, involving redstone comparators with the ability to store up to 1KB, being practically sized.

Tertiary Storage[]

Third and last, is a tertiary memory, which requires a lot of time to read/write but can hold massive amounts of information at the expense of speed. Real-world tertiary storage use a mechanism of mounting the memory which takes about a minute for each drive. This is used for archival purposes and for memory which is rarely used. In Minecraft, a system where shulker boxes are used and block in the shulker boxes must be sorted out by a sorting system to represent a form of data. This can also be used to create removable storage. The read/write speed is fairly slow due to the massive amount of comparators and a lot of time is required. The aforementioned mods could speed up tick rate and eliminate this problem, however. This is used for storing long-term data that needed to be loaded at the beginning of a program or rarely due to its poor read/write speed and large capacity. This is the equivalent of a real computer's hard disk or solid-state drive.

执行模型[]

命令存储块的技术叫做程序在内存是允许计算机同时执行各种不同的任务。使用的设备由计算机来存储和检索这些程序是计算机的执行模型。世界上最成功的两个执行模型,哈佛和冯·诺依曼,今天将近100%的可用的计算机上运行。

哈佛结构[]

The Harvard architecture 检索器分离的命令组成一个活跃的程序从数据访问器的程序在执行期间访问。   编写的程序对电脑使用哈佛架构可能执行的任务达到快100%访问主内存总线。但是要注意,哈佛架构的某些记忆电路体积会很大。

冯·诺依曼结构[]

The von Neumann architecture使用一个两步的过程来执行命令。首先,加载内存包含下一个命令,然后新命令加载是允许访问相同的内存,因为它执行,使用一个内存的程序和数据促进元编程技术像编译器和自我修改代码。    冯诺依曼体系结构是第一个提出模型的计算和几乎所有真实的计算机是冯·诺依曼在《自然》杂志上。

位宽与指令位数[]

位数大小是计算机物理尺寸的主要因素。 在Minecraft中,从1位一直到32位的机器已经被成功构建出来。 常见的字大小的组合:

数据 命令
4 8
8 8
8 16
16 16

数据字符[]

计算机在任何特定时间可以操作的信息量代表了计算机的数据字大小。

在数字二进制中,计算机的数据字大小(以位为单位)等于计算机主总线中通道的宽度或数目。

数据字通常表示整数,或编码为二进制数字模式的整数。

最大大小的数量可表示的二进制整数编码是2 ^数据字宽度在位- 1。

一些常见的整数数据大小是:

最大可表示的数量 所需的字节数
1 ( 2 ^ 1 - 1 ) 1
7 ( 2 ^ 3 - 1 ) 3
15 ( 2 ^ 4 - 1 ) 4
255 ( 2 ^ 8 - 1 ) 8
65535 ( 2 ^ 16 - 1 ) 16
4294967295 ( 2 ^ 32 - 1 ) 32

数据字大小还决定了可以由计算机的ALU(算术和逻辑单元)处理的数字的最大大小。

命令字[]

计算机完成一条命令所需的数据量代表计算机命令字大小。

计算机的命令字大小通常是其数据字大小的倍数,这有助于在程序执行期间检索命令时最小化存储器未对准。

Instruction Set[]

This is a collection of instructions the control unit (CU) can decode, and then execute.

Instructions are essentially functions run by the computer, examples of instructions include:

  • Add, subtract, multiply and divide
  • Read/Write from RAM/ROM/tertiary memory
  • Load and unload data into the RAM
  • Branching to other parts of the code
  • Comparing registers
  • Selecting a logic function (NAND, NOR, NOT etc.)

Instructions can be programmed into the RAM, loaded from ROM or directly activated by using a lever or button. Each instruction would have its own specific binary string assigned to it (e.g. 0000=Load data from register 0001=add A and B 1011=Save RAM into tertiary memory etc.) and would probably require its own binary to decimal or binary to BCD to decimal encoders and buses to the ALU/registers.

Architecture of the Computer[]

Inside the computer, there is a Central Processing Unit (not to be confused with the Control Unit (CU), a component inside the CPU), which in real life, is a very small and powerful component that acts as more or less, the brain of the computer. In Minecraft, it is difficult to compact it to the scale we see in real life so don't worry if it looks wrong.

We will first be designing our 4-bit Central Processing Unit in the next chapter, as it is the most important thing in our computer with the Execution Model (the method of communication and organization of the CPU) in mind, (talked about in this page, before, in the Execution Model section) we can map out the construction of the computer.

Map of the CPU, based on the Havard Execution Mode

The CPU follows a cycle four steps, fetch, decode, execute and (sometimes) stores to perform instructions. The CPU first fetches the instruction from RAM, decodes what it means (the instruction will most likely be a number, and the CPU must find out what number it is), and once it understands what the instruction is, it will perform that action. This sometimes requires the data to be put back into the storage, therefore it will store the data. The cycle is then repeated.

Busses[]

There are five busses in the CPU, each to carry information from one component to the next. Busses are channels of redstone connecting each component. Since we are building a 4-bit computer, we only need four channels in our bus. These are the red and blue lines connecting the components inside the CPU. Notice that the blue buses have less than four lines, this is because they do not carry data. Since busses can only carry data one way (in Minecraft, due to repeaters only working one way), there are two buses connecting the CPU to the outer computer.

The first bus is the data bus, this is to transfer information from the storage or I/O devices to the CU. Instructions are also sent through this line The CU can also use this bus to transfer data to the ALU. The ALU cannot transfer data onto this bus because buses only work one way and once the information is taken by the ALU, the bus cuts off beyond the ALU. Information from the ALU is passed through bus 2.

The second bus is the data bus, but returns the data from the ALU to the CU. The CU cannot send data through this bus to the ALU because the bus goes from left to right and works in one direction only. The CU can send information back to the storage units though, and is used to set values of storage devices.

The third bus is the address bus, which the CU can send the address of storage. This is where the information resides. For example, the CU asks for the address of the byte living in 0001. It sends the address (0001) through the address bus and the RAM will return the value of the byte through the first bus. 0001 is the location of the byte, not the value of it.

The fourth bus is the control bus, which the CU will communicate with the RAM with. For example, one wire could tell the RAM to set the byte to the value to the data sent to it by the CU. Another wire could tell the RAM to get the byte from the address sent to it by the CU.

The fifth bus is another control bus, linking with the ALU, which sends flags from the ALU. Flags are notes which could be error messages. For example, the CU could ask the ALU to add 15 and 1 in a 4-bit system. Adding 15 and 1 in 4 bits would yield 0 (explained above) and this is called a binary overflow. This is an error and the ALU will tell the CU about this through the fifth bus as a flag. The CPU could also send data to the ALU and ask for it to perform an action with that data.

Components[]

Control Unit (CU) will fetch instructions from the instruction ROM (for other computers, instructions can be changed and therefore is RAM. For our case, we are running a fixed program and do not need to change the instructions. This simplifies the process entirely and the instruction is Read-Only Memory (ROM)). Inside the CU, it will then decode the instruction, which is normally a number, into a sensible action. It will then perform that action and if the instruction requires, store the result into the RAM. It communicates with the RAM through the control bus and receives flags from the ALU. It can also ask the ALU to perform actions on data it sends to the ALU (e.g. addition). To communicate with the RAM, for example, one wire could tell the RAM to set the byte (the location of it is specified through the third, address bus) to the value to the data sent to it by the CU through the second, data bus.

Arithmetic logic unit (ALU) will execute instructions sent to it from the CU and will compare binary numbers and communicate with the Control Unit. It can do simple addition and subtraction which can be repeated to do multiplication and whole-number division, outputting a whole number (then division). There are also logic gates for booleans, the fundamental logic gates are required, such as the NOT gate and the NAND gate.

Now we can choose from a range of designs of busses, each contributing to the aforementioned three key designing goals of a Minecraft computer.

第三节 计算机的设计[]

命令集架构[]

状态[]

内存是一系列的位。在Minecraft中,尽管曾经成功创造过32位和64位[1]计算机,但是通常情况下内存占8位或16位。每一位都是两种可能的状态中的一种:开或闭。而内存就是一系列的开和闭,用于完成特定的任务。

信号[]

现实世界计算机使用二进制,一系列的1和0。“1”表示“开”和“0”表示“关”。在"Minecraft,最好的体现是红石:有信号意味着“1”,没有信号表示“0”。然而,根据距离红石从内存存储,它是“0”可以是任何信号强度从0到14。你也可以设计,使“1”信号强度从1到15。

[]

我们常规的十进制是一种以10为基数的数字系统。在电脑中使用的数制——二进制,则是以2为基数。为了比较两者,我们看一下两位数。在十进制中,左边的那一位是十位。在二进制中,则是“二位”。比如在十进制中,“10”表示“十”。而在二进制中,“10”表示“二”。有两种常用的十进制转二进制的方法:

最高位优先:这种方法需要一点直觉。我们以42为例。首先我们找(小于等于42的)最大的2的幂(“2的幂”就是如32 [2^5] 或65536 [2^16])。在这个例子中,是32。然后我们用例子中的数字来减它,42-32=10。那么最左边的一位就是“1”。随后我们继续找下一个2的幂,看它是否小于等于当前的数字。对于这个例子来说,下一个是16,16并不比10小,所以接下来这一位是“0”。一直找下去直到数字为0为止。无论二的幂是小于还是等于当前的数字,都要减掉它,并且记下一位为“1”。否则下一位就是“0”。就我们的例子来说接下来就是 8<10-->10-8=2-->"1" 4>2-->"0" 2=2-->2-2=0-->"1" 1>0-->"0" 因此最终42的二进制表示就是“101010”。不错。

最后是最低位:这个方法不需要记忆许多2的指数。相反,它重复将数字除以2,使用商作为下一个被除数,余数作为二进制位。 但请记住,此方法从右到左写入二进制数,而不是像前一种方法一样从左到右写入。 让我们重用我们的例子,42: 42/2=21 r 0 (最右边的数字是0) 21/2=10 r 1 (向左边一位的数是1) 10/2=5 r 0 (向左边一位的数是0) 5/2=2 r 1 (向左边一位的数是1) 2/2=1 r 0 (向左边一位的数是0) 1/2=0 r 1 (向左边一位的数是1)

商数为0,所以我们停止。 这给了我们二进制数“101010”。与之前的方法相同。

过渡[]

[]
命令[]

功能本质上是由计算机命令构成的,命令的例子包括:

  • 加、减、乘、除
  • 从RAM/ROM/第三存储器的读/写
  • 读取和写入数据到内存
  • 分支的其他部分代码
  • 比较寄存器
  • 计算一个逻辑函数 (NAND,NOR,NOT etc.)

命令可以被编程到内存,从ROM加载或直接通过一个拉杆或按钮激活。每条命令都有它自己的特定的二进制串分配(比如0000=从寄存器加载数据,0001=A加B,等),并且可能需要其自己的二进制到十进制或二进制到BCD到十进制编码器和总线到ALU或寄存器。

归类[]

抽象[]

映射[]

符号[]
数字[]

符号可以用红石灯或者活塞的推拉方块产生凸凹起来显示:

注:如果用红石灯的话不要用黄色的方块做面板,不然不容易分辨。

功能[]

形式化[]

可计算性[]
变量[]

变量是数字、字符串、字符(套)或布尔值(真/假)存储在RAM中的空间。例如,布尔值可以用来保存信息如果程序已经达到某种状态。以下信息需要保存一个变量:名称,类型(数字、字符串或布尔),和变量值。变量,顾名思义,改变。命令操作可以改变变量。在运行程序时创建变量,一旦程序结束,变量值会被从内存中删除。当一个程序重启,变量会被重置。

层次结构[]

内存[]

内存是储存您的程序数据的地方。 它是可更改的 (但它在计算机关闭后将会被删除),它也用于储存您计算机的数据。例如说,在一个从1开始计算的程序中,1就被储存在了内存中,从内存中加载出来的1被添加上原来的1便得到了2。

执行[]

语义[]

数据[]

数据是计算机处理的信息,使用二进制表示。

控制单元(CU)[]

机器架构[]

数据通道[]

Processing[]
算术逻辑单元(简称ALU)[]

1-bit 3 function ALU.png

ALU是计算机最重要的组件之一,在现实生活和Minecraft中。首先,你必须选择你希望能够实现的功能。大多数时候,这些都是加法、减法和一组逻辑选项。

与,或,与非,或者你所喜欢的。你必须建立单位和所有你想要的逻辑门和数学函数和选择哪一个的输出显示。

(数据)总线[]

用总线允许您的计算机的组件相互通信。

一条总线可以通过使用创建红石布线连接你的计算机的运算器,随机储存器,只读储存器,中央处理器和寄存器在一起,这样他们就可以互相之间发送数据。通常是重要的计划,建立你的电脑的组件,否则你创建总线过长,或者更糟的是,没有空间来创建总线,在这种情况下,您可以删除的组件并重建一个适当的位置,或者使用像WorldEdit移动组件到其他地方。

存储[]

Register

随机存取存储器[]

4byteRAM default.png

随机存取存储器又称RAM,是程序使用的一种存储器,具有易失性。易失性是指当电源断开时,它将丢失信息。大多数情况下,在Minecraft中内存数据不会失去,所以最简单的方法就是使用d-触发器来添加读写功能。

二级存储器[]

这相当于HDD和SSD。下面介绍一种非常紧凑的存储技术,要涉及到红石比较器,能够存储高达1KB的实际数据大小。

https://www.youtube.com/watch?v=1zE_XZLTDBw

三级存储器[]

第三,也是最后一点,是第三级内存,它需要大量的时间来读/写,牺牲速度但可以存储大量信息。在现实世界中,三级存储器使用的是一种老式的挂载内存的机制,而且现在也很少使用了。在Minecraft中,这种系统要用潜影盒来完成,潜影盒中的方块必须由排序系统进行排序,以表示某种形式的数据。由于这些工作需要大量的比较器和大量的时间,所以读/写速度相当慢。然而,利用某些mod可以加快游戏tick的速度并消除这个问题。这用于存储长期数据,这些数据需要在程序开始时加载。相当于一台真正的计算机的机械硬盘或固态硬盘。

机器状态[]
程序计数器[]

程序计数器用于告诉CPU应该运行哪行代码。在每个时钟周期,解码器将访问这个计数器来获取下一个要执行的命令。一些命令会比另一个访问不同的数据量,或任何数据,因此解码器将适量增加程序计数器的下一个命令。使用的计数器也跳转命令控制程序流。

控制路径[]

处理[]
控制单元[]

Redstone Computer Control Unit.PNG

总线[]

Redstone Computer Control Busing.PNG

硬盘[]

Redstone Computer Tertiary Memory.PNG

固体方块可以被红石中继器强冲能,强充能方块可以点亮周围的红石粉。透明方块却不可以被冲能,这就是一个简单的硬盘。

程序内存[]

Redstone Computer Program Memory.PNG

程序内存,最基本,ROM(只读存储器)。ROM是最常用的远程执行一系列任务(如一个程序,因此得名)。它可以用来在用户控件(如图片)或每一行之间的时钟和足够的延迟2不是在同一时间。最简单、最高效的设计之一是一个图中,这可能是也可能不是加上解码器。它可以很容易地扩大,这是另一个优势。

机器状态[]

Redstone Computer Machine State.PNG

程序计数器[]

Redstone Computer Program Counter.png

时钟[]

Redstone Computer Clock.PNG

时钟同步组件或使用时间。(Minecraft)在大多数情况下,可以避免使用但有时它是计算机的功能所必需的。它基本上可以由红石火把链接成一条线/圈的非门(奇数建议或者你的输出必须“取反”),或者中继器,如上图所示。

提示[]

  • 你也可以使用一些像是WorldEdit的模组。
  • 如果你在生存模式没有太多的红石中继器,你可以用两个红石火把代替。
  • 利用颜色进行分区(例如用蓝色羊毛建造RAM(随机存取存贮器),黄色羊毛建造ALU(算术逻辑部件运算器)等)。

参见[]

注释[]

  1. “International General Certificate of Secondary Education(国际普通中等教育证书)”的简称,剑桥全球测试的一部分
Advertisement