CN1661558A - 基于程序代数的硬件编译器设计方法 - Google Patents

Abstract

本发明公开了一种基于程序代数的硬件编译器设计方法，采用相同的语义形式化方法来定义不同的规范，具体步骤如下：首先，根据资源模型对每条程序进行运算资源预编译，使转化后的程序不违反资源限制；根据硬件编译子句对上面所述步骤转换后的程序进行硬件编译，生成各功能模块的硬件范式；连接各功能模块硬件范式成为能满足系统硬件部分功能的硬件网表；根据厂商提供的网表文件格式，将硬件范式映射为相应的网表文件。它能实现正确性可证明地将系统级描述语言编译为底层芯片的网表，并将资源信息引入不同层次的描述语言中，建立有资源的程序模型。本发明可用于嵌入式实时系统开发设计。

Description

基于程序代数的硬件编译器设计方法

技术领域

本发明涉及一种嵌入式实时系统开发方法，特别是涉及一种基于程序代数的硬件编译器设计方法。

背景技术

嵌入式系统设计通常包含软件设计与硬件设计。在软件运行环境下，微控制器是唯一的运算资源，它顺序地一条一条执行指令。所有的软件程序都最终被编译为顺序的指令流。要实现多任务并发必须通过分时方式在各任务间切换；要及时响应环境信号则必须中断当前任务，在完成相应的处理后恢复原先的工作。因此并发性与实时交互能力差是软件实现的不足。软件实现的优势表现在程序编写的抽象性。由于运行环境单一，程序员可以较少地考虑微控制器的具体特征，用高级语言给出所需要的程序。相比之下，硬件实现的特点是并发性能强。因为只要存在电位差，线路上就会有电流通过。因此可以自由地组合元器件和线路，使多个功能模块同时工作。为这一自由付出的代价是硬件设计人员必须非常了解所有元器件的特性，并在低抽象层次上工作。虽然随着电子设计自动化技术的发展，硬件描述语言(如VHDL与Verilog)被广泛应用于芯片结构的设计，但仍无法达到软件语言的抽象层次。

由于抽象层次的不同，软硬件分立的设计方法不利于整个系统的行为与性能分析。它驱使人们寻找软硬件协同设计技术。而该技术的先决条件是有软硬件协同设计语言。由于最终运行环境的不确定，该语言必须具有相当的抽象层次。它描述的仅仅是系统的行为与功能，底层的运算资源信息应该越少越好。但要让一个系统真正能够可靠运行，还是要将系统级描述转换为与目标平台相适应的低层描述，并且保证用低层描述给出的系统完全实现了高层描述的功能。

以往所说的编译指的都是将高级语言描写的程序翻译为微控制器机器指令，仍然是软件到软件的编译。而在软硬件协同设计中，从用系统级协同设计语言描述的进程规范到硬件元件连接表(网表)的编译，则是需要解决的问题之一。它涉及两个方面的内容：

一是要简洁解决编译器的正确性。通常，软件编译含有语法检验、语义检验、代码生成、代码连接、代码优化等诸多内容。在硬件编译器设计中编译是指代码生成。编译器本质上是一个文本翻译过程。  与其他软件不同的是，编译生成的新程序，在目标环境下运行必须优于或至少和原程序规范的一致。编译器不能在程序翻译过程中引入错误。

McCarthy和Painter(J.McCarthy and J.Painter.Correctness of a Compiler forArithemetic Expressions.In Proceedings of Symposium on Applied Mathematics，Pages33-41，American Mathematics Society，1967)最早于1967年率先提出用操作语义的方法来验证简单表达式的编译正确性。代数方法的应用则源自Burstall和Landin

(R.Burstall and P.Landin.Programs and their Proofs：an Algebraic Approach.Machine Intelligence，7：17-43，1969)。从代数的角度看，正确编译器的原理如图1所示。该交换图是Morris(F.Morris.Advice on Structuring Compilers and Proving themCorrect.SIGACT/SIGPLAN Symposium on Principles of Programming Languages，page 144-152，ACM，1973)在Burstall和Landin的工作基础上引入的。图1中点为代数概念，箭头为同态映射，φ和ψ为语义函数。解码映射表明编译产生的目标程序的语义应能充分表达源程序的语义，而非两者确切的相等。当然，也可用从源程序语义到目标程序语义上的译码映射来替换解码映射。

与图1类似的交换图也可用于基于指称语义的编译器证明。Polak(W.Polak.Compiler Specification and Verification，LNCS 124，Springer-Verlag1981.)不仅使用图1的风格，还用了图1的符号来表示指称语义。所不同的是，他的图较Morris的更简单，源程序与目标程序享有相同的语义函数模型，这样可直接比较两者的语义，而无须在语义层次引入解码/译码映射。

除了早期的代数分析方法，McCarthy和Painter的操作语义方法还带来了“解释器等价”的概念。解释器根据程序对运行时环境的影响给出源语言与目标语言的语义。两者的翻译函数是由它们运行环境间的关系刻画的。类似图1的交换图也可用于基于操作语义的方法。

尽管这些方法有这样那样的区别，但在表达编译器正确性方面有共同之处。如果不考虑对图1中点线名称定义的不同，它们的整体架构是一样的。换言之，为构造一个正确的编译器，需要如下条件：1.源语言与目标语言的文法；2.源语言与目标语言的语义模型；3.源语言与目标语言从文法到语义模型的语义函数；4.将源程序映射到目标程序的编译器；5.源语言与目标语言语义比较方法。所不同的是每个组件在各自体系中的定义。最新的编译器设计也未跳出这一框架。

即便人们对编译器有如此的共识，要简洁解决编译器的正确性问题仍是个挑战。必须确保当某些文本被替换为新文法形式下的文本时，后者所描写的模块功能需与前者保持一定的关系，通常称为精化关系。如果两者采用不同的语义形式化方法，问题将变得更复杂，还必须建立语义间的翻译。

二是要进行有资源限制程序模型的程序预编译。软硬件协同设计语言描述的仅是嵌入式系统的功能，不考虑具体目标平台的特性。一旦设定某功能模块应该用特定方式实现后，就要转换程序使之符合特定运行环境下运算模型与运算资源的限制。这一程序转换过程仍然要满足对编译的要求。即转换后的描述在功能上完全满足原规范的功能。所不同的是，该过程是为到最终目标平台编译做准备，而非最终编译，转换后的程序与源程序有相同的文法形式。该过程被称为预编译。

发明内容

本发明解决的技术问题是提供一种基于程序代数的硬件编译器设计方法，它能实现正确性可证明地将系统级描述语言编译为底层芯片的网表，并将资源信息引入不同层次的程序规范中，建立有资源的程序模型。

为解决上述技术问题，本发明基于程序代数的硬件编译器设计方法，采用相同的语义形式化方法来定义不同的规范，具体步骤包括：

首先，根据资源模型对每条程序进行运算资源预编译，使转化后的程序不违反资源限制；

根据硬件编译子句对上面所述步骤转换后的程序进行硬件编译，生成各功能模块的硬件范式；

连接各功能模块硬件范式成为能满足系统硬件部分功能的硬件网表；根据厂商提供的网表文件格式，将硬件范式映射为相应的网表文件。

所述硬件编译子句为：

1.|[skip]

<s，f.delay(s)，f>

2.|[wait(n)]

<s，f.srl(s，n)，f>

  |[x：＝Exp] <s，C，f>

3.

  if $C=\left(\begin{array}{c}f.\mathrm{delay}\left(s\right)\\ x.\mathrm{latch}(s,\mathrm{Exp})\end{array}\right)$

  |[P；Q] <s，C，f>

  if  |[P]

<s，C1，h>

4.

      ∧|[Q] <h，C2，f>

      ∧C＝C2&C1

      |[if B then Pelse Q] <s，C，f>

          

          

5.

      if

          

  |[while B do P]

<s，C，f>

      |[P]

<s1，C1，f1>

6.

  if  

  |[Ch？x]

<s，C，f>

7.

  if  

                   |[Ch！x] <s，C，f>

8.

  if  

       |[par{P：Q}] <s，C，f>

           |[P]

<s，C1，f1>

       if  ∧|[Q] <s，C2，f2>

9.

          

  |[alt{g1-＞P1：g2-＞P2}]

<s，C，f>

  if  |[P1]

<s1，f1.delay(F1)&C1，f1>

      ∧|[P2]

<s2，f2.delay(F2)&C2，f2>

10.

     

      |[alt{wait(n1)∷g1-＞P1:wait(n2)∷g2-＞P2}] <s，C，f>

      if  |[P1] <s1，f1.delay(F1)&C1，f1>

          ∧|[P2] <s2，f2.delay(F2)&C2，f2>

11.

         

应用上述方法，可实现系统规范到硬件范式网表的映射。所述根据资源模型对每条程序进行运算资源预编译，包括如下步骤：

根据同质资源限制预编译子句对表达式预编译；

根据算术资源数量限制预编译子句对表达式预编译；

根据内存访问冲突限制预编译子句对表达式预编译。

所述同质资源限制预编译子句为：

1.PCE(Exp，skip，Exp，φ，ET)

  if A(Exp，ET)

  PCE(op Exp，L，op x，{x}∪V，ET)

2.

     ～A(Exp，ET)

  if

     ∧x：＝Exp

var V；L；end V

  PCE(Exp1 op Exp2，L，Exp1 op x，{x}∪V ET)

     EC(op)＝0

3.

     ∧ET(Exp1)＝0

  if

     ∧ET(Exp2)＞0

     ∧x：＝Exp2 var V；L；end Var

  PCE(Exp1 op Exp2，L，x op Exp2，{x}∪V ET)

     EC(op)＝0

4.

     ∧ET(Exp1)＞0

  if

     ∧ET(Exp2)＝0

     ∧x：＝Exp1 var V；L；end Var

  PCE(Exp1 op Exp2，L1；L2，x op y，V1∪V2∪{x，y} ET)

     EC(op)＝0

     ∧ET(Exp1)＞0

5.

  if ∧ET(Exp2)＞0

     ∧x：＝Exp1

var V1；L1；end V1

     ∧y：＝Exp2 var V2；L2；end V2

  PCE(Exp1 op Exp2，L2；，Exp1 op y，V2∪{y} ET)

     EC(op)＞0

6.

     ∧ET(Exp1)＝φ

  if

     ∧Req(Exp2)≠φ

     ∧y：＝Exp2

var V2；L2；end V2

  PCE(Exp1 op Exp2，L1；，x op Exp2，V1∪{x} ET)

     EC(op)＞0

7.

     ∧ET(Exp1)≠φ

  if

     ∧Req(Exp2)＝φ

     ∧x：＝Exp1 var V1；L1；end V1

  PCE(Exp1 op Exp2，L1；L2，x op y，V1∪V2∪{x，y} ET)

     EC(op)＞0

     ∧Req(Exp1)≠φ

8.

  if ∧ET(Exp2)≠φ

     ∧x：＝Exp1

var V1；L1；end V1

     ∧y：＝Exp2 var V2；L2；end V2

所述算术资源数量限制预编译子句为：

1.PCE(Exp，skip，Exp，φ，R)

  if  Exp是常量或变量

  PCE(op Exp1，Q，op Exp2，V，R)

2.

     res(R，op)≥1

  if

     ∧PCE(Exp1，Q，Exp2，V，R-{(op，1)})

  PCE(op Exp2，Q，x V，R)

3.

     res(R，op)＝0

  if

     ∧x：＝op Exp2＜＝var V，Q，end V

  PCE(Exp1 op Exp2，Q，Exp12 op Exp22，V，R)

     res(R，op)≥1

     ∧PCE(Exp1，Q1，Exp12，V1，R-{(op，1)})

4.

  if ∧PCE(Exp2，Q2，Exp22，V2，R-{(op，1)}-Req(Exp12))

     ∧V＝V1∪V2

     ∧Q＝Q1；Q2

  PCE(Exp1 op Exp2，Q，x V，R)

5.

     res(R，op)＝0

  if

     ∧x：＝Exp1 op Exp2＜＝var V，Q，end V

所述内存访问冲突限制预编译子句为：

1.PCE(Exp，skip，Exp，φ，M)

  if  Exp是常量或变量

2.PCE(a[i]，skip，a[i]，φ，M)

  if (M+{a})↓1＝(M+{a})

3.PCE(a[i]，x：＝a[i]，x，{x}，M)

  if (M+{a})↓1≠(M+{a})

4.PCE(op Exp，op Exp1，V，M)

  if PCE(Exp，L，Exp1，V，M)

  PCE(Exp1 op Exp2，L1；L2，Exp12 op Exp22，V1∪V2，M)

5.

      PCE(Exp1，L1，Exp12，V1，M)

  if

      ∧PCE(Exp2，L2，Exp22，V2，M+mac(Exp12))

根据本发明的设计方法可安全可靠地将系统级程序编译为芯片网表。

附图说明

下面结合附图和具体实施方式对本发明作进一步详细的说明：

图1是正确编译器的原理交换图；

图2是本发明硬件编译流程图；

图3是本发明资源模型下的表达式预编译流程图。

具体实施方式

如图2所示，本发明基于程序代数的硬件编译器设计方法，采用相同的语义形式化方法来定义不同的规范，具体步骤包括：

首先，根据资源模型对每条程序进行运算资源预编译，使转化后的程序不违反资源限制；

根据硬件编译子句对上面所述步骤转换后的程序进行硬件编译，生成各功能模块的硬件范式；

连接各功能模块硬件范式成为能满足系统硬件部分功能的硬件网表；

根据厂商提供的网表文件格式，将硬件范式映射为相应的网表文件。

在本发明的语义模型中首先定义αP，它是进程P的字符集，即P中所有可观察变量的集合。x表示进程开始时变量取值，x′表示进程结束时观测到的变量值。进程的行为可表示为 $\left|\right[P\left]\widehat{=}{A}_P\right|-C_P,$ A_P是进程P开始时的假设，只有αP中的变量满足该假设，进程P才能运行；C_P是进程结束时的承诺，即在P结束时αP中变量的值应满足的关系。|[P]|(v/x)表示用v的值替换进程P中x的值。虽然系统级程序与硬件元器件有不同的物理表现形式，但它们的功能都可用这种方法来描述。

本发明设定进程P可完全满足进程Q的功能，当且仅当在任何输入参数下，P的行为都与Q的一致。即_v，v′·|[P]_|[Q]。本发明硬件编译器的功能就是根据系统级规范S产生特定的元件组合C，使得C完全能满足S的功能。

在本发明中系统级描述语言定义为：

P∷＝skip|wait(n)|x：＝Exp|P；Q |Ch？x|Ch！x|var x|end x

      |if B then then P esle Q |while B do P

      |alt {g1-＞P1：g2-＞P2：...gn-＞pn}

      |alt {wait(t1)∷g1-＞P1：wait(t2)∷g2-＞P2：…wait(tn)∷gn-＞Pn}

其中：

skip表示进程跳跃一个时钟，除时间t外其他的变量都不变；

wait(n)表示进程跳跃n个时钟，除时间t外其他的变量都不变；

x：＝Exp表示将Exp的值赋给变量x；

var x在进程中引入一个新的变量x；

end x在进程结束变量x的使用；

P；Q表示在执行进程P之后，再执行进程Q；

Ch？x表示从同步通道Ch中输入x；

Ch！e表示从同步通道Ch中输出ex；

if B then P else Q表示条件判断，如果B是真则执行进程P，否则执行进程Q；

while B do P表示只要B为真就一直执行进程P，否则停止；

alt {g1-＞P1：g2-＞P2：…gn-＞pn}表示有多个进程Pi等待被激发，gi是Pi的激发条件，一旦某个进程被激活，其他进程就不能再被激活；

alt {wait(t1)∷g1-＞P1：wait(t2)∷g2-＞P2：…wait(tn)∷gn-＞Pn}是有时间限制的多进程等待程序。激发条件gi只有在相应的ti时间内有效。如果所有的进程在限制时间内都未被激活，则停止。以上这些语句被定义如下：

$\left|\right[\mathrm{var\; x}]\widehat{=}\&Exists;x\&CenterDot;|\left[\mathrm{skip}\right]$

$\left|\right[\mathrm{end\; x}]\widehat{=}\&Exists;x^{\&prime;}\&CenterDot;|\left[\mathrm{skip}\right]$

                                   t＜t′∧trace(t)＝<>∧～Ch.outready(t)∧～Ch.synch(t)t＜τ∧trace(t)＝<>∧～Ch.outready(t)∧～Ch.synch(t)∨t∈[τ，t′)∧Ch.outready(t)∧Ch.synch(t)∧trace(t)＝<Ch.x′>∧y′＝y∧...z′＝z

t＜t′∧trace(t)＝<>∧～Ch.outready(t)∧～Ch.synch(t)t＜τ∧trace(t)＝<>∧Ch.outready(t)∧～Ch.synch(t)∨t∈[τ，t′)∧Ch.synch(t)∧trace(t)＝<Ch.e>∧x′＝x∧y′＝y∧...z′＝z

对于硬件元器件，本发明规定如下：

1.只有在一个时钟开始与结束的时候，元件输入端输出端的值可被观察；

2.元件只有两种观测值，即低电平和高电平。

在本发明中有如下元器件：

x.comb(Exp)：表示组合线路，无论何时，线路x上的值都等于表达式Exp的值；

l.delay(Exp)：表示延时线路，l在一个时钟开始时寄存Exp在上个时钟结束时的值；

d.latch(S，Exp)：表示寄存器，在一个时钟开始时若S为真，d寄存Exp在上个时钟结束时的值；否则d的值不变。

c.in：是一个特殊的组合线路，但c是与芯片外的线路相连，c的取值由芯片外的信号决定；

d.out(D)：是一个特殊的组合线路，但d是与芯片外的线路相连，d将芯片内D的取值输出到芯片外；

r.srl(s，n)：是一个移位寄存器，在n个时钟延迟之后，r才取得s的值；

x.mux(s，D0，D1)：是一个多路器，当s为低电平时，m取D0的值，否则取D1的值；

m.mem(s，we，AD，DI)：是存储器，当s，we均为高电平时，在存储器的地址AD处写入DI的值，在下个周期开始时m取DI的值；当s为高电平时，we为低电平时，在下个周期开始时m取地址为AD的存储单元的值。

这些元件可用下面的方法进行定义：

$x.\mathrm{comb}\left(\mathrm{Exp}\right)\widehat{=}\&ForAll;t\&CenterDot;x\left(t\right)=\mathrm{Exp}\left(t\right)$

$l.\mathrm{delay}\left(\mathrm{Exp}\right)\widehat{=}\&ForAll;t\&CenterDot;l\left(t\right)=\mathrm{Eep}(t-1)$

$r.\mathrm{srl}(s,n)\widehat{=}r\left(t\right)=s(t-n)$

                                        s(t-1)∧we(t-1)∧DI(t-1)m(t)＝∨s(t-1)∧～we(t-1)∧mem(AD(t-1))∨m(t-1)∧mem(AD(t-1))(t)＝s(t-1)∧we(t-1)∧DI(t-1)

线路的连接相当自由，只要某元件的输入与另一元件的输出相连就可组成电路C。

为了规范线路，本发明定义了一种特殊的元件连接方式，称为硬件范式<s，C，f>。其中C是一些相连的元件，s是高电平时C开始运行，f是高电平表明C已完成工作。<s，C，f>应满足下面的条件：

1.f不能连接到C中元件的输入端；

2.d.latch(S，Exp)中Exp满足Exp＝S∧Exp

3.当l，w，s为低电平时，L，W，d，S的值都是低电平。

当要组合两个线路C1，C2时，应如下组合它们的寄存器与输出电路。

                   {l1.latch(s1，E1)|l1∈C1∧l1 

C2}

l.latch(S，E)＝&{l1.latch(s1∨s2，E1∧E2)|l1∈C1∩C2}

                &{l.latch(s2，E2)|l2∈C2∧l2

C2}

            {d1.out(D1)|d1∈C1∧d1 C2}

d.out(D)＝ &{d.out(D1∧D2)|d1∈C1∩C2}

          &{d2.out(D2)|d2∈C2∧d2

C2}

这一特殊的元件连接方式<s，C，f>其行为可被形式化定义为：

                var s，f，l，w；

                    Init；

<s，C，f>

while～f do step；

                    Final；

                end s，f，l，w

Init      s，f，l，w，c，d：∈s′＝1∧f′＝0∧l′＝0∧d′＝D∧w′＝W

step

 s，f，l，w，c，d，x：∈s′＝0∧f′＝1∧l′＝L∧x′＝X

B

x∧w′＝W

Final

                       (～l∧～w)_⊥

其中：

Init是线路初始化，在该阶段结束时，取值低电平、取值高平、其它组合线路与输出的取值由相应表达式决定；

step是以一个时钟周期为执行时间的元件的行为；

final表示当C完成工作时，所有的延时电路与组合电路的输出都应是低电平，否则会造成线路运行的混乱。

由此可见，硬件范式<s，C，f>大大限制了元件连接组合的随意性，特别是排斥了组合线路中反馈的可能，增强了电路运行时的顺序性。这种受限制的元件的连接方式带来的好处是，可以用软件的形式化方法来描述元件组合的功能，从而可以建立系统级规范描述的进程与电子线路的联系。这样硬件电路与程序语言的鸿沟被跨越了，可以检验<s，C，f>是否满足P的功能。一个正确的编译就是要使最终的<s，C，f>_|[P]。

根据这样的理论基础，可以获得如下硬件编译子句：

1.|[skip] <s，f.delay(s)，f>

2.|[wait(n)] <s，f.srl(s，n)，f>

  |[x：＝Exp] <s，C，f>

3.

  if $C=\left(\begin{array}{c}f.\mathrm{delay}\left(s\right)\\ x.\mathrm{latch}(s,\mathrm{Exp})\end{array}\right)$

  |[P；Q]

<s，C，f>

  if |[P]

<s，C1，h>

4.

       ∧|[Q] <h，C2，f>

       ∧C＝C2&C1

  |[if B then Pelse Q] <s，C，f>

      

      

5.

  if

      

  |[while B do P] <s，C，f>

    |[P] <s1，C1，f1>

6.

  if

    

  |[Ch？x]

<s，C，f>

7.

  if

                 |[Ch！x]

<s，C，f>

8.

  if

  |[par{P：Q}]

<s，C，f>

      |[P] <s，C1，f1>

  if  ∧|[Q]

<s，C2，f2>

9.

  

  |[alt{g1-＞P1：g2-＞P2}]|

<s，C，f>

  if   |[P1] <s1，f1.delay(F1)&C1，f1>

       ∧|P2] <s2，f2.delay(F2)&C2，f2>

10.

      

    |[alt{wait(n1)∷g1-＞P1：wait(n2)∷g2-＞P2}]

<s，C，f>

    if   |[P1] <s1，f1.delay(F1)&C1，f1>

         ∧|[P2]

<s2，f2.delay(F2)&C2，f2>

11.

        

由于整个体系的简洁性，采用上述方法用逻辑编程语言Prolog就可以开发硬件编译器，实现到语句网表编译。

如图3所示，所述根据资源模型对每条程序进行运算资源预编译，包括如下步骤：

根据同质资源限制预编译子句对表达式预编译；

根据资源数量限制预编译子句对表达式预编译；

根据内存访问冲突限制预编译子句对表达式预编译。

本发明定义的有资源限制程序模型为：

$|{\left[P\right]}_{\mathrm{XE}}\widehat{=}A(P,E)\&DoubleRightArrow;|\left[P\right]$

其中，A(P，E)为某资源限制，只有当A(P，E)为真时|[P]_XE才与|[P]一致。若P为源程序，Q为转换后的程序，则正确的预编译应该是|[Q]|_XE_|[P]|。

本发明给出的是将系统级程序转换为满足芯片元件特性限制程序的资源预编译方法。尤其是表达式的预编译。为此给出预编译程序模块PCE(Exp，Q，Exp2，V，E)，这里Exp是源表达式，Q是新产生的程序，Exp2是转换后的表达式，V新产生的变量，E是某种环境资源限制。

对程序构造，本发明有如下的预编译子句：

skip skip

wait(n)

wait(n)

P；Q P1；Q1

     P

P1

if

     ∧Q Q1

x：＝Exp x：＝Exp

if   A(Exp，E)

x：＝Exp

var V；Q；x：＝Exp2；end V

     ～A(Exp，E)

if

     ∧PCE(Exp，Q，Exp2，V，E)

if   BExp then P else Q if BExp then P1 else Q1

     A(BExp，E)

if   ∧P

P1

     ∧Q

Q1

if BExp then P else  Q

var V；Q；Q；if BExp2 then P1 else Q1；end V

    ～A(BExp，E)

    ∧PCE(BExp，Q，BExp2，V，E)

if

    ∧P

P1

    ∧Q

Q1

while BExp do P while BExp do P1

    A(BExp，E)

if

    ∧P P1

while BExp do P

var V；Q；while BExp2 do (P；Q) end V

    ～A(BExp，E)

if  ∧PCE(BExp，Q，BExp2，V，E)

    ∧P

P1

par{P1：P2：…Pn}

Par｛Q1：Q2：...Qn｝

    P1 Q1

    ∧P2

Q2

if

    _

    ∧Pn

Qn

alt{g1→P1：g2→P2：...gn→Pn}

alt{g1→Q1：g2→Q2：...gn→Qn}

    P1

Q1

    ∧P2

Q2

if.

    _

    ∧Pn

Qn

alt{                     alt{

wait(t1)∷g1→P1：       wait(t1)∷g1→Q1：

wait(t2)∷g2→P2：   wait(t2)∷g2→Q2：

_                       _

wait(tn)∷gn→Pn}        wait(tn)∷gn→Qn}

    P1

Q1

    ∧P2 Q2

if

    _

    ∧Pn

Qn

在将源表达式编译为符合硬件特性的过程中，会遇到许多资源限制问题。

首先，给出算术资源数量限制下的预编译方法。

所谓算术资源数量限制即芯片内的加法器，乘法器，比较器和其它算术运算模块的数量。如果表达式要求的资源多于系统可提供的资源数目，则不能正确计算表达式的值。为此先定义一种数据类型Res：{(Name，t)|t≥0}，这里Name是运算资源名，t是资源个数。函数res：Res×Name-＞N提取以Res为类型的变量中名称为Name的资源个数。Res有如下运算：

      res(r1+r2，n)＝res(r1，n)+res(r2，n)

      res(r1∪r2，n)＝max{res(r1，n)，res(r2，n)}

      res(r1-r2，n)＝max{res(r1，n)-res(r2，n)，0}

      res(r1∩r2，n)＝min{res(r1，n)-res(r2，n)}

同时有资源间的比较关系_：Res×Res-＞Bool，

$R1\&SubsetEqual;R2\widehat{=}\&ForAll;\mathrm{name}\&CenterDot;\mathrm{res}(R1,\mathrm{Name})\&le;\mathrm{res}(R2,\mathrm{Name})$

函数Req：Exp-＞Res提取表达式中的各种资源个数，表达式Exp是可运算的，当且仅当谓词

$A(\mathrm{Exp},R)\widehat{=}\mathrm{Req}\left(\mathrm{Exp}\right)\&SubsetEqual;R$ 成立，在运算资源数量的限制下，则有如下的预编译子句：

1.PCE(Exp，skip，Exp，φ，R)

  if  Exp是常量或变量

  PCE(op Exp1，Q，op Exp2，V，R)

2.

     res(R，op)≥1

  if

     ∧PCE(Exp1，Q，Exp2，V，R-{(op，1)})

  PCE(op Exp2，Q，x V，R)

3.

     res(R，op)＝0

  if

     ∧x：＝op Exp2＜＝var V，Q，end V

  PCE(Exp1 op Exp2，Q，Exp12 op Exp22，V，R)

     res(R，op)≥1

     ∧PCE(Exp1，Q1，Exp12，V1，R-{(op，1)})

4.

  if ∧PCE(Exp2，Q2，Exp22，V2，R-{(op，1)}-Req(Exp12))

     ∧V＝V1∪V2

     ∧Q＝Q1；Q2

  PCE(Exp1 op Exp2，Q，x V，R)

5.

     res(R，op)＝0

  if

     ∧x：＝Exp1 op Exp2＜＝var V，Q，end V

其次，给出同质资源限制。根据硬件实现方式不同，有两类运算资源，组合逻辑资源与时序逻辑资源。组合逻辑资源可在一个时钟周期内给出运算结果，时序逻辑资源需要多个时钟周期才能获得运算资源，两种资源都不寄存运算结果。因此在一个表达式中不能出现两种不同质的资源，否则有可能在一个二目运算中，当通过一个资源计算出操作数时，另一个操作数已过期。为此，定义函数EC：Name→N和函数ET：Exp-＞N，EC给出的是每种资源的运算时间，ET给出的是表达式的运算时间。

ET(Exp)＝0

if表达式Exp是常量或变量

ET(op Exp)＝ET(Exp)+EC(op)

ET(Exp1 op Exp2)＝max(ET(Exp1)，ET(Exp2))+EC(op)

如果表达式包含异质资源，则谓词HCR：Exp→Bool成立。

HCR(Exp)＝false

if表达式Exp是常量或变量

              (ET(Exp1)＞0)∧EC(op)＝0

HCR(op Exp1)＝∨(Req(Exp1)≠φ)∧ET(Exp1)＝0∧EC(op)＞0

              ∨HCR(Exp1)

                   (ET(Exp1)＞0∨ET(Exp2)＞0)∧EC(op)＝0

HCR(Exp1 op Exp2)＝

                   ∨(Req(Exp1)≠φ∨Req(Exp2)≠φ)∧EC(op)＞0

这样，在本发明定义的有资源限制程序模型中同质运算资源条件可表示为：

                     A(Exp，ET)＝～HCR(Exp)

在此基础上，则有如下预编译子句：

1.PCE(Exp，skip，Exp，φ，ET)

  if A(xp，ET)

  PCE(op Exp，L，op x，{x}∪V，ET)

2.

     ～A(Exp，ET)

  if

     ∧x：＝Exp

var V；L；end V

  PCE(Exp1 op Exp2，L，Exp1 op x，{x}∪V ET)

     EC(op)＝0

3.

     ∧ET(Exp1)＝0

  if

     ∧ET(Exp2)＞0

     ∧x：＝Exp2 var V；L；end Var

  PCE(Exp1 op Exp2，L，x op Exp2，{x}∪V ET)

     EC(op)＝0

4.

     ∧ET(Exp1)＞0

  if

     ∧ET(Exp2)＝0

     ∧x：＝Exp1 var V；L；end Var

  PCE(Exp1 op Exp2，L1；L2，x op y，V1∪V2∪{x，y} ET)

     EC(op)＝0

     ∧ET(Exp1)＞0

5.

  if ∧ET(Exp2)＞0

     ∧x：＝Exp1 var V1；L1；end V1

     ∧y：＝Exp2 var V2；L2；end V2

  PCE(Exp1 op Exp2，L2；，Exp1 op y，V2∪{y} ET)

     EC(op)＞0

6.

     ∧ET(Exp1)＝φ

  if

     ∧Req(Exp2)≠φ

     ∧y：＝Exp2

var V2；L2；end V2

  PCE(Exp1 op Exp2，L1；，x op Exp2，V1∪{x} ET)

     EC(op)＞0

7.

     ∧ET(Exp1)≠φ

  if

     ∧Req(Exp2)＝φ

     ∧x：＝Exp1

var V1；L1；end V1

  PCE(Exp1 op Exp2，L1；L2，x op y，V1∪V2∪{x，y} ET)

     EC(op)＞0

     ∧Req(Exp1)≠φ

8.

  if ∧ET(Exp2)≠φ

     ∧x：＝Exp1

var V1；L1；end V1

     ∧y：＝Exp2 var V2；L2；end V2

最后，给出内存访问冲突限制的预编译子句。内存有两种操作，读取与写入。当从内存的一个单元中读取数据时，要在内存的地址端提供稳定的地址信息，在下个时钟开始时，内存数据输出端输出相应存储单元的数据。当要在内存某单元中写入数据时，除了地址信息，还要为数据输入端提供稳定的数据，写入操作也要一个周期的时间。如果在一个周期中，地址信息或数据信息不稳定，就得不到期望的结果，或称操作失败。因此对一个内存一个周期中只能有一次操作。否则称发生了内存访问冲突。在系统级表达式中，可以对同一内存有多次操作，本发

明的预编译子句要将这样的表达式转换为没有内存访问冲突的表达式计算。

为此，本发明定义数据类型MAC：{(Name，Cnt)| Cnt≥0}，这里Name是内存名，Cnt是该内存的被访问次数。

该数据类型有操作+：MAC×MAC→MAC。其定义如下：

                        {(name1，cnt1)|(name1，cnt1)∈ac1∧(name1，cnt1) ac2)}

ac1，ac2∈MAC·ac1+ac2＝∪{(name，cnt)|(name，cnt)∈ac1∧(name，cnt)∈ac2)}

                        ∪{(name2，cnt2)|(name2，cnt2) ac1∧(name2，cnt2)∈ac2)}

如果函数↓_N：MAC×N→MAC将被访问次数为N的内存提取出来。函数Mac(Exp)给出表达式Exp中所有的内存访问次数。一个无访问冲突的表达式应满足谓词 $A(\mathrm{Exp},M)\widehat{=}(\mathrm{mac}\left(\mathrm{Exp}\right)+M)\&DownArrow;1=\mathrm{mac}\left(\mathrm{Exp}\right)+M.$

这样，则有如下预编译子句：

1.PCE(Exp，skip，Exp，φ，M)

  if  Exp是常量或变量

2.PCE(a[i]，skip，a[i]φ，M)

  if (M+{a})↓1＝(M+{a})

3.PCE(a[i]，x：＝a[i]，x，{x}，M)

  if (M+{a})↓1≠(M+{a})

4.PCE(op Exp，L，op Exp1，V，M)

  if  PCE(Exp，L，Exp1，V，M)

  PCE(Exp1 op Exp2，L1；L2，Exp12 op Exp22，V1∪V2，M)

5.    PCE(Exp1，L1，Exp1 2，V1，M)

  if

      ∧PCE(Exp2，L2，Exp22，V2，M+mac(Exp12))

由于数组可出现在赋值语句赋值号的左边，本发明对赋值语句有特殊的预编译子句：

1.a：＝Exp  var V；L；a：＝Exp2；end V

  if  PCE(Exp，L，Exp2，φ，φ)

2.a[i]＝Exp  var V；L；a[i]＝Exp2；end V

  if  PCE(Exp，L，Exp2，φ，{(a，1)})

下面列举一个具体的实施例，对如何实现预编译子句进行详细的说明。Prolog是一种逻辑编程语言，主要用于逻辑推导。由于本发明是基于形式化的程序模型，因此可方便地借助Prolog实现本发明给出的预编译子句。

具体方法是先在Prolog中定义二目运算符 谓词A

B表示A和B具有关系 然后，用Prolog中的表结构[]实现元素间的先后关系。根据Prolog的编程规则，预编译子句

A B

     C1

     ∧C2

if

     _

     ∧Cn

相应的Prolog程序是：

A＜＝B：-

C1，

C2，

...

Cn.

例如子句：

|[P；Q] <s，C，f>

if |[P]

<s，C1，h>

   ∧|[Q] <h，C2，f>

   ∧C＝C2&C1

对应的程序是：

P；Q＜＝<s，C，f>：-

P＜＝<s，C1，h>，

Q＜＝<h，C2，f>，

append(C2，C1，C).

Claims (8)

1.一种基于程序代数的硬件编译器设计方法，采用相同的语义形式化方法来定义不同的规范语言，其特征在于：包括如下步骤：

首先，根据资源模型对每条程序进行运算资源预编译，使转化后的程序不违反资源限制；

根据硬件编译子句对上面所述步骤转换后的程序进行硬件编译，生成各功能模块的硬件范式；

连接各功能模块硬件范式成为能满足系统硬件部分功能的硬件网表；

根据厂商提供的网表文件格式，将硬件范式映射为相应的网表文件。

2.如权利要求1所述的基于程序代数的硬件编译器设计方法，其特征在于：所述根据资源模型对每条程序进行运算资源预编译，包括如下步骤：

根据同质资源限制预编译子句对表达式预编译；

根据算术资源数量限制预编译子句对表达式预编译；

根据内存访问冲突限制预编译子句对表达式预编译。

3.如权利要求1所述的基于程序代数的硬件编译器设计方法，其特征在于，所述硬件编译子句为：

$1.\left|\right[\mathrm{skip}]\&DoubleLeftArrow;<s,f.\mathrm{delay}\left(s\right),f>$

$2.\left|\right[\mathrm{wait}\left(n\right)]\&DoubleLeftArrow;<s,f.\mathrm{srl}(s,n),f>$

$\left|\right[x:=\mathrm{Exp}]\&DoubleLeftArrow;<s,C,f>$

$3.\mathrm{if\; C}=\left(\begin{array}{c}f.\mathrm{delay}\left(s\right)\\ x.\mathrm{latch}(s,\mathrm{Exp})\end{array}\right)$

$\left|\right[P;Q]$ $\&DoubleLeftArrow;<s,C,f>$

$4.\mathrm{if}\left|\right[P]\&DoubleLeftArrow;<s,C1,h>$

$\left|\right[\mathrm{if\; B\; then\; Pelse\; Q}]\&DoubleLeftArrow;<s,C,f>$

$\left|\right[\mathrm{while\; B\; do\; P}]\&DoubleLeftArrow;<s,C,f>$

$\left|\right[P]\&DoubleLeftArrow;<s1,C1,f1>$

$\left|\right[\mathrm{Ch}?x]\&DoubleLeftArrow;<s,C,f>$

$\left|\right[\mathrm{Ch}!x]\&DoubleLeftArrow;<s,C,f>$

$\left|\right[\mathrm{par}\{P:Q\}]\&DoubleLeftArrow;<s,C,f>$

$\left|\right[P]\&DoubleLeftArrow;<s,C1,f1>$

$\left|\right[\mathrm{alt}\{g1->P1:g2->P2\}]\&DoubleLeftArrow;<s,C,f>$

$\left|\right[\mathrm{alt}\{\mathrm{wait}\left(n1\right)::g1->P1:\mathrm{wait}\left(n2\right)::g2->P2\}]\&DoubleLeftArrow;<s,C,f>$

4.如权利要求1或2所述的基于程序代数的硬件编译器设计方法，其特征在于，所述同质资源限制预编译子句为：

1.PCE(Exp，skip，Exp，φ，ET)

  if A(Exp，ET)

2.PCE(op Exp，L，op x，{x}∪V，ET)

    ～A(Exp，ET)

if

3.PCE(Exp1 op Exp2，L，Exp1 op x，{x}∪V ET)

    EC(op)＝0

    ∧ET(Exp1)＝0

  if

    ∧ET(Exp2)＞0

4.PCE(Exp1 op Exp2，L，x op Exp2，{x}∪V ET)

    EC(op)＝0

    ∧ET(Exp1)＞0

  if

    ∧ET(Exp2)＝0

5.PCE(Exp1 op Exp2，L1；L2，x op y，V1∪V2∪{x，y} ET)

    EC(op)＝0

    ∧ET(Exp1)＞0

if  ∧ET(Exp2)＞0

6.PCE(Exp1 op Exp2，L2；，Exp1 op y，V2∪{y} ET)

    EC(op)＞0

    ∧ET(Exp1)＝φ

  if

    ∧Req(Exp2)≠φ

7.PCE(Exp1 op Exp2，L1；，x op Exp2，V1∪{x} ET)

    EC(op)＞0

    ∧ET(Exp1)≠φ

  if

    ∧Req(Exp2)＝φ

8.PCE(Exp1 op Exp2，L1；L2，x op y，V1∪V2∪{x，y} ET)

    EC(op)＞0

    ∧Req(Exp1)≠φ

  if∧ET(Exp2)≠φ

5.如权利要求1或2所述的基于程序代数的硬件编译器设计方法，其特征在于，所述算术资源数量限制预编译子句为：

1.PCE(Exp，skip，Exp，φ，R)

  if Exp是常量或变量

2.PCE(op Exp1，Q，op Exp2，V，R)

    res(R，op)≥1

  if

    ∧PCE(Exp1，Q，Exp2，V，R-{(op，1)})

3.PCE(op Exp2，Q，x V，R)

    res(R，op)＝0

  if

4.PCE(Exp1 op Exp2，Q，Exp1 2 op Exp22，V，R)

    res(R，op)≥1

    ∧PCE(Exp1，Q1，Exp12，V1，R-{(op，1)})

  if∧PCE(Exp2，Q2，Exp22，V2，R-{(op，1)}-Req(Exp12))

    ∧V＝V1∪V2

    ∧Q＝Q1；Q2

5.PCE(Exp1 op Exp2，Q，x V，R)

    res(R，op)＝0

  if

6.如权利要求1或2所述的基于程序代数的硬件编译器设计方法，其特征在于，所述内存访问冲突限制预编译子句为：

1.PCE(Exp，skip，Exp，φ，M)

  if Exp是常量或变量

2.PCE(a[i]，skip，a[i]，φ，M)

  if (M+{a})↓1＝(M+{a})

3.PCE(a[i]，x：＝a[i]，x，{x}，M)

  if M+{a})↓1≠(M+{a})

4.PCE(op Exp，L，op Exp1，V，M)

  if PCE(Exp，L，Exp1，V，M)

5.PCE(Exp1 op Exp2，L1；L2，Exp12 op Exp22，V1∪V2，M)

    PCE(Exp1，L1，Exp12，V1，M)

  if

    ∧PCE(Exp2，L2，Exp22，V2，M+mac(Exp12))

7.如权利要求6所述的基于程序代数的硬件编译器设计方法，其特征在于，赋值语句的预编译子句为：

$a:=\mathrm{Exp}\&DoubleLeftArrow;\mathrm{var\; V};L;a:=\mathrm{Exp}2;\mathrm{end\; V}$

1.

if CE(Exp，L，Exp2，φ，φ)

$2.a\left[i\right]:\mathrm{Exp}\&DoubleLeftArrow;\mathrm{var\; V};L;a\left[i\right]:=\mathrm{Exp}2;\mathrm{end\; V}$

if PCE(Exp，L，Exp2，φ，{(a，1)})

Images