CN1766841A

CN1766841A - 消息传递处理器

Info

Publication number: CN1766841A
Application number: CNA2005101192160A
Authority: CN
Inventors: S·辛格
Original assignee: Microsoft Corp
Current assignee: Microsoft Corp
Priority date: 2004-10-28
Filing date: 2005-10-27
Publication date: 2006-05-03
Also published as: US20060095724A1; EP1653346A2; EP1653346A3; KR20060053246A; JP2006155600A

Abstract

揭示了一种设计成直接执行基于异步π演算的机器代码的处理器。此类处理器可以是多处理器系统的一个元件，该多处理器系统旨在提供一种用于执行基于π演算的程序的可缩放的、松耦合的架构。

Description

消息传递处理器

相关申请的参照

本文中所揭示并要求保护的主题涉及于2004年3月11日提交的题为“ProcessLanguage For Microprocessors With Finite Resources”(具有有限资源的微处理器所用的处理语言)的美国专利申请第10/816,558号中所揭示和要求保护的主题。以上引用的美国专利申请的揭示内容通过引用包含于此。

技术领域

一般而言，本发明涉及计算机处理器。本发明尤其涉及设计成直接执行基于异步π演算的机器代码的处理器。

背景技术

π演算提供一种有效地建模松耦合的消息传递系统的方法，在该系统中可以动态地重新组织通信链路(例如，当蜂窝电话从一个基站移动到另一个基站时)。在剑桥大学出版社1999年Robin Milner的“Communicating and mobile systems：the pi-calculus”(通信和移动系统：π演算)中具体描述了π演算。最初使用此模型在形式上推理此类系统，较近期提议用基于π演算的编程语言来实际地实现系统。并且，原始的π演算是同步模型，其中消息的发送由接收者确认。已开发出异步的π演算，其中可发送消息而无需等待回复(以因特网方式)。

基于π演算方法的形式体系允许以严格的方式推理通信系统的行为。例如，可分析两个并发的进程来确保它们的通信遵从相同的协议。用基于π演算的语言编写的程序具有强加于它们之上的规则，使得手动或自动的分析比试图用任意的C#代码执行等效的分析来得更容易。

对于某些人来说，π演算可构成编程语言的基础是一种极端的想法，但是若干项目已显示此方法可能具有许多优点。目前正在开发各种基于π演算的编程语言，用于设计和实现松耦合的消息传递系统，特别是web服务。π演算的一个实际应用包括为web服务分析“合同”。

一种使用基于π演算的编程语言的示例性系统通过在常规系统软件(例如，公共语言运行时间(“CLR”)和常规的处理器架构(例如，Intel的X86处理器)之上执行来工作。但是，如果有一种系统架构或处理器可直接执行松耦合的消息传递程序，那将是合乎需要的。即，要缩小π演算等级的代码和常规指令集架构之间的语义差距，有一种直接执行基于π演算的程序的消息传递处理器系统可能是合乎需要的。

如果将此类系统设计成具有合适的处理器和存储器架构以确保随着更多处理器被加入，这些系统可被缩放，那也是合乎需要的。即，如果这样一个处理器不是通过集中到单个处理引擎中的极度复杂性(如x86架构中的情况)，而是通过对许多简单、小型的处理器的可缩放的部署来实现性能，那么将是尤其合乎需要的。基于松耦合的架构的小型处理器使得在性能和能力之间权衡变得较为简单。对于如因特网搜索加速或生物计算等计算复杂的任务，部署数百个处理器可能是合乎需要的。

发明内容

本文中所描述的发明提供一种合适的中间编译技术，用于在常规处理器上有效地实现基于π演算的程序，并提供新颖的基于π演算原语的指令集架构。已在实际的硬件上设计出并实现了用于π演算的原型处理器。

本发明提供设计用于在硬件上直接执行基于π演算的程序的指令集架构和处理器。尽管本发明的处理器的示例性实施例可能具有基本的操作系统核心，但是无需编写代码来管理多个进程、上下文切换、等等。例如，任务切换可由处理器在硬件中执行，且通过使用基于π演算的程序，使得代码并发的可能性显而易见。这也允许代码在另一个处理器上或甚至在某个远程位置处运行。

可将此类架构描述成“松耦合的”。即，在不同机器上运行的程序的若干组件可通过传递消息来与彼此通信。在常规处理器的世界中，组件会请求执行某个任务，并等待对该请求的回复。在松耦合的架构中，通常没有控制处理流程的中央处理器。某一处理器仅仅发送要求执行某个功能的消息，并且通常不等待对第一个请求的回复，随即继续执行安排它接下来要做的任何事。因此，此类系统是异步的。最终，根据某组规定的规则，将由发送该消息的处理器，或由另一个处理器接收回复。此类架构可能有助于通过提供松耦合的框架，来更好地利用硅片的能力，该框架使得处理器能够独立地(因此是并发地)尽可能多地进行。

但是，在此类松耦合的架构中需要一种理论，以受控制和可预测的方式来调整此类消息传递的结果。异步π演算提供这样一种理论。根据本发明的处理器集中于异步π演算。在硬件中定义了对应于π演算原语的指令集。同样，处理器在各线程之间调度其本身，这通常是由软件实现的功能。例如，可在对直接在FPGA硬件上操作的web服务的设计和实现中使用根据本发明的处理器系统。

附图说明

图1描述了36位存储器字的示例性实施例。

图2提供了根据本发明的处理器架构的示例性实施例的框图。

图3描述了来自VHDL仿真器的用户界面。

图4描述了来自逻辑分析器的用户界面。

图5A和5B分别是典型的现有技术的处理系统和根据本发明的处理系统的功能性框图。

图6所示是可实现本发明的各个方面的示例性计算环境的框图。

具体实施方式

现在将对直接执行基于异步π演算的指令集架构的处理器的一个示例性实施例进行描述。此类处理器通过缩小语言级概念和机器代码级实现之间的语义差距，提供可用于执行用基于异步π演算的语言编写的程序的引擎。

π演算是一种过程代数，其中通道名称既可作为传输介质，也可作为传输数据。因此，π演算可用于对已知为移动系统的自主主体系统进行建模。移动系统是通信网络的一种形式，其中个体组件以自由地自发选择的方式与彼此交互。开发π演算来对如蜂窝电话网络、因特网、和面向对象的软件程序般多样的并发计算系统中的交互进行建模。已采纳其为由BPMI.org开发的诸如商务过程建模语言(BPML)和微软的XLANG(BPEL4WS的先驱)等商务过程规范的基础。

异步π演算是不包括用于选择和给输出加前缀的显式算子的π演算的子集。基于异步π演算的指令集的示例性实施例的基本元素可包括以下7个指令：

NEW-动态创建新的通信通道的指令；

SEND2-异步发送一对字(直接或者间接)的指令；

RECEIVE2-从通道读取一对字的指令；

SELECT-听取一列通道，随后当在这些通道中的一个上出现数据时执行某个动作的指令；

PAR-将新的进程添加到处理器上运行的进程的列表中的指令；

SERVE-产生新的进程来处理通道上刚刚到达的数据值的指令；以及

HALT-停止进程的执行的指令。

根据本发明，可分别定义各个硬件电路来执行上述指令中的每一个。根据本发明的系统可包括这些指令中的一个或多个。因为期望用基于π演算原语的编程语言来编写软件，所以可使用对应于π演算原语的硬件指令来管理运行该软件的机器。因此，在根据本发明的系统中，可“从顶到底”应用π演算模型。在附录中提供了用于执行这些指令中的每一个的硬件处理器的示例性实施例的硬件定义语言(“HDL”)描述。

选择双向的异步发送，则可通过传递“延续通道”作为第二参数来对同步发送进行建模。当接收器获得消息时，它随即可沿延续通道向下发送虚值(dummyvalue)到发送器来确认接收(即，基本握手协议)。注意RECEIVE2指令实际上是SELECT指令的退化情况。为效率起见提供RECEIVE2作为原语指令，因为程序通常具有比不确定的选择多得多的接收。

对这7个指令的使用提供了对任何计算功能的执行(即，处理器是“图灵机完整的”)和对数据类型的建模。但是，为效率起见，较佳的是支持32位的有符号整数作为基本数据类型。通道也可表示为32位的地址。

用异步π演算编写的程序通常是若干试图通过各个通道通信或创建新通道的进程的集合。当一个进程通过通道向另一个进程发送消息时，在发送该消息期间可能发生交互。发送进程可能被删除(对于异步发送来说没有后续动作)，而接收器可用其刚刚接收到的新数据值重新开始执行。因此，对程序的执行可对应于进程之间的一系列交互。

在较佳的实施例中，可使用能支持36位值的存储器的FPGA硬件。图1描述了36位存储器字的示例性实施例。如图所示，操作码(和通道状态信息)可存储在4个最高阶的位中(即，在如图1中所示的最左边的4个位中)。32位值可存储在36位字的其余位中(即，最右边的32位)。

通常，对于大多数指令来说第一个参数将会是通道。通道可由全局存储器空间中的地址表示。指令集架构不需要用其绝对地址来标识通道。相反，可经由包含绝对通道地址的“变量”来间接地引用通道。例如，可用指定局部变量(即，从当前“栈框架”(stack frame)起的偏移量)的参数来调用NEW操作码，其中最近分配的通道的地址应被贮存(deposite)。

SEND2指令也可用同样方式(即，通过标识栈框架上包含通道实际地址的局部变量)指定通道用于通信。SEND2指令可通过查找局部变量的内容并发送该内容(例如，通道的绝对地址)来发送可指定局部变量的间接参数。这允许通过通道来发送通道，这是π演算的基本特性。SEND2指令还可发送直接模式(immediatemode)变量。发送指令的另一种模式允许发送嵌套范围内的值。当在如Pascal等语言中使用嵌套过程和函数时，此操作码类似于NS32016处理器中用于沿着栈框架走动的指令。

SERVE命令可通过在堆(heap)上分配新的任务框架来产生新的进程。此任务框架的第一个字指向封闭的任务框架。

因为用较大类的并发和分布式应用程序来建立概况可能是合乎需要的，所以可使用已知技术来实现无用信息收集器。由此，在另一个实施例中，现有的栈框架将被克隆和扩展，这使得无用信息收集变得更容易。在这样一个实施例中，SERVE操作码可自由地在一个不同的处理器上将所产生的进程实例化。

已编译的组件的第一个字可包含初始任务框架的地址，第二个字可包含它的大小。这允许运行时间系统计算出堆的初始地址。从而，可在存储器地址2处开始程序代码。

有时想要同时监听一个通道集，随后在数据出现在其中之一上的时候采取适当的行动，并放弃其它监听。此功能可由SELECT指令执行，该指令后可跟着一个通道和地址对的列表。处理器可按非指定的顺序检查要监听的通道，当某个通道有了数据的时候，可执行对应的代码。

通过将偏移量添加到PAR和SELECT指令的参数中所指定的绝对地址(以固定的专用通道的地址为模)，可将指令集设计成允许可容易地重新分配的机器代码。指令集架构不需要就如何调度进程或某通道上可容纳多少个数据项进行说明。这些考虑事项，包括如公平性等其它考虑事项，可由具体的架构实现来设置。

可将指令集架构设计成适用于基于控制和协议的应用程序，而不是密集的数字处理应用程序。例如，结合数字密集子组件的一种有效方式是为此功能设计某种专用的硬件，并使用和访问常规通道完全相同的通道协议来与该硬件通信。

应当注意，可将其它指令添加到该指令集而不会偏离本发明的精神。此类指令的例子包括同步发送、及一元发送和接收。但是，应当理解，将这些附加指令包括进来所需的硅面积的增加可能不能证明性能中的些微增益可归功于将它们包括进来。例如，即使同步发送可能常见于某些类型的应用程序中，无论如何它们的远程实现最终退化为某种类型的握手协议——这是以上所示的基于延续传递的编码所做的。因此，承受存储稍大一些的程序(和延续通道)所需的若干额外字节的代价、以及局部设置中若干时钟周期的损失可能是较佳的。

硬件平台和处理器架构

可在根据本发明的消息传递处理器系统中使用的硬件平台(或称“板”)的一个示例性实施例可包括连接到组成多媒体系统的各种资源的现场可编程门阵列(“FPGA”)。可包括一个或多个(数十个)根据本发明设计的处理器的FPGA可连接到多个完全独立的存储体(其中每一个存储体都可以是例如2MB的ZBT存储器)、视频输入/输出逻辑、音频输入/输出、以太网接口、串行输入、键盘输入、鼠标输入、CF接口、及各种转换开关和LED。

以上就π演算处理器所描述的指令集架构不需要常规意义的任何寄存器。FPGA架构提供大量双端口存储器(例如，在较佳实施例中为56个)，其中每一个都可以是例如18K的大小。此类FPGA可用来表示消息传递系统中使用的通道，以及用于程序和数据的高速缓存(cache)。可经由管理与较大存储器芯片(例如，在较佳实施例中为5个2兆字节存储体)的通信的“SDRAM”控制器来访问主存储器。可有若干专用通道，提供与诸如加法器、乘法器、和用于串行端口通信的UART等硬件资源的连接。可通过交换网络到达另一个处理器所拥有的通道。图2中示出根据本发明的处理器架构的示例性实施例的框图。

用户程序中的逻辑通道可由双重(two-tier)分层结构存储器中的全局地址表示。处理器的一个存储器端口可通过快速计时接口与本地高速缓存直接通信。另一个端口可与将一个或多个处理器连接到全局存储器空间中的存储器“交换开关”通信。但是，这些存储器之间的接口无须是固定周期的同步接口。正如处理器所支持的底层计算模型，该接口可以是异步发送请求远程存储器位置的内容的存储器事务(例如，消息)的消息传递系统。此类去耦合允许部署可缩放的存储器架构，而同时保持与为具体处理器包含数据的本地存储器的高性能链路。

32位的地址字可被划分成标识具体处理器和存储器组的较高阶位和标识在这样一个组内的位置的较低阶位。因此，可通过检查较高阶位来判断通道是否正在本地环境中进行通信。当将此架构作为在常规指令集架构上编译的跳板使用时，此组织结构可允许优化用基于寄存器的操作来取代某些基于通道的计算。

指令集架构的另一个特征是它不需要包括任何算术操作。几乎所有计算元件都是由诸如加法器和乘法器等外部进程来建模的。这可由以下π演算宏汇编的片段来说明，该片段示出如何将两数相加并随后将结果写到串行端口：

2 k1＜-new

3 par2(send2(adder，((x，y)，k1))

4 (do sum＜-receive k1

5 send uart sum))

此代码创建新的通道供加法器返回结果(k1)。它随后并行地执行两个进程。一个进程向专用加法器通道发送包含要相加的值的两个通道(x，y)，和返回结果的通道(k1)。另一个进程监听通道k1上的结果，随即将和写到UART，以供在例如连接到系统的RS232端口的设备上显示。

应当理解，此类基于通道的操作可转换为常规的x86或基于RISC的ADD(加)操作，以在常规处理器中执行。通过将此类指令外部化，就有了小得多的指令集，这导致更紧凑的处理器，它进而允许在给定的芯片区域中实现多得多的此类处理器。

根据本发明的基本π演算处理器的示例性单处理器实施例可包括多达592个逻辑单元、308个触发器、和代表大约3％可用逻辑资源的中等规模的FPGA(例如，XC2V2000)的3个18K双端口存储器块。这不包括通常由一个以上处理器共享的供SDRAM控制器用的资源。

已将该示例性实施例的原型设计和构造成在少于10纳秒之内执行每个时钟周期，这提供了100兆赫兹的操作频率。尽管比起诸如Intel的“PENTIUM”处理器等许多公知处理器来说这是显然较低的操作频率，但是可通过增加简单处理器的个数来提高性能，而不是使一个处理器非常复杂。此外应当理解，FPGA的原型设计的技术通常要比定制硅实现慢一个数量级。由此，应当理解，根据本发明的处理器在例如90nm CMOS硅处理器上的执行速度应在1G赫兹以上。

可使用交换矩阵，将多个π演算处理器在通信上耦合到一起。预期在当前可用的最大FPGA上，可将多达100个π演算处理器耦合到一起。

根据本发明的处理器系统的一个示例性实施例可包括宏汇编器、反汇编器、和用于为处理器初始化引导存储器的代码生成器。在原型设计环境中，处理器本身的实现可以是VHDL代码的形式，可用公知的工具将该代码合成为逻辑网表(netlist)。

可将宏汇编器设计成插入到π演算程序编译器的后端中。还可将基于π演算的程序直接写入宏汇编器中。例如，以下汇编程序片段在异步π演算框架中编码了两个消息的同步发送：

6 prog

7 ＝do chanl＜-new

8 k1＜-new

9 k2＜-new

10 par[send_imm2 chanl(5，k1)，

11 do_＜-receive k1

12 send_imm2 chanl(7，k2)，

13 do_＜-receive k2

14 halt，

15 serve chanl.

16 (\(v，k)-＞.

17 par2(send_ind write_chan v).

18 (send_imm k0)).

19 ].

此程序创建一个通信通道和两个延续通道，随后并行地执行以下操作：a)向chanl发送包含值5和延续k1的对，b)等待延续k1上的响应，随后向chanl发送包含值7和延续k2的对，c)等待延续k2上的响应，随后删除该进程，以及d)等待chanl上的通信，每次接收到某个数据时，派生一个单独的进程来处理该数据(在此例中为通过写到专用通道FFEE来写某个输出)。

此程序可编译成以下汇编代码：

20 00000002：NEW 0.

21 00000003：NEW 1.

22 00000004：NEW 2.

23 00000005：PAR 00000009.

24 00000006：SEND2 (0)#5(1).

25 00000009：PAR 0000000F.

26 0000000A：RECEIVE2(1)3.

27 0000000C：SEND2 (0)#7(2).

28 0000000F：PAR 00000013.

29 00000010：RECEIVE2(2)5.

30 00000012：HALT.

31 00000013：SERVE (0)3.

32 00000015：PAR 00000019.

33 00000016：SEND2 (65518)(1)(1).

34 00000019：SEND2 (2)#0(0).

35

36 FRAME_BASE at 0000001C.

37 FRAME size＝00000007.

38 HEAP_PTR＝00000023.

尽管该处理器可能具有基本的操作系统核心，但可能没有必要编写代码来管理多个进程、上下文切换、等等。这些任务可由处理器执行。通过使用PAR和SERVE操作码，可使代码并发的可能性显而易见。该系统因而可自由地在任何给定处理器上或甚至在远程位置处运行代码。

可将所生成的汇编代码转换成处理器的引导存储器用的初始化信息，并可用显示这些指令在800纳秒内完成的VHDL仿真器(见图3)确定对此程序精确到时钟周期的执行。已使用实验的设置，在上述的实际硬件上执行已编译的π演算程序，并通过闪光的发光二极管、超级终端等来监视它们的进度，或通过使用逻辑分析器(见图4)来检查内部状态。

图5A和5B分别是典型的现有技术的处理系统10和根据本发明的处理器系统20的功能性框图。如图5A中所示，多个处理器11可被耦合到通信通路12(例如，可以是总线)。每个处理器11都可包括控制单元13、数据寄存器14、和算术逻辑单元(ALU)15。控制单元13进行指令的执行。数据寄存器14包含受控制单元操纵的数据。ALU 15执行加法和减法、逻辑操作、屏蔽、和移位(乘法和除法)。随机存取存储器(“RAM”)16也被耦合到通信通路12。各处理器11可访问(即，读和写)RAM 16。各处理器共享对RAM的访问。每个处理器都顺序执行一组程序指令，并在需要时访问其自带的ALU和数据寄存器、及共享的存储器。

如图5B中所示，多个指令处理器21可被耦合到通信通路22。RAM 26、ALU服务25、端口27也可被耦合到通信通路22。处理器21共享到ALU服务和RAM的访问。处理器21还共享端口27。在根据本发明的系统20中，可经由通过网络传递的消息来执行程序。例如，指令处理器21可接收包括指令流的消息。指令处理器21可作用于该指令流，并且在该过程中可访问共享RAM 26、共享ALU服务25、和共享端口27。指令处理器可从端口读出数据，或将数据放到端口上。可通过简单地向通信网络添加更多的指令处理器21来缩放这种系统。

示例性计算环境

图6示出了可实现本发明的合适的计算系统环境100的示例。计算系统环境100仅为合适的计算环境的一个例子，并不试图对本发明的使用或功能的范围提出任何限制。也不应将计算环境100解释成具有涉及示例性操作环境100中所示的各组件中的任何一个或其任何组合的依赖性或要求。

本发明可用于许多其它通用或专用计算系统环境或配置。适用于本发明的公知的计算系统、环境、和/或配置的例子包括，但不限于，个人计算机、服务器计算机、手持式或膝上设备、多处理器系统、基于微处理器的系统、机顶盒、可编程消费者电子设备、网络PC、微型计算机、大型计算机、包括任何上述系统或设备的分布式计算环境、等等。

可以在由计算机执行的诸如程序模块等计算机可执行指令的通用环境中描述本发明。一般而言，程序模块包括执行特定任务或实现特定抽象数据类型的例程、程序、对象、组件、数据结构等等。本发明还可在分布式计算环境中实施，其中任务由通过通信网络或其它数据传输介质连接的远程处理设备执行。在分布式计算环境中，程序模块和其它数据可位于包括记忆存储设备的本地和远程计算机存储介质两者之中。

参考图6，用于实现本发明的示例性系统包括计算机110形式的通用计算设备。计算机110的组件可包括，但不限于，处理单元120、系统存储器130、以及将包括系统存储器在内的各种系统组件耦合到处理单元120的系统总线121。系统总线121可以是若干类型总线结构的任意一种种，包括存储器总线或存储器控制器、外围总线、及使用各种总线体系结构中的任何一种的局部总线。作为示例，而非限制，此类体系结构包括工业标准体系结构(ISA)总线、微通道体系结构(MSA)总线、增强ISA(EISA)总线、视频电子技术标准协会(VESA)局部总线、外围部件互联(PCI)总线(也称Mezzanine总线)。

计算机110通常包括各种计算机可读介质。计算机可读介质可以是可由计算机110访问的任何可用介质，包括易失性和非易失性介质，可移动和不可移动介质。作为示例而非限制，计算机可读介质可包括计算机存储介质和通信介质。计算机存储介质包括以任何方法或技术实现的用于存储诸如计算机可读指令、数据结构、程序模块或其它数据等信息的易失性和非易失性，可移动和不可移动介质。计算机存储介质包括，但不限于，RAM、ROM、EEPROM、闪存或其它存储器技术、CD-ROM、数字多功能盘(DVD)或其它光盘存储、磁带盒、磁带、磁盘存储或其它磁存储设备、或可用于存储所需信息并可由计算机110访问的任何其它介质。通信介质通常具体化为诸如载波或其它传输机制等已调制数据信号中的计算机可读指令、数据结构、程序模块或其它数据，并包括任何信息传送介质。术语“已调制数据信号”指以在信号中将信息编码的方式设置或改变其一个或多个特征的信号。作为例子而非限制，通信介质包括诸如有线网络或直线连接等有线介质，及诸如声学、RF、红外及其它无线介质等无线介质。上面的任意组合也应被包括在计算机可读介质的范畴内。

系统存储器130包括诸如ROM 131和RAM 132等易失性和/或非易失性存储器形式的计算机存储介质。包含例如在启动期间在计算机110内部各元件间传送信息的基本例程的基本输入输出系统133(BIOS)通常存储在ROM 131中。RAM 132通常包含可由处理单元120立即访问和/或当前正在操作的数据和/或程序模块。作为示例而非限制，图6示出了操作系统134、应用程序135、其它程序模块136及程序数据137。

计算机110还可包括其它可移动/不可移动，易失性/非易失性计算机存储介质。仅仅作为例子，图6示出读或写不可移动、非易失性磁介质的磁盘驱动器141、读或写可移动、非易失性磁盘152的磁盘驱动器151、以及读或写诸如CD-ROM或其它光介质等可移动、非易失性光盘156的光盘驱动器155。可在示例性操作环境中使用的其它可移动/不可移动、易失性/非易失性计算机存储介质包括，但不限于，磁带盒、闪存卡、数字多功能盘、数字录像带、固态RAM、固态ROM等等。硬盘驱动器141通常通过诸如接口140等不可移动存储器接口连到系统总线121，磁盘驱动器151和光盘驱动器155通常通过诸如接口150等可移动存储器接口连到系统总线121。

各驱动器及其相关联的计算机存储介质为计算机110提供了计算机可读指令、数据结构、程序模块及其它数据的存储。例如，在图6中，硬盘驱动器141被示为存储操作系统144、应用程序145、其它程序模块146和程序数据147。注意，这些组件可以和操作系统134、应用程序135、其它程序模块136和程序数据137相同或者相异。此处给操作系统144、应用程序145、其它程序模块146和程序数据147不同的标号，以说明至少它们是不同的副本。用户可通过诸如键盘162和定位设备161(通常指鼠标、跟踪球或触摸垫)等输入设备将命令和信息输入到计算机110中。其它输入设备(未示出)可包括话筒、操纵杆、游戏垫、圆盘式卫星天线、扫描仪等等。这些及其它设备常通过耦合到系统总线的用户输入接口160连到处理单元120，但也可由诸如并行端口、游戏端口或通用串行总线(USB)等其它接口和总线结构连接。监视器191或其它类型的显示设备也经由诸如视频接口190等接口连到系统总线121。除了监视器之外，计算机还可包括可通过输出外围接口195连接的其它外围输出设备，诸如扬声器197和打印机196等。

计算机110可用到诸如远程计算机180等一个或多个远程计算机的逻辑连接在联网环境中运行。远程计算机180可以是个人计算机、服务器、路由器、网络PC、对等设备或其它公共网络节点，且通常包括以上相对于计算机110所描述的许多或全部元件，尽管在图6中仅示出记忆存储设备181。所示逻辑连接包括LAN 171和WAN 173，但也可包括其它网络。此类网络环境常见于办公室、企业范围计算机网络、内联网和因特网。

当用于LAN网络环境时，计算机110通过网络接口或适配器170连到LAN171。当用于WAN网络环境时，计算机110通常包括调制解调器172或其它通过诸如因特网等WAN 173建立通信的装置。可以是内置或外置的调制解调器172可经由用户输入接口160或其它适当的机制连到系统总线121。在联网环境中，相对于计算机110描绘的程序模块或其部分可存储于远程记忆存储设备中。作为示例而非限制，图6示出远程应用程序185驻留在存储器设备181上。应当理解，所示网络连接是示例性的，且可使用在计算机之间建立通信链路的其它装置。

如上文所提及的，尽管是就各种计算设备描述了本发明的示例性实施例，但是基础的概念可适用于任何计算设备或系统。

可结合硬件或软件、或在适当处就两者的组合来实现本文中所述的各种技术。因此，本发明的方法和装置或其某些方面可表现为在诸如软盘、CD-ROM、硬盘驱动器、或任何其它机器可读存储介质等有形介质中具体化的程序代码(即，指令)，其中，当诸如计算机等机器加载并执行程序代码时，该机器成为实施本发明的装置。在程序代码在可编程计算机上执行的情形中，计算设备一般包括处理器、处理器可读的存储介质(包括易失性和非易失性存储器和/或存储元件)、至少一个输入设备、和至少一个输出设备。如果合乎需要，可用汇编或机器语言实现各个程序。无论在何种情况下，该语言可以是编译或解释语言，并可与硬件实现结合。

本发明的方法和装置还可经由具体化为诸如通过电线连线或电缆连线、通过光纤、或经由任何其它的传输形式等通过某种传输介质传输的程序代码形式的通信来实施，其中，当由诸如EPROM、门阵列、可编程逻辑设备(PLD)、客户计算机等机器接收、加载和执行该程序代码时，该机器成为实施本发明的装置。当在通用处理器上实现该程序代码时，它与处理器结合以提供一种用于调用本发明的功能的独特装置。此外，结合本发明使用的任何存储技术可以总是硬件和软件的组合。

由此，已描述了设计成直接执行基于异步π演算的机器代码的硬件处理器。尽管是结合各附图中所描述的某些较佳的实施例来描述本发明，应当理解，可以使用其它类似的实施例，并可为实施本发明而对所描述的实施例作修改或添加，而不会偏离本发明。因此，不应将本发明限制于任何单独的实施例，相反，应根据所附权利要求书的广度和范围来解释本发明。

例如，应当理解，FPGA提供了“虚拟硬件”(即，在运行时间将硬件动态地交换进和交换出芯片)的潜在可能。尽管有许多开发此能力的手工尝试，但还没有令人满意的动态重新配置的模型。可研究诸如π演算等的移动过程代数的适用性，用于对此类系统进行建模。可控制的可重新配置的技术对于能动态地决定哪些操作需要硬件加速的未来操作系统来说可能非常有用。

另一个近期的技术革新是超高速串行链路的使用。如今硅片可访问多个10GB的串行收发器，这可用来实现芯片间的、板级的、及以上的高速通信。利用此能力很可能需要为松耦合系统协议进行仔细的设计和实现。

此外，应当理解，在上述的示例性体系结构中，如果第一个消息已经在该通道等待，则第二个消息可能不被发送(即，放到通道中)。相反，它可能需要等待，直到第一个消息被移除。由此，一些人可认为上述的示例性架构在最纯粹的意义上不是“异步的”，诸如在接收命令有超时但发送命令没有的地方，以及当发送命令张贴一个消息而发送器对此一无所知的时候，等等。应当理解，将这样一个“准异步”架构改变成同步架构(例如，发送者张贴一个消息，接收者执行一个功能，且发送者得回该功能的回答)是直接的。同步架构可能更易于用代码实现，因此，在某些应用中可能比异步架构更为有用。

附录

此附录包括对于用于执行基于异步π演算原语的指令的硬件处理器的示例性实施例的硬件定义语言(“HDL”)描述。应当理解，本文中所提供的HDL描述仅仅是示例，任何数量的硬件定义都可以描述执行基于异步π演算原语的指令的处理器。

　　library ieee；

　　use ieee.std_logic_1164.all；

　　use work.hwprocl_package.all；

　　entity memory_block is

　　         port(signal do：out word36；

　　         signal addr：in memory_block_address；

　　         signal clk：in std_logic；

　　         signal di：in word36；

　　         en，we：in std_logic)；

　　end entity memory_block；

　　library ieee；

　  use ieee.std_logic_1164.all；

　  use ieee.std_logic_arith.all；

　  use ieee.std_logic_unsigned.all；

　　library unisim；

　　use unisim.vcomponents.all；

　　architecture memory_organization of memory_block is

　　  signal ssr：std_logic：＝′0′；

　　  signal addr_vec：std_logic_vector(8 downto 0)；

　　  signal di_vec，do_vec：std_logic_vector(31 downto 0)；

　　  signal dip_vec，dop_vec：std_logic_vector(3 downto 0)；

　　begin

　　  block_ram：ramb16_s36

　　               port map(do＝＞do_vec，dop＝＞dop_vec，

　　                          addr＝＞addr_vec，clk＝＞clk，
        <!-- SIPO <DP n="14"> -->
        <dp n="d14"/>
                            di＝＞di_vec，dip＝＞dip_vec，en＝＞en，ssr＝＞ssr，

                            we＝＞we)；
  addr_vec＜＝conv_std_logic_vector(addr，9)；
  di_vec＜＝conv_std_logic_vector(di.val，32)；
  dip_vec＜＝conv_std_logic_vector(di.tag，4)；
  do.val＜＝conv_integer(do_vec)；
  do.tag＜＝conv_integer(dop_vec)；
end architecture memory_organization；
package debug_package is
 procedure trace(message：in string)；
end package debug_package；
package body debug_package is
 procedure trace(message：in string)is
 begin

     report message；
 end procedure trace；
end package body debug_package；
        <!-- SIPO <DP n="15"> -->
        <dp n="d15"/>
library ieee；
use ieee.std_logic_1164.all；
use work.hwprocl_package.all；
entity hwprocl is
  port(signal clk，rst：in std_logic；

         sigual led1，led2：out std_logic；

         signal ram_out：out word36)；
end entity hwprocl；
        <!-- SIPO <DP n="16"> -->
        <dp n="d16"/>
library ieee；
use ieee.std_logic_1164.all；
use ieee.std_logic_arith.all；
use ieee.std_logic_unsigned.all；
use work.debug_package.all；
use work.memory_package.all；
use work.task_memory_Package.all；
architecture behavioural of hwprocl is
  constant nr_task_slots：natural：＝8；--最大值是512
  signal block1_out，block1_in：word36：＝(0，0)；
  signal addr，pc：memory_block_address：＝0；
  signal en，we：std_logic：＝′0′；
  signal task_addr_out，task_addr_in：natural：＝0；
  signal task_frame_in，task_frame_out：natural：＝0；
  signal task_id：memory_block_address：＝0；
  signal task_en，task_we：std_logic；
  signal frame_base，frame_size，heap_ptr：memory_block_address：＝0；
  signal arg1，arg2，arg3：natural：＝0；
  type states is(first_cycle，second_cycle，read_frame_base，read_frame_size，

                       new_task，new_task1，new2，find_task，find_task0，exec，

                       readout_program，fetch_next_instr，

                       --SEND_IMM状态

                       send_cycle2，send_cycle3，send_cycle4，send_cycle5，

                       send_cycle6，send_cycle7，send_cycle8，send_cycle8b，

                       send_cycle9，

                       send_cycle10，
        <!-- SIPO <DP n="17"> -->
        <dp n="d17"/>
                        --PAR状态

                        par_cycle2，par_cycle3，find_free_slot，

                        finish_par，read_slot，

                        --RECEIVE状态

                        recv，recv2，recv2a，recv2b，recv3a，recv3，recv4，recv5

                        )；
  signal state：states：＝first_cycle；
  signal after_reset：boolean：＝false；
begin
  block1：memory_block port map(do＝＞block1_out，

                                    addr＝＞addr，

                                    clk＝＞clk，

                                    di＝＞block1_in，

                                    en＝＞en，

                                    we＝＞we)；
  task_list：task_memory_block port map(

                    task_addr_out＝＞task_addr_out，

                    task_frame_out＝＞task_frame_out，

                    addr＝＞task_id，

                    clk＝＞clk，

                    task_addr_in＝＞task_addr_in，

                    task_frame_in＝＞task_frame_in，

                    en＝＞task_en，

                    we＝＞task_we)；
  top_level_control：process(clk，rst)

    variable led1_value，led2_value：std_logic：＝′0′；
  begin
        <!-- SIPO <DP n="18"> -->
        <dp n="d18"/>
if rst′event and rst＝′0′then
   after reset＜＝true；
end if；
if clk′event and clk＝′1′and after reset then
   case state is

     when first_cycle＝＞--此上电模式确保存储器单元具有正确的控制信号

                           en＜＝′1′；--启用主存储器

                           we＜＝′0′；--启用存储器的读模式

                           task_en＜＝′1′；--启用任务存储器

                           task_we＜＝′0′；

                           addr＜＝0；

                           state＜＝second_cycle；

     when second_cycle＝＞addr＜＝addr+1；

                            state＜＝read_frame_base；

                            --准备要被写的任务存储器

                            task_id＜＝0；

     when read_frame_base＝＞--捕捉FRAME BASE寄存器值

                               frame_base＜＝block1_out.val；

                               --设置要执行的第一个任务ID

                               task_we＜＝′1′；

                               task_addr_in＜＝2；--开始ADDR

                               task_frame_in＜＝block1_out.val；--TF

                               state＜＝read_frame_size；

     when read_frame_size＝＞frame_size＜＝block1_out.val；

                               heap_ptr＜＝frame_base+block1_out.val；

                               --将任务存储器置成读模式

                               --以搜索第一个任务

                               task_we＜＝′0′；

                               state＜＝find_task；
        <!-- SIPO <DP n="19"> -->
        <dp n="d19"/>
                   when find_task＝＞

                    state＜＝find_task0；

                  when find_task0＝＞

                   if task_frame_out＝0 then

                      --这是空的任务槽

                      task_id＜＝(task_id+1)mod nr_task_slots；

                      state＜＝find_task；

                    else

                      --找到可运行的任务

                      trace(″＞＞＞Found task at slot″& natural′image(task_id)&″pc＝″&
natural′image(task_addr_out)&″frame_base＝″& natural′image(task_frame_out))；

                      pc＜＝task_addr_out；

                      addr＜＝task_addr_out；

                      frame_base＜＝task_frame_out；

                      en＜＝′1′；we＜＝′0′；

                      state＜＝fetch_next_instr；

                    end if；

                  when new_task＝＞

                    --任务id包含下一个要运行的任务的ID

                    --读任务地址和框架基址

                    task_we＜＝′0′；

                    state＜＝new_task1；

                  when new_task1＝＞

                    --捕捉任务基地址和任务框架基址

                    pc＜＝task_addr_out；

                    addr＜＝task_addr_out；

                    frame_base＜＝task_frame_out；

                    state＜＝fetch_next_instr；

                  -----------------------------------------------------

                  --发送直接操作码
        <!-- SIPO <DP n="20"> -->
        <dp n="d20"/>
                 ------------------------------------------------------

                 --Cycle 1(周期1)：操作码、通道ID可用

                 --         准备读通道地址

                 --Cycle 2(周期2)：通道地址可用，准备读内容

                 --Cycle 3(周期3)：如果通道满则阻塞，否则准备写直接参数。

                 --Cycle 4(周期4)：直接参数可用，准备将直接参数写到通道中的第一
个槽。

                 --准备读间接参数以及准备从任务列表删除此进程。

                 --Cycle 5(周期5)：间接参数可用，因此准备将此写到通道中的第二个
槽。

                 --Cycle 6(周期6)：间接参数的写操作完成，开始寻找另一个要运行的
进程。

                 --注意：考虑合并周期5和6

                 when send_cycle2＝＞--周期2

                    --准备地址以读取通道的地址

                    state＜＝send_cycle3；

                  --将通道地址移到地址总线以读取其内容

                  when send_cycle3＝＞--周期3

                    trace(″Channel address is″& natural′image(block1_out.val))；

                    arg1＜＝block1_out.val；

                    addr＜＝block1_out.val；

                    state＜＝send_cycle4；

                  --读取通道的内容

                  when send_cycle4＝＞--周期4

                    trace(″Channel word1 tag＝″& nibble′image(block1_out.tag)&″val＝″
& natural′image(block1_out.val))；

                  --读取通道val的内容以获取通道地址
        <!-- SIPO <DP n="21"> -->
        <dp n="d21"/>
                                  if block1_out.tag mod 2＝0 then

                                    trace(″Channel is empty.″)；

                                    --取回直接参数

                                    addr＜＝pc+1；

                                    state＜＝send_cycle5；

                                  else

                                    trace(″Channel is full so SEND blocked.″)；

                                    task_id＜＝(task_id+1)mod nr_task_slots；

                                    state＜＝find_task；

                                  end if；

               when send_cycle5＝＞

                 --等待读取直接参数

                 addr＜＝addr+1；

                 state＜＝send_cycle6；

               when send_cycle6＝＞

                 --取回间接的第三参数

                 trace(″SEND_IMM immediate argument is″& natural′image
(block1_out.val))；

                 arg2＜＝block1_out.val；

                 state＜＝send_cycle7；

               when send_cycle7＝＞

                 trace(″Indirect argument is″& natural′image(block1_out.val)&″channel
var address″& natural′image(block1_out.val+frame_base))；

                 --读取通道值以发送

                 addr＜＝block1_out.val+frame_base；

                 state＜＝send_cycle8；

                 --删除此进程

                 task_frame_in＜＝0；

                 when send_cycle8＝＞
        <!-- SIPO <DP n="22"> -->
        <dp n="d22"/>
  --读取间接参数的值
  state＜＝send_cycle8b；
when send_cycle8b＝＞
  trace(″Indirect value to send is″& natural′image(block1_out.val))；
  --删除此进程
  task we＜＝′1′；
  arg3＜＝block1_out.val；
  --执行发送
  we＜＝′1′；
  addr＜＝arg1；
  block1_in.tag＜＝1；
  block1_in.val＜＝arg2；
  state＜＝send_cycle9；
when send_cycle9＝＞
  task_we＜＝′0′；
  --写间接参数
  addr＜＝addr+1；
  block1_in.tag＜＝0；
  block1_in.val＜＝arg3；
  state＜＝send_cycle10；
--开始寻找另一个任务来运行
when send_cycle10＝＞
  we＜＝′0′；
  task_id＜＝(task_id+1)mod nr_task_slots；
  state＜＝find_task；
---------------------------------------------------------------------
--PAR操作码状态
---------------------------------------------------------------------
when par_cycle2＝＞
        <!-- SIPO <DP n="23"> -->
        <dp n="d23"/>
                   task_we＜＝′0′；

                   state＜＝par_cycle3；

                   task_id＜＝0；

                 when par_cycle3＝＞

                   --在槽0处读任务数据

                   state＜＝find_free_slot；

                 when find_free_slot＝＞

                   if task_frame_out＝0 then-这是空槽所以使用它

                       race(″Found free slot for PAR at″& natural′image(task_id))；

                       --为新进程建一个条目

                       task_we＜＝′1′；

                       task_frame_in＜＝frame_base；

                       task_addr_in＜＝arg1；

                       state＜＝finish_par；

                       addr＜＝arg1；

                       pc＜＝arg1；--继续运行PAR的进程

                      else

                        trace(″Slot″& natural′image(task_id)&″contains addr″&
natural′image(task_addr_out)&″frame″& natural′image(task_frame_out))；

                        task_id＜＝(task_id+1)mod nr_task_slots；

                        state＜＝read_slot；

                      end if；

                    when read_slot＝＞

                      state＜＝find_free_slot；

                    when finish_par＝＞--周期3

                      --将处理器设置成继续在由PAR指令参数指定的地址执行

                      task_we＜＝′0′；

                      state＜＝fetch_next_instr；
        <!-- SIPO <DP n="24"> -->
        <dp n="d24"/>
                 -------------------------------------------------------------------------

                 --RECEIVE操作码状态

                 -------------------------------------------------------------------------

                 when recv＝＞--周期2

                   trace(″RECEIVE2 Cycle 2：addres of channel var is″& natural′image
(block1_out.val+frame_base))；

                   --block1_out.val包含通道val的地址

                   --现在读取该通道地址

                   addr＜＝block1_out.val+frame_base；

                   state＜＝recv2a；

                 when recv2a＝＞

                   trace(″Channel absolute value is″& natural′image(block1_out.val))；

                   --浮动(float)该通道的地址

                     addr＜＝block1_out.val；

                     state＜＝recv2b；

                 when recv2b＝＞

                   --读该通道

                   state＜＝recv2；

                 when recv2＝＞--周期3

                   trace(″RECEIVE2：channel tag is″& natural′image(block1_out.tag))；

                   if block1_out.tag＝0 then-没有数据可用因此阻塞

                     trace(″RECEIVE2 blocked.″)；

                     task_id＜＝(task_id+1)mod nr_task_slots；

                     state＜＝find_task；

                   else

                     trace(″$$$Read value 1：″& natural′image(block1_out.val))；

                     --取数据

                     arg1＜＝block1_out.val；

                     addr＜＝addr+1；
        <!-- SIPO <DP n="25"> -->
        <dp n="d25"/>
    state＜＝recv3a；
  end if；
when recv3a＝＞
  --读周期
  state＜＝recv3；
when recv3＝＞
trace(″$$$Read value 2：″& natural′image(block1_out.val))；
arg2＜＝block1_out.val；
--现在写数据
addr＜＝pc+1；
state＜＝recv4；
when recv4＝＞
  we＜＝′1′；
  block1_in.tag＜＝0；
  block1_in.val＜＝arg1；
  addr＜＝block1_out.val+frame_base；
  state＜＝recv5；
when recv5＝＞
  block1_in.val＜＝arg2；
  addr＜＝addr+1；
  we＜＝′0′；
  pc＜＝pc+1；
---------------------------------------------------------------------
--读出操作码和arg1以为执行模式作好准备
---------------------------------------------------------------------
when fetch_next_instr＝＞state＜＝exec；
---------------------------------------------------------------------
--执行取回的指令+arg1
        <!-- SIPO <DP n="26"> -->
        <dp n="d26"/>
                 --------------------------------------------------------------------------

                 when exec＝＞--对主存储器的输出上的操作码进行解码

                   trace(″exec addr″& natural′image(addr)&″with block1_out.tag＝″&
nibble′image(block1_out.tag))；

                   case block1_out.tag is

                     when 1＝＞--SEND直接指令

                       trace(″＝＝＝SEND_IMM″& natural′image(block1_out.val)&″var at
″& natural′image(block1_out.val+frame_base))；

                       trace(″Channel variable address is″& natural′image(block1_out.val
+frame_base))；

                       addr＜＝block1_out.val+frame_base；

                       --检查通道的状态

                       state＜＝send_cycle2；

                     when 4＝＞--PAR指令

                       trace(″＝＝＝PAR″& natural′image(block1_out.val))；

                       arg1＜＝block1_out.val；--记录要加的进程地址

                       --在任务表中为此线程更新PC

                       task_we＜＝′1′；

                       task_addr_in＜＝pc+1；

                       task_frame_in＜＝frame_base；

                       --开始寻找空的任务槽

                       state＜＝par_cycle2；

                     when 6＝＞--NEW指令

                       --将堆位置写到本地var

                       trace(″＝＝＝NEW″& natural′image(block1_out.val)&″var at″&
natural′image(block1_out.val+frama_base))；

                       addr＜＝block1_out.val+frame_base；

                       block1_in.val＜＝heap_ptr；

                       --递增程序计数器

                       task_we＜＝′1′；

                       task_addr_in＜＝pc+1；

                       task_frame_in＜＝frame_base；
        <!-- SIPO <DP n="27"> -->
        <dp n="d27"/>
                        --分配通道

                        heap_ptr＜＝heap_ptr+2；

                        state＜＝new2；

                      when 11＝＞--RECEIVE指令

                        --查看通道上数据是否可用

                        trace(″＝＝＝RECEIVE2″& natural′image(block1_out.val)&″chan
var at″& natural′image(block1_out.val+frame_base))；

                         addr＜＝block1_out.val+frame_base；

                         we＜＝′0′；

                         state＜＝recv；

                       when others＝＞en＜＝′1′；

                         we＜＝′0′；

                         state＜＝readout_program；

                   end case；

                ------------------------------------------------------------

                --NEW操作码

                ------------------------------------------------------------

                when new2＝＞--换出主存储器写模式并执行下一个指令

                              we＜＝′0′；

                  --取回下一个指令

                  task_we＜＝′0′；

                  pc＜＝pc+1；

                  addr＜＝pc+1；

                  state＜＝fetch_next_instr；

                --------------------------------------------------------------------

                --转储程序并闪动发光二极管

                --------------------------------------------------------------------

                when readout_program＝＞

                  if en＝′1′then
        <!-- SIPO <DP n="28"> -->
        <dp n="d28"/>
              if we＝′1′then

                block1_in.tag＜＝0；

                block1_in.val＜＝pc；

                --we＜＝′0′；

              else

                ram_out＜＝block1_out；

                --we＜＝′1′；

                pc＜＝(pc+1)mod 512；

                addr＜＝(pc+1)mod 512；

              end if；

            end if；

          led1_value：＝not led1_value；

          led2_value：＝not led2_value；

          led1＜＝led1_value；

          led2＜＝led2_value；

      end case；

    end if；
  end process；
end architecture behavioural；
library ieee；
use ieee.std_logic 1164.all；
package hwprocl_package is
  subtype nibble is integer range 0 to 15；
  type word36 is

    record

      tag：nibble；
        <!-- SIPO <DP n="29"> -->
        <dp n="d29"/>
      val：natural；

    end record；
  subtype memory_block_address is natural range 0 to 511；
  constant num_processors：positive：＝8；
  type control is(request，grant，no_grant，word2)；
  type ext_chans is array(1 to num_processors-1)of word36；
  component hwprocl is

    port(signal clk，rst：in std_logic；

           signal led1，led2：out std_logic；

           signal ram_out：out word36)；
  end component hwprocl；
end package hwprocl_package；
        <!-- SIPO <DP n="30"> -->
        <dp n="d30"/>
library ieee；
use ieee.std_logic_1164.all；
use work.hwprocl_package.all；
entity memory_block is
  port(signal do：out word36；

         signal addr：in memory_block_address；

         signal clk：in std_logic；

         signal di：in word36；

         en，we：in std_logic)；
end entity memory_block；
        <!-- SIPO <DP n="31"> -->
        <dp n="d31"/>
        library ieee；

        use ieee.std_logic_1164.all；

        use ieee.std_logic_arith.all；

        use ieee.std_logic_unsigned.all；

        library unisim；

        use unisim.vcomponents.all；

        architecture memory_organization of memory_block is

          signal ssr：std_logic：＝′0′；

          signal addr_vec：std_logic_vector(8 downto 0)；

          signal di_vec，do_vec：std_logic_vector(31 downto 0)；

          signal dip_vec，dop_vec：std_logic_vector(3 downto 0)；

        begin

          block_ram：ramb16_s36

                       generic map(

        init_00＝＞
X″00000001000000FE00000000000000080000000100000000000000040000000B″，

        init_01＝＞
X″0000000000000000000000000000000000000000000000000000000200000000″，

        initp_00＝＞
X″0000000000000000000000000000000000000000000000000000090B00146600″，

                          srval＝＞X″0″)

                          port map(do＝＞do_vec，dop＝＞dop_vec，

                          addr＝＞addr_vec，clk＝＞clk，

                          di＝＞di_vec，dip＝＞dip_vec，en＝＞en，ssr＝＞ssr，

                          we＝＞we)；

       addr_vec＜＝conv_std_logic_vector(addr，9)；

       di vec＜＝conv_std_logic_vector(di.val，32)；

       dip_vec＜＝conv_std_logic_vector(di.tag，4)；

       do.val＜＝conv_integer(do_vec)；

       do.tag＜＝conv_integer(dop_vec)；
        <!-- SIPO <DP n="32"> -->
        <dp n="d32"/>
end architecture memory_organization；
        <!-- SIPO <DP n="33"> -->
        <dp n="d33"/>
library ieee；
use ieee.std_logic_1164.all；
use work.hwprocl_package.all；
package memory_package is
  component memory_block is

    port(signal do：out word36；

           signal addr：in memory_block_address；

           signal clk：in std_logic；

           signal di：in word36；

           en，we：in std_logic)；
  end component memory_block；
end package memory_package；
        <!-- SIPO <DP n="34"> -->
        <dp n="d34"/>
package debug_package is
  procedure trace(message：in string)；
end package debug_Package；
package body debug_Package is
  procedure trace(message：in string)is
  begin

    null；
  end procedure trace；
end package body debug_Package；
        <!-- SIPO <DP n="35"> -->
        <dp n="d35"/>
entity sim_hwprocl is
end entity sim_hwprocl；
library ieee；
use ieee.std_logic_1164.all；
use work.hwprocl_package.all；
architecture simulation of sim_hwprocl is
  signal clk，rst，led1，led2：std_logic；
begin
  hwprocl_l：hwprocl port map(clk，rst，led1，led2)；
  clocking：process
  begin

    rst＜＝′1′；

    wait for 10 ns；

    rst＜＝′0′；

    loop

      clk＜＝′0′；

      wait for 10 ns；

      clk＜＝′1′；

      wait for 10 ns；

    end loop；
  end process clocking；
end architecture simulation；
        <!-- SIPO <DP n="36"> -->
        <dp n="d36"/>
library ieee；
use ieee.std_logic_1164.all；
use work.hwprocl_package.all；
entity task_memory_block is
  port(signal task_addr_out，task_frame_out：out natural；

         signal addr：in memory_block_address；

         signal clk：in std_logic；

         signal task_addr_in，task_frame_in：in natural；

         en，we：in std_logic)；
end entity task_memory_block；
library ieee；
use ieee.std_logic_1164.all；
use ieee.std_logic_arith.all；
use ieee.std_logic_unsigned.all；
library unisim；
use unisim.vcomponents.all；
architecture memory_organization of task_memory_block is
  signal ssr：std_logic：＝′0′；
  signal addr_vec：std_logic_vector(8 downto 0)；
  signal task addr_in_vec，task_addr_out_vec：std_logic_vector(31 downto 0)；
  signal task_frame_in_vec，

           task_frame_out_vec：std_logic_vector(31 downto 0)；
  signal zero4：std_logic_vector(3 downto 0)；
begin
  zero4＜＝(others＝＞′0′)；
  task_addr_mem：ramb16_s36

              port map(do＝＞task_addr_out_vec，

                         addr＝＞addr_vec，clk＝＞clk，

                         di＝＞task_addr_in_vec，dip＝＞zero4，

                         en＝＞en，ssr＝＞ssr，

                         we＝＞we)；
        <!-- SIPO <DP n="37"> -->
        <dp n="d37"/>
    task_frame_mem：ramb16_s36

                port map(do＝＞task_frame_out_vec，

                           addr＝＞addr_vec，clk＝＞clk，

                           di＝＞task_frame_in_vec，dip＝＞zero4，

                           en＝＞en，ssr＝＞ssr，

                           we＝＞we)；
  addr_vec＜＝conv_std_logic_vector(addr，9)；
  task_addr_in_vec＜＝conv_std_logic_vector(task_addr_in，32)；
  task_frame_in_vec＜＝conv_std_logic_vector(task_frame_in，32)；
  task_addr_out＜＝conv_integer(task_addr_out_vec)；
  task_frame_out＜＝conv_integer(task_frame_out_vec)；
end architecture memory_organization；
        <!-- SIPO <DP n="38"> -->
        <dp n="d38"/>
library ieee；
use ieee.std_logic_1164.all；
use work.hwprocl_package.all；
package task_memory_package is
  component task_memory_block is

    port(signal task_addr_out，task_frame_out：out natural；

           signal addr：in memory_block_address；

           signal clk：in std_logic；

           signal task_addr_in，task_frame_in：in natural；

           en，we：in std_logic)；
  end component task_memory_block；
end package task_memory_package；

Claims

1.一种计算机处理器系统，包括：

至少一个处理器，所述处理器包括适用于执行基于π演算原语的硬件指令的电子电路。

2.如权利要求1所述的计算机处理器系统，其特征在于，所述π演算原语是异步π演算原语。

3.如权利要求1所述的计算机处理器系统，其特征在于，所述至少一个处理器还包括多个电子电路，所述多个电子电路中的每一个都适用于执行基于对应的一组π演算原语的一组硬件指令中的相应的一个。

4.如权利要求3所述的计算机处理器系统，其特征在于，所述一组硬件指令包括用于异步发送一对字的指令和从通道读取一对字的指令。

5.如权利要求4所述的计算机处理器系统，其特征在于，所述用于异步发送一对字的指令至少部分地基于本文附录中所提供的对SEND2指令的硬件定义语言描述。

6.如权利要求4所述的计算机处理器系统，其特征在于，所述用于从通道读取一对字的指令至少部分地基于本文附录中所提供的对RECEIVE2指令的硬件定义语言描述。

7.如权利要求4所述的计算机处理器系统，其特征在于，所述一组硬件指令包括以下的至少一个：

用于动态地创建新通信通道的指令；

用于监听一通道列表，随后当所述通道列表中的通道之一上出现数据时执行动作的指令；

用于向所述处理器上运行的一进程列表添加新进程的指令；

用于产生新进程来处理在通道上接收到的数据值的指令；以及

用于停止进程的执行的指令。

8.如权利要求7所述的计算机处理器系统，其特征在于，所述用于动态地创建新通信通道的指令至少部分地基于本文附录中所提供的对NEW指令的硬件定义语言描述。

9.如权利要求7所述的计算机处理器系统，其特征在于，所述用于监听一通道列表的指令至少部分地基于本文附录中所提供的对SELECT指令的硬件定义语言描述。

10.如权利要求7所述的计算机处理器系统，其特征在于，所述用于添加新进程的指令至少部分地基于本文附录中所提供的对PAR指令的硬件定义语言描述。

11.如权利要求7所述的计算机处理器系统，其特征在于，所述用于产生新进程的指令至少部分地基于本文附录中所提供的对SERVE指令的硬件定义语言描述。

12.如权利要求7所述的计算机处理器系统，其特征在于，所述用于停止进程的执行的指令至少部分地基于本文附录中所提供的对HALT指令的硬件定义语言描述。

13.一种在计算机中使用的电路板，所述电路板包括：

多个处理器，所述多个处理器中的每一个都适用于执行基于对应的一组π演算原语的一组硬件指令中相应的一个；以及

连接到所述多个处理器中的每一个的存储器。

14.如权利要求13所述的电路板，其特征在于，所述存储器是双端口存储器。

15.如权利要求14所述的电路板，其特征在于，所述双端口存储器表示在消息传递系统中使用的通道。

16.如权利要求15所述的电路板，其特征在于，所述双端口存储器担当用于程序和数据的高速缓存。

17.如权利要求13所述的电路板，其特征在于，所述存储器是经由SDRAM控制器来访问的。

18.如权利要求17所述的电路板，其特征在于，所述SDRAM控制器管理与较大存储器的通信。

19.如权利要求13所述的电路板，其特征在于，还包括提供与硬件资源的连接的一个或多个通道。

20.如权利要求13所述的电路板，其特征在于，还包括交换网络，所述多个处理器可经由所述交换网络访问另一个处理器所拥有的通道。

21.如权利要求13所述的电路板，其特征在于，所述多个处理器是用现场可编程门阵列实现的。

22.如权利要求13所述的电路板，其特征在于，所述多个处理器是用硅片实现的。

23.一种计算机处理器系统，包括：

通信通路；以及

独立地耦合到所述通信通路的多个处理器，其中，所述多个处理器中的每一个都适用于执行基于对应的一组π演算原语的一组硬件指令中相应的一个。

24.如权利要求23所述的系统，其特征在于，还包括：

耦合到所述通信通路的处理服务，其中，所述多个处理器中的每一个都可经由所述通信通路访问所述处理服务。

25.如权利要求23所述的系统，其特征在于，还包括：

耦合到所述通信通路的存储器，其中，所述多个处理器中的每一个都可经由所述通信通路访问所述存储器。

26.如权利要求23所述的系统，其特征在于，还包括：

耦合到所述通信通路的存储器，其中所，述多个处理器中的每一个都可经由所述通信通路对所述存储器进行读或写。

27.一种用于执行硬件指令的处理器，所述处理器包括：

多个电子电路，其中，所述多个电子电路中的每一个都至少部分地由本文附录中所提供的硬件定义语言语句中的一个来定义。