CN102929781B - 基于上下文定界的队列通信并发递归程序验证方法 - Google Patents

Abstract

基于上下文定界的消息队列通信并发递归程序的验证方法属于软件安全、可靠性技术领域，其特征在于通过对每个下推系统迭代地应用Post^*算法，穷尽搜索其执行的状态空间，并通过有限的上下文切换次数k利用上下文切换函数实现不同上下文间的切换，以模拟各个进程之间的交错执行，得到k次上下文执行内的可达格局集合，通过计算可达格局集合与目标格局集合的交集是否为空，判断出目标格局集合即状态是否可达，从而确定程序中存在的设计错误或漏洞，保证程序的正确与可靠。本发明无需用户过多参与，实现了基于可达性求解的程序自动化检验，而且格局计算过程简单而有效，在良序排队约束的条件下，本发明提出的上下文定界可达性是可以判定的。

Description

基于上下文定界的队列通信并发递归程序验证方法

技术领域

本发明属于软件安全性、可靠性研究领域，涉及并发递归程序的可达性求解方法，具体是一种适合于事件驱动编程方法的程序验证技术，基于上下文切换定界思想和良序排队假设证明基于队列通信的并发递归程序的上下文定界可达性问题是可判定的，并应用标准的自动机Post^*算法以及良序排队约束求解基于队列通信的并发递归程序可达问题的一种自动化方法。

背景技术

基于队列通信的并发递归程序是一种基于事件驱动（Event-Driven）架构的应用程序，被广泛应用于Windows环境下的应用程序设计或者面向对象应用程序设计，此类程序充分利用了多核处理器提供的强大计算能力，通过收集来自用户的外部事件（如键盘输入，鼠标点击），或者系统事件（函数调用，系统中断），对这些事件做出相应的响应，从而更加灵活、及时的与外部环境进行交互。近些年来，基于队列通信的消息传递框架（队列系统）的可达性问题引起了学术界的广泛关注的研究热点。

基于消息队列的通信框架是一种通用的并发系统模型，通常用于事件驱动的并发程序或基于网络通信的分布式程序的建模。为了获得高性能以及低延迟，基于事件驱动的并发程序常通过异步调用方式发布多任务，然后使用调用模块并行地处理各个任务，或者等待处理器和I/O等资源空闲时再处理任务，同时异步地调用多个函数，从而避免等待某个函数返回而阻塞执行。并发程序的任务通常作为队列中的消息：发布任务时，进行入队操作；执行任务时，进行出队操作。因此基于消息队列的通信框架可作为事件驱动并发程序的信任模型。

模型检验队列系统(即基于消息队列通信的系统)的主要障碍是无界FIFO队列可能引起状态空间爆炸问题，采用上下文定界方法可有效地抑制状态空间爆炸问题。队列系统的上下文定义为：某个进程任意长度的连续执行序列，进程仅可从一个队列中读取消息，但可向所有输出消息队列写入消息。其上下文切换定界可达性问题即：是否经过有限次上下文切换的运行，某个全局状态(或者格局)是可达的。基于上下文定界方法的模型检验能获得良好的状态空间覆盖度，并可利用算法技术高效地搜索进程间的交错，因此对于并发程序的验证是一种有效约束方法。实验表明：许多并发相关的错误可以在极少数上下文切换执行中显现出来，穷尽搜索有限次上下文切换执行能够高效地查找程序中隐匿的错误和漏洞（S.Qadeer,J.Rehof，“Context-bounded model checking of concurrent software,”TACAS 05,LNCS,2005,3440,93-107）。

Qadeer首次提出针对并发系统的上下文定界分析思想，表明包含共享内存的递归布尔程序的上下文定界可达性问题是可判定的，并基于该思想提出KISS框架。近些年来，许多研究工作针对其他复杂系统进行上下文定界可达性分析，例如异步动态下推系统的上下文定界分析，针对包含有限可见堆的系统的上下文定界分析，以及针对递归布尔程序的上下文切换定界分析。

近二十年来，基于消息传递的队列系统是模型检验领域的一个研究热点。近些年提出的基于自动机理论分析的约束方法，被用于验证此类系统：例如基于有损信道通信的系统（P.Abdulla,B.Jonsson,“Verifying programs with unreliable channels,”IEEE Symp on Logic inComputer Science,1993,160-170），以及队列系统的某些约束模型：如基于单个队列通信的系统（O.H.Ibarra,Z.Dang,P.San Pietro,“Verification in loosely synchronous queue connecteddiscrete timed automata,”Theoretical Computer Science,2003,290(3),1713-1735），基于特定类型消息的队列通信的系统（W.Peng,S.Purushothaman,Analysis of a class of communicating finitestate machines,”Acta Informatica,1992,29(6/7),499–522）,任意时刻只有单个队列运行的半双工传输系统（G. Cece,A.Finkel,“Programs with quasi-stable channels are effectivelyrecognizable,”CAV 1997,LNCS,1254,1997,304-315）,以及基于单个队列通信的多计数器系统（O.H.Ibarra,“Verification in queue-connected multicounter machines,”International Journal ofFoundations of Computer Science,2002,13(1),115-127）等。另有研究表明：任何时刻单个递归进程执行的异步程序的可达性问题是可判定的，当且仅当进程的局部栈为空时才能读取任务（K.Sen,M.Viswanathan,“Model checking multithreaded programs with asynchronous atomicmethods,”CAV 06,LNCS,2006,4144,300-314）。最近提出的基于消息计数器有界的自下近似和自上近似方法，被用于解决异步程序的数据流分析问题（R.Jhala,R.Majumdar,“Interprocedural analysis of asynchronous programs,”ACM SIGPLAN-SIGACT Symp on POPL,2007,339-350）。

发明内容

本发明目的在于提供一种针对队列通信的并发递归程序（RQCP，Recursive QueueConcurrent Program）的可达性求解方法，通过对此类程序的某些错误状态或者格局的可达性判定分析，确定程序运行是否会出现错误，从而检测出并发程序中隐匿的错误或漏洞。

本发明研究基于FIFO队列通信的有限状态递归程序的可达性问题。当并发程序包含递归过程调用时，即使仅考虑执行有限次上下文切换，其可达性问题仍是不可判定的。为了使上下文切换定界可达性问题为可判定，约束系统进程的消息队列为良序：即仅当进程的局部栈为空时，进程才能从队列中读取消息。由于进程处理任务时，直至执行结束时才处理下一个任务，中途不允许被中断，故良序排队是适当的。给定一个递归队列并发程序，构造模拟递归队列并发程序执行的多栈下推系统，将其上下文切换定界可达性问题转换为多栈下推系统的阶定界可达性问题（k上下文切换对应于多栈下推系统的3k+1阶运行）。基于上下文切换定界思想和良序排队约束，本文提出一种针对多栈下推系统的上下文切换定界可达算法，该算法可作为求解递归队列并发程序可达性问题的算法基础。算法使用标准Post^*算法描述每个下推系统的迭代过程，基于良序排队定义控制进程对队列的出队操作，通过下文切换函数实现上下文的切换，穷尽地计算k次上下文切换内正向可达的格局。最后对目标状态集合与可达格局状态集合的交集进行判空，从而解决递归队列并发程序的可达性问题。

为实现上述目的，本发明采取以下技术方案：

整个技术方案包括以下三个步骤：

步骤（1）、依次按以下步骤把所述的R转换为一个多栈下推系统，用表示，以便把上下文(p,q)切换定界可达性问题转换为多栈下推系统的阶定界可达性问题，其中k次上下文切换对应于3k+1个阶，其目的在于把基于良序消息队列通信的并发递归程序R转换为一个等价的用于模拟R执行的多栈下推系统该多栈下推系统的执行对应于所述R所包含的动作或行为（将R转换为多栈下推系统的具体流程图如图1所示），

步骤（2）、执行基于可达算法Post^*的可达格局集合Reach计算（K上下文切换可达算法的流程图如图2所示，具体算法的伪代码如图3所示），

步骤（3）、目标可达性的判定分析（可达性判定分析的流程图如图7所示）。

本发明提出的基于上下文定界的消息队列通信并发递归程序的验证方法，首次实现了针对事件驱动的并发递归程序的自动化检测方法，可有效地检测程序中的并发错误和漏洞，无需用户过多参与，实现了基于可达性求解的程序自动化检验，而且格局计算过程简单而有效，在良序排队约束的条件下，本发明提出的上下文定界可达性是可以判定的。

附图说明

图1为递归队列并发程序R转换为多栈下推系统的示意图；通过限定R的上下文定界执行，并约束R是良序排队的，可以构造出模拟良序排队的递归队列并发程序R执行的多栈下推系统图下方所示的是根据R构造的转换语义。

图2为基于队列通信的并发递归程序可达性问题求解方法的K上下文切换可达算法流程示意图，各个步骤对应于图3所示的K上下文切换可达算法。

图3为基于队列通信的并发递归程序可达性问题求解方法的K上下文切换可达算法示意图，该算法的详细步骤说明参见具体实施方式的步骤（2）。

图4为K上下文切换可达算法中的上下文切换处理函数，该函数用于实现上下文间的切换，函数Context_switch((p,q),(p′,q′))表示上下文(p,q)切换到上下文(p′,q′)，其中函数Inverse Move(st_w,(st_p,st_q))将st_w(工作栈)的顶部和底部内容弹出并压入st_p和st_q中，函数Move((st_p,st_q),st_w)将(p,q)对应的栈内容弹出并压入st_w。

图5为一种有效的Post^*算法，该算法可用于计算当前上下文从初始格局正向可达的格局集合。

图6为应用Post^*算法进行正向可达格局求解的实例；其中：

图6.1所示的是接受下推系统初始格局集合的自动机A=(Q,Γ，→₀,P,F)，其中：Q是自动机A的状态集合，P={p₀,p₁,p₂}作为自动机A的初始状态，s₂是自动机A的终止状态，Γ＝{γ₀,γ₁,γ₂,ε}是自动机A的字母表；→₀=Δ={r₁,r₂,r₃,r₄}是自动机的转移函数;c_in=<p₀,γ₀γ₀>是自动机A接受的下推系统的初始格局集合。

图6.2所示的是基于图5所示的Post^*算法计算出的自动机自动机接受的语言是自动机A接受格局的正向可达格局集合，自动机A和的关系相当于图3算法中自动机A_p和A′_p的关系。

图7为基于队列通信的并发程序的可达性求解方法的可达性判定分析示意图。基于上下文切换定界可达算法，计算得到多栈下推系统系统在k次上下文执行内的可达格局集合Reach(K)，通过判断给定目标状态集合T与可达格局集合Reach(K)的交集是否为空，判断目标状态s的可达性，具体的判定方法参见具体实施方式的步骤（3）。

图8为一个良序排队的队列通信并发递归程序R，R=(S,s₀,∏，Γ，{T_p}_p∈P)，该程序是事件驱动程序设计的应用程序的一个抽象实例，程序R包括三个可并发执行的进程p₀,p₁,p₂，以及进程间通信的队列q₀,q₁,q₂，l是预先定义的全局共享变量，程序包含三个事件，分别使用字母a，b，c表示，进程p₀，p₁和p₂的动作集合定义如下：Act₀={recv(q₀,a),send(q₁,b),send(q₂,c),call f(5),e₁:=dequeue(q₀),x:=f(5),return}；Act₁={recv(q₁,b),call g(n),e₂:=dequeue(q₁),m:=g(n),return}；Act₂={recv(q₂,c),e₃:=dequeue(q₂),return}。具体实施方式中对该程序的可达性问题求解步骤进行了详解阐述。

图9是图8所示的队列通信递归程序R的流图，该图表示程序中各个语句之间的关系（相当于程序的控制流图），根据该图可以方便的抽象出该程序的迁移关系集合（对应于多栈下推系统的下推规则（迁移关系）集合），其中：结点表示各个进程和函数的控制位置，使用语句所在的行号进行标记，边上标记的是切换到下一个控制位置的所要执行的语句。

具体实施方式

本发明的特征在于：是一种基于良序消息队列通信的并发递归程序RQCP上下文切换定界的可达性辨识之上的程序验证方法，所述良序消息队里是仅当进程的局部栈为空时，进程才能从队列中读取消息中途不允许被中断，直至执行结束时才处理下一个任务，所述的并发递归程序，以下简称RQCP，用R表示，是在一台多核处理器中依次按以下步骤实现验证的。

步骤（1）、依次按以下步骤把所述的R转换为一个多栈下推系统，用表示，以便把上下文(p,q)切换定界可达性问题转换为多栈下推系统的阶定界可达性问题，其中k次上下文切换对应于3k+1个阶，其目的在于把基于良序消息队列通信的并发递归程序R转换为一个等价的用于模拟R执行的多栈下推系统，该多栈下推系统的执行对应于所述R所包含的动作或行为，步骤如下：

步骤（1.1）、构建R的抽象模型

定义1给定一个体系结构A=(P,Q,Sender,Receiver)，P是有限进程集合，Q是有限队列集合，Sender:Q→P和Receiver:Q→P是两个指派函数，分别为每个队列q∈Q唯一指派的发送进程和接收进程，并规定每个队列的发送进程和接收进程是不同的：即对于q∈Q，Sender(q)≠Receiver(q)。

其中各个符号定义如下：

Π表示有限的消息字母表，m∈Π表示消息；

p∈P表示一个进程，q∈Q表示一个队列；

Act_p表示一个进程p的动作集合，Act=∪_p∈PAct_p表示所有进程的动作集合；

Calls表示所有进程的调用动作的集合，表述为{p:call|p∈P}，p:call为描述过程调用的局部栈动作；

Rets表示所有进程的返回动作的集合，表述为{p:ret|p∈P}，p:ret为描述过程返回的局部栈动作，其中：

p:call相当于进程p的局部过程调用，进程p把至少包括地址、局部变量的赋值在内的数据送到局部栈的栈顶，并迁移到新状态；

p:ret相当于进程p中过程调用的返回，弹出局部栈的内容并迁移到另一个新状态，所述另一个新状态依赖于进程p的当前状态及所述的局部栈中弹出的数据；

动作p:send(q,m)表示进程p向接收队列q中写入消息m；

动作p:recv(q,m)表示进程p从所述接收队列q中读取消息m；

动作p:int表示进程p的对队列不处理的一个内部动作；

定义2给定一个体系结构A=(P,Q,Sender,Receiver)，在所述体系结构A运行的上的递归队列并发程序是一个五元组R，R=(S,s₀,П，Γ，{T_p}_p∈P)，其中：S是有限的状态集合，s₀∈S是初始状态；Π是所述的有限的消息字母表，Γ是有限的局部栈字母表，T_p是进程p的迁移关系集合，符号定义集合间的“属于”关系，T_p具体表示如下：

$T_p\&SubsetEqual;(S\&times;({\mathrm{Act}}_p\backslash \{p:\mathrm{call},p:\mathrm{ret}\left\}\right)\&times;S)\&cup;(S\&times;\{p:\mathrm{call}\}\&times;S\&times;\mathrm{\&Gamma;})\&cup;(S\&times;\{p:\mathrm{ret})\&times;\mathrm{\&Gamma;}\&times;S),$

其中进程p的动作的形式如下：

1)p:send(q,m)，其中m∈Π，q∈Q，且Sender(q)=p；

2)p:recv(q,m)，其中m∈Π，q∈Q，且Receiver(q)=p；

3)p:int，或者p:call或者p:ret；

步骤（1.2）、R的操作语义描述

给定递归队列并发程序R=(S,s₀,П，Γ，{T_p}_p∈P)，其中：

{T_p}_p∈P是所有进程p的迁移关系集合；

其格局是一个三元组(s,{σ_p}_p∈P，{μ_q}_q∈Q)，其中s∈S是R的状态；

符号{σ_p}∈Γ^*表示进程p的进程局部栈的内容，表示为σ_p∈Γ^*，Γ^*是所述进程局部栈字母上的闭包；

符号{μ_q}∈Π^*表示队列q的内容，表示为μ_q∈Π^*，Π^*是所述消息字母上的闭包；

假设进程p的栈顶内容位于σ_p的最左端，栈底内容位于σ_p的最右端；

队列q的队尾消息位于μ_q的最左端，队头消息位于μ_q的最右端；

使用以下操作语义描述格局之间的迁移关系：

操作 $\left[\mathrm{Internal}\right]\frac{\begin{array}{cc}\mathrm{act}=p:\mathrm{int}& (s,p:\mathrm{int},s^{\&prime;})\&Element;T_p\end{array}}{(s,{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})\stackrel{\mathrm{sct}}{\&RightArrow;}(s^{\&prime;},{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})}$ 为内部动作，表示：执行动作p:int，使R的状态由但{σ_p}、{μ_q}的内容没有改变。

操作 $\left[\mathrm{Send}\right]\frac{\begin{array}{ccc}\mathrm{act}=p:\mathrm{send}(q,m)& (s,p:\mathrm{send}(q,m),s^{\&prime;})\&Element;T_p& \mathrm{Sender}\left(q\right)=p\end{array}}{(s,{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_{q^{\&prime;}}\right\}}_{q^{\&prime;}\&Element;(Q\backslash \{q\left\}\right)}\&cup;\{{\mathrm{\&mu;}}_q\left\}\right)\stackrel{\mathrm{act}}{\&RightArrow;}(s^{\&prime;},{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_{q^{\&prime;}}\right\}}_{q^{\&prime;}\&Element;(Q\backslash \{q\left\}\right)}\&cup;\{m.{\mathrm{\&mu;}}_q\left\}\right)}$ 为写入，表示：执行动作p:send(q,m)，写入进程是p，使R的状态由使队列的内容{μ_q′}中除了{μ_q}外还写入了消息m。

操作 $\left[\mathrm{Receive}\right]\frac{\begin{array}{ccc}\mathrm{act}=p:\mathrm{recv}(q,m)& (s,p:\mathrm{recv}(q,m),s^{\&prime;})\&Element;T_p& \mathrm{Receiver}\left(q\right)=p\end{array}}{(s,{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_{q^{\&prime;}}\right\}}_{q^{\&prime;}\&Element;(Q\backslash \{q\left\}\right)}\&cup;\{{\mathrm{\&mu;}}_q^{\&prime;}.m\left\}\right)\stackrel{\mathrm{act}}{\&RightArrow;}(s^{\&prime;},{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_{q^{\&prime;}}\right\}}_{q^{\&prime;}\&Element;(Q\backslash \{q\left\}\right)}\&cup;\{{\mathrm{\&mu;}}_q^{\&prime;}\left\}\right)}$ 为接受，表示执行动作p:recv(q,m)，读取进程是p，从s状态下的队列{μ′_q.m}中读取消息m，使R的状态由使队列q的内容{μ′_q}中被读取了消息m，写入时的{μ_q}不一定等于读取时的{μ′_q}。

操作 $\left[\mathrm{Call}\right]\frac{\begin{array}{cc}\mathrm{act}=p:\mathrm{call}& (s,p:\mathrm{call},s^{\&prime;},\mathrm{\&gamma;})\&Element;T_p\end{array}}{(s,\{{\mathrm{\&sigma;}}_p\}\&cup;{\left\{{\mathrm{\&sigma;}}_{p^{\&prime;}}\right\}}_{p^{\&prime;}\&Element;(P\backslash \{p\left\}\right)},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})\stackrel{\mathrm{act}}{\&RightArrow;}(s^{\&prime;},\{\mathrm{\&gamma;}{\mathrm{\&sigma;}}_p\}\&cup;{\left\{{\mathrm{\&sigma;}}_{p^{\&prime;}}\right\}}_{p^{\&prime;}\&Element;(P\backslash \{p\left\}\right)},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})}$ 为调用，表示：执行动作p:call，在s状态下进程p根据规则γ调用至少包括地址、局部变量的赋值在内的数据送到对应于进程p的局部栈的内容{σ_p′}的最左端，使得状态由{σ_p′}添加为{γσ_p′}。

操作 $\left[\mathrm{Return}\right]\frac{\begin{array}{cc}\mathrm{act}=p:\mathrm{ret}& (s,p:\mathrm{ret},\mathrm{\&gamma;},s^{\&prime;})\&Element;T_p\end{array}}{(s,\{{{\mathrm{\&gamma;\&sigma;}}^{\&prime;}}_p\}\&cup;{\left\{{\mathrm{\&sigma;}}_{p^{\&prime;}}\right\}}_{p^{\&prime;}\&Element;(P\backslash \{p\left\}\right)},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})\stackrel{\mathrm{act}}{\&RightArrow;}(s^{\&prime;},\{{{\mathrm{\&sigma;}}^{\&prime;}}_p\}\&cup;{\left\{{\mathrm{\&sigma;}}_{p^{\&prime;}}\right\}}_{p^{\&prime;}\&Element;(P\backslash \{p\left\}\right)},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})}$ 为返回，表示：执行动作p:ret，在s状态下，根据规则γ，弹出进程p的进程局部栈的内容{γσ′_p}中按规则γ调用的至少包括地址、局部变量的赋值在内的数据，剩下原先的内容{σ′_p}，使状态状态，所述调用的{γσ′_p}与返回的{σ′_p}不一定相同。

步骤（1.3）、用一个多栈下推系统模拟良序消息队列的并发递归程序的执行

定义3递归队列并发程序是良序排队的，当且仅当进程p∈P的局部栈为空时，才可从对应的消息队列中读取消息，也就是说，良序排队的递归队列并发程序不存在如下形式的运行：其中c_n-1=(s,{σ_p}_p∈P,{μ_q}_q∈Q)，act_n-1=p:recv(q，m)，且σ_p≠ε，即进程的局部栈不为空时，不能执行动作p:recv(q,m)。

给定：良序消息队列的并发递归程序R=(S,s₀,∏，Г，{T_p}_p∈P)。

构造一个模拟所述良序消息队列的并发递归程序R的k上下文切换定界执行的多栈下推系统其中：

S是有限的状态集合；s₀是初始状态，s₀∈S；

St是局部栈集合，包括工作局部栈st_w，进程p对应的局部栈st_p，队列q∈Q对应的局部栈st_q，St表示为St={st_w∪{st_p}_p∈P∪{st_q}_q∈Q}，各局部栈初始化为空；

是字母表，包括队列对应的局部栈字母表，与进程对应的局部栈的字母表，表示为

Δ是迁移关系集合，包括：

Δ_int内部迁移关系集合；

Δ_push写入迁移关系集合，包括push_q和push_p，其中：push_q与进程p的写入队列操作相关的迁移关系，push_p与进程p的入栈操作相关的迁移关系；

Δ_pop读取迁移关系集合，包括pop_q和pop_p，其中：pop_q与进程p的读取队列操作相关的迁移关系，pop_p与进程p的出栈操作相关的迁移关系；

从而得到迁移关系集合Δ的表达式为：

Δ=Δ_int∪Δ_pop∪Δ_push

在上下文（p,q）内，所述上下文定义为：某个进程任意长度的连续执行序列，进程p仅能从一个队列中读取消息，但可向所有输出消息的任一队列q写入消息，所述进程p可执行的迁移关系定义如下：

规则 $\left[\mathrm{internal}\right]\frac{(s,p:\mathrm{int},s^{\&prime;})\&Element;T_p}{(s,p:\mathrm{int},s^{\&prime;})\&Element;{\mathrm{\&Delta;}}_{\mathrm{int}}};$

规则 $\left[{\mathrm{push}}_q\right]\frac{\begin{array}{cc}(s,p:\mathrm{send}(q,m),s^{\&prime;})\&Element;T_p& \mathrm{Sender}\left(q\right)=p\end{array}}{(s,p:\mathrm{send}(q,m),s^{\&prime;})\&Element;{\mathrm{\&Delta;}}_{\mathrm{push}}};$

规则 $\left[{\mathrm{push}}_p\right]\frac{(s,p:\mathrm{call},s^{\&prime;},\mathrm{\&gamma;})\&Element;T_p}{(s,p:\mathrm{call},s^{\&prime;},\mathrm{\&gamma;})\&Element;{\mathrm{\&Delta;}}_{\mathrm{push}}};$

规则 $\left[{\mathrm{pop}}_q\right]\frac{\begin{array}{cc}(s,p:\mathrm{recv}(p,m),s^{\&prime;})\&Element;T_p& \mathrm{Receiver}\left(q\right)=p\end{array}}{(s,p:\mathrm{recv}(q,m),s^{\&prime;})\&Element;{\mathrm{\&Delta;}}_{\mathrm{pop}}};$

规则 $\left[{\mathrm{pop}}_p\right]\frac{(s,p:\mathrm{ret},\mathrm{\&gamma;},s^{\&prime;})\&Element;T_p}{(s,p:\mathrm{ret},\mathrm{\&gamma;},s^{\&prime;})\&Element;{\mathrm{\&Delta;}}_{\mathrm{pop}}};$

规则表示把所述的R内队列操作相关的迁移关系添加加到所述的多栈下推系统中对应的迁移关系集合中去。

根据以上转换方法构造的多栈下推系统能模拟良序排队的递归队列并发程序R的执行，并且的3k+1阶定界可达问题相当于R的k上下文切换定界可达问题；

具体证明过程如下：

定理1良序排队的递归队列并发程序的上下文切换定界可达性问题是可判定的，其时间复杂度与上下文切换的次数呈2-EXPTIME关系，与程序的大小呈指数关系。

证明：假定R是定义在体系结构(P,Q,Sender,Receiver)上的一个良序排队的递归队列并发程序，S是R的状态集合。则可构造一个模拟递归队列并发程序R的执行情况的多栈下推系统，从而将R的上下文切换定界可达性问题转换为多栈下推系统的阶定界可达性问题。该多栈下推系统中包括：每个队列q∈Q对应的栈st_q，一个额外的工作栈st_w，以及每个进程p∈P对应的局部栈st_p。

假定当前上下文是(p,q)，对于递归队列并发程序R中的每个进程p′∈{P\p}，栈st_p′逆序地存储进程的局部栈内容，栈st_q′存储每个队列q′∈{Q\q}的内容（即队尾指向的内容存储在栈顶，队头指向的内容存储在栈底），栈st_p和栈st_q初始化为空；工作栈st_w存储上下文(p,q)对应的进程p的局部栈内容和队列q的栈内容：栈st_w的顶部存储进程p的局部栈内容，栈st_w的底部存储队列q的栈内容（即队列q的栈内容存储在工作栈的底部，进程p的局部栈内容存储在工作栈的顶部）。

多栈下推系统的内部动作模拟R的内部动作；向队列q′∈{Q\q}中写入消息m相当于对栈st_q′进行入栈操作，将符号m写入栈顶；工作栈st_w的入栈和出栈操作分别模拟递归过程的调用和返回操作。当进程p从队列q对应的栈中读取消息时，进程p的局部栈必须为空(基于良序排队的定义)，此时从队列q中读取的消息恰好位于工作栈st_w的顶部，从而弹出栈顶的消息。在一个上下文内，模拟R执行的多栈下推系统不进行阶切换。当上下文(p,q)切换为上下文(p′,q′)时，对工作栈st_w的顶部和底部进行出栈操作，将读取的内容分别存储到栈st_p和st_q中，然后对栈st_q′和栈st_p′进行出栈操作，将读取的内容分别存储到栈st_w的底部和顶部(上下文切换函数如图4所示)。从而良序排队的递归队列并发程序的k上下文切换定界可达性问题被转换为多栈下推系统的3k+1阶定界可达性问题(k+1个上下文对应k+1个阶，进行k次上下文切换相当于增加额外2k个阶)。

步骤（2）、按如下步骤执行基于可达算法Post^*的可达格局集合Reach计算，K上下文切换可达算法的流程图如图1所示，具体算法如图2所示

步骤（2.1）、初始化多栈下推系统

设立多栈下推系统和上下文切换次数K，0≤k≤K，其中：多栈下推系统是下推系统的自然扩展，包含多个栈结构；K是一个正整数，也是Post^*算法的迭代次数；其中：

S是有限的状态集合；s₀∈S是初始状态；

St={st_w∪{st_p}_p∈P∪{st_q}_q∈Q}，初始时，各栈st∈St的栈内容σ_st为空，表示为σ_st=ε；

其中：Π是队列对应的局部栈字母表，Γ是进程对应的局部栈的字母表，总称字母表；

Δ是迁移关系集合，Δ=Δ_int∪Δ_pop∪Δ_push。

定义：输出可达格局集合Reach，集合Reach中存储的是在至多k次上下文切换执行内正向可达的格局，用c表示，c=<s₀,{σ_st}_st∈St>，σ_st表示栈st∈St的内容，多栈下推系统的初始格局是c_in=<s₀,{σ_st}_st∈St>，以及对应的切换次数k，以格局项(c,k)的形式存储在所述可达格局Reach的工作列表WL上，初始时的初始格局是c_in=<s₀,{σ_st}_st∈St>，内容σ_st为空。

给定的目标格局状态集合T，所述目标状态集合T定义为一种错误状态集合，表示为是一种在所述并发递归程序不可能出现的错误状态的集合。

步骤（2.2）、建立工作列表WL

按照所述并发递归程序的执行顺序把所述上下文(p,q)转换为依次衔接的格局项(c,k)，0≤k≤K的编号存储于工作列表WL内，并初始化所述初始格为c_in。

步骤（2.3）、初始上下文(p,q)选择

定义二元组（p,q）是所述并发递归程序的一个执行上下文，其中p是进程，q是进程间通信的队列，并且随机或指定某个上下文（p,q）为初始上下文，并对各栈st初始化：根据队列q和进程p对应的迁移关系集合Δ，把队列q对应栈st_q的内容压入工作栈st_w的底部，将进程p对应的栈st_p内容压入工作栈st_w的顶部。

假定是上下文（p,q）下进程p的下推系统，建立接受上下文(p,q)的初始格局的下推自动机A_p=(Q,Г，→₀,P,F)，对应算法5中的自动机A，其中：Q是自动机的控制位置集合，对应算法5中自动机A的状态集合；Γ是自动机接受的字母表，对应算法5中自动机A接受的字母表；→₀是自动机的转移函数；P是初始控制位置集合，对应算法5中自动机A的初始状态集合；F是终止控制位置集合，对应算法5中自动机A的终止状态集合。

对于下推自动机A_p，存在接受其正向可达格局集合的下推自动机A′_p=post^*(A_p)，给定初始格局为<s₀,σ_st>的下推系统及其对应的迁移关系集合Δ，可以计算接受下推系统正向可达格局集合为语言的下推自动机

步骤（2.4）、按以下步骤从所述初始上下文(p,q)开始，对所述工作队列表WL中各个格局项编号中的内容进行上下文切换可达性计算

步骤（2.4.1）从工作列表WL中取出一个编号对应于初始上下文(p,q)的格局项，并分别存储在进程局部栈st_p和队列局部栈st_q中：进程p逆序地存储存储在st_p和中，栈底存储队尾指向的内容，栈顶存储队头指向的内容，队列q是顺序存储在栈st_q中：栈顶存储队尾指向的内容，栈底存储队头指向的内容。

步骤（2.4.2）、再把栈st_q的内容存储在工作栈st_w的底部，栈st_p的内容存储在工作栈st_w的顶部。

步骤（2.4.3）、使另一个进程局部栈栈st_p和队列栈st_q初始化为空，在把初始上下文(p,q)切换为上下文(p′,q′)时，此时迭代次数k≤K,对工作栈st_w的顶部和底部进行出栈操作，把读取的内容分别存储到栈st_p和st_q中。

步骤（2.4.4）、按以下步骤计算进程中的初始格局是否属于正向可达格局集合的初始格局：

步骤（2.4.4.1）、若所述多栈下推系统中对应于初始上下文(p,q)的迁移关系集合是写入迁移关系集合Δ_push，δ=(s,st_q′,a,s′)∈Δ_push，a是消息，且格局<s′,σ′_p>，σ′_p=aσ_p，σ_p是栈st_p的内容，则向栈st_q′中入栈消息a。

步骤（2.4.4.2）、若所述多栈下推系统中对应于初始上下文(p,q)的迁移关系集合是读取迁移关系集合Δ_pop，δ=(s,st_q,a,s′)，且格局为<s′,ε>，则弹出栈st_q内的消息a，局部栈为空。

步骤（2.4.4.3）、修改状态s′的可达格局赋值为x，把格局项(x,i+1)添加到工作列表WL中。

步骤（2.4.4.4）、在继续从初始上下文(p,q)开始向下执行上下文切换之后，按步骤（2.5）所述进行可达格局集合Reach计算，上下文切换函数如图4所示：

上述步骤（2.4）基于Post^*算法计算多栈下推系统正向可达格局集合，其理论依据和具体的步骤如下：

多栈下推系统是下推系统的自然扩展，包含多个栈结构，多栈下推系统的正向可达格局的计算，可通过对其包含的下推系统迭代地应用Post^*算法进行计算，下推自动机可以作为下推系统格局集合的计算模型。

定义4下推系统是一种模拟递归程序执行的抽象模型，表示为其中：P是下推系统的控制位置集合；Γ是下推系统的栈字母表；Δ是下推系统的迁移关系集合；c₀是下推系统的初始格局。

定义5下推自动机是一种适用于下推系统可达格局的计算模型，表示为A=(Q,Г，→₀,P,F)，其中：Q是自动机的控制位置集合；Γ是自动机接受的字母表；→₀是自动机的转移函数，P是初始控制位置集合；F是终止控制位置集合；自动机A接受的语言定义为L(A)。

定理2假定是对自动机A重复应用本节定义的饱和规则得到的自动机，那么自动机识别集合post^*(L(A))。

定理3假定是一个下推系统，A=(Q,Г，→₀,P,F)是一个下推自动机，则存在识别post^*(L(A))的自动机

给定：初始格局为<s₀,σ_st>的下推系统及其对应的迁移关系集合Δ，可以根据以下步骤计算接受下推系统可达格局集合为语言的自动机

Post^*算法的具体步骤如下：

步骤（1）对于每个元组(p′,γ′)，如果中包含至少一个如下规则则添加一个新状态q_p′,γ′，

步骤（2）根据以下饱和规则向A中添加新的迁移：

i.如果并且当前自动机中添加迁移(p′,ε,q)，

ii如果并且当前自动机中添加迁移(p′,γ′,q)，

iii.如果并且当前自动机中首先添加迁移(p′,γ′,q_p′,γ′)，再添加迁移(q_p′,γ′,γ″，q)，

符号p，p₀，p′，q_p′,γ′，s∈P等表示下推系统的控制位置（q_p′,γ′表示控制位置为p′，接受字母为γ′时的控制位置），对应于自动机A的状态；符号γ，γ′，γ″∈Γ表示下推系统的栈符号，对应于自动机A接受的字母表。一种有效的Post^*算法如图5所示：

给定：图6.1所示的下推系统和自动机A。使用以上算法得到自动机该自动机接受post^*({<p₀,γ₀γ₀>})，如图6.2所示。

通过以下步骤可以计算得到图6.2所示的自动机

a)首先，添加新的状态：根据添加状态q_p1,γ1，根据规则 添加状态q_p2,γ2；

b)由于匹配规则r₁的左半部分，添加迁移(p₁,γ₁,q_p1,γ1)和(q_p1,γ1,γ₀,s₁)；

c)根据迁移(p₁,γ₁,q_p1,γ1)和规则r₂，添加迁移(p₂,γ₂,q_p2,γ2)和(q_p2,γ2,γ₀,q_p1,γ1)；

d)根据迁移(p₂,γ₂,q_p2,γ2)和规则r₃，添加迁移(p₀,γ₁,q_p2,γ2)；

e)再次，根据迁移(p₀,γ₁,q_p2,γ2)和规则r₄，在p₀和q_p2,γ2之间添加一条ε-边；

f)此时再次应用规则r₁。由于已经添加过迁移(p₁,γ₁,q_p1,γ1)，此时只需要添加迁移(q_p1,γ1,γ₀,q_p1,γ1)；

g)没有需要添加的迁移，整个过程终止。

步骤（2.5）、根据Post^*算法计算接受上下文（p,q）正向可达格局的下推自动机A′_p，修改A′_p的状态，修改后的格局添加到工作列表WL、以及可达格局集合Reach。

步骤（2.5.1）对于s′∈S(A′_p)，如果下推自动机A_p∈{P\p}的初始状态与状态s相同，使用rename(A_p∈{P\p},s′)修改A_p∈{P\p}的初始状态为s′，避免自动机A′_p的初始状态与自动机A_p中的状态重名而产生冲突。

步骤（2.5.2）使用函数update(A′_p,s′)重命名A′_p中除s′之外的其他状态，并更新S不包含的状态，即修改格局的赋值为x=<s′,update(A′_p,s′),rename(A_p∈{P\p},s′),update(σ_st\{p∈P})>。

步骤（2.5.3）最后将修改后的可达格局赋值为x，将格局项(x,k+1)添加到工作列表WL，并将格局x添加到集合Reach。

步骤（3）、目标可达性的判定分析，目标可达性的判定流程如图7所示

根据正向可达格局集合Reach(k)和给定的目标状态集合T，目标状态集合T视为R中不可能出现的状态的集合，也称错误状态集合，进而计算集合Reach和集合 的交集是否为空；

步骤（3.1）、若Reach∩T非空，则经过k次上下文切换的运行，某个目标状态s∈S是可达的。则存在一个起始于初始格局的执行路径能够到达该错误状态，进而根据进程在各个状态的局部栈的内容和消息队列的内容，尝试查找产生错误的原因；

步骤（3.2）、若Reach∩T为空，则经过k次上下文切换的运行，目标状态s∈S是不可达的。状态s不可达的判断步骤如下：

a)经过k次上下文切换的运行，搜索的状态空间覆盖度不足以覆盖目标状态，此时可以增大k的值并继续求解，直至耗尽所有可用的计算资源；

b)若根据步骤a)仍不能判定目标状态是可达的，则得出结论：在现有计算能力下目标状态是不可能出现的。

本实例针对事件驱动的并发递归程序R应用本发明提出的求解方法进行可达性求解。该事件驱动程序包括三个可并发执行的进程p₀,p₁,p₂，以及进程间通信的队列q₀,q₁,q₂，该程序对进程产生的某些事件进行响应,是事件驱动编程方法设计的应用程序的一个抽象实例，实例程序R如图8所示，实例程序R的流图如图9所示。

具体实施步骤如下：

步骤（1）、依次按以下步骤把所述的R转换为一个多栈下推系统，用表示。

给定：一个体系结构A=(P,Q,Sender,Receiver)，其中进程集合P={p₀,p₁,p₂},队列集合Q={q₀,q₁,q₂}。函数Sender和Receiver定义如下：Sender(q₁)=p₀,Sender(q₂)＝p₀,Receiver(q₀)=p₀,Receiver(q₁)＝p₁,Receiver(q₂)=p₂。

步骤（1.1）、构建R的抽象模型

定义在体系结构A上的递归队列并发程序R=(S,s₀,∏，Г，{T_p}_p∈P)，其中：

l是预先定义的全局共享变量，程序包含三个事件，分别使用字母a，b，c表示，进程p₀，p₁和p₂的动作集合定义如下：

Act₀={recv(q₀,a),send(q₁,b),send(q₂,c),call f(5),e₁:=dequeue(q₀),x:=f(5),return}；Act1={recv(q₁,b),call g(n),e₂:=dequeue(q₁),m:=g(n),return}；Act₂={recv(q₂,c),e₃:=dequeue(q₂),return}；

步骤（1.2）、R的操作语义如下：

$\left[\mathrm{Internal}\right]\frac{\begin{array}{cc}\mathrm{act}=p:\mathrm{int}& (s,p:\mathrm{int},s^{\&prime;})\&Element;T_p\end{array}}{(s,{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})\stackrel{\mathrm{sct}}{\&RightArrow;}(s^{\&prime;},{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})}$

$\left[\mathrm{Send}\right]\frac{\begin{array}{ccc}\mathrm{act}=p:\mathrm{send}(q,m)& (s,p:\mathrm{send}(q,m),s^{\&prime;})\&Element;T_p& \mathrm{Sender}\left(q\right)=p\end{array}}{(s,{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_{q^{\&prime;}}\right\}}_{q^{\&prime;}\&Element;(Q\backslash \{q\left\}\right)}\&cup;\{{\mathrm{\&mu;}}_q\left\}\right)\stackrel{\mathrm{act}}{\&RightArrow;}(s^{\&prime;},{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_{q^{\&prime;}}\right\}}_{q^{\&prime;}\&Element;(Q\backslash \{q\left\}\right)}\&cup;\{m.{\mathrm{\&mu;}}_q\left\}\right)}$

$\left[\mathrm{Receive}\right]\frac{\begin{array}{ccc}\mathrm{act}=p:\mathrm{recv}(q,m)& (s,p:\mathrm{recv}(q,m),s^{\&prime;})\&Element;T_p& \mathrm{Receiver}\left(q\right)=p\end{array}}{(s,{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_{q^{\&prime;}}\right\}}_{q^{\&prime;}\&Element;(Q\backslash \{q\left\}\right)}\&cup;\{{\mathrm{\&mu;}}_q^{\&prime;}.m\left\}\right)\stackrel{\mathrm{act}}{\&RightArrow;}(s^{\&prime;},{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_{q^{\&prime;}}\right\}}_{q^{\&prime;}\&Element;(Q\backslash \{q\left\}\right)}\&cup;\{{\mathrm{\&mu;}}_q^{\&prime;}\left\}\right)}$

$\left[\mathrm{Call}\right]\frac{\begin{array}{cc}\mathrm{act}=p:\mathrm{call}& (s,p:\mathrm{call},s^{\&prime;},\mathrm{\&gamma;})\&Element;T_p\end{array}}{(s,\{{\mathrm{\&sigma;}}_p\}\&cup;{\left\{{\mathrm{\&sigma;}}_{p^{\&prime;}}\right\}}_{p^{\&prime;}\&Element;(P\backslash \{p\left\}\right)},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})\stackrel{\mathrm{act}}{\&RightArrow;}(s^{\&prime;},\{\mathrm{\&gamma;}{\mathrm{\&sigma;}}_p\}\&cup;{\left\{{\mathrm{\&sigma;}}_{p^{\&prime;}}\right\}}_{p^{\&prime;}\&Element;(P\backslash \{p\left\}\right)},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})}$

$\left[\mathrm{Return}\right]\frac{\begin{array}{cc}\mathrm{act}=p:\mathrm{ret}& (s,p:\mathrm{ret},\mathrm{\&gamma;},s^{\&prime;})\&Element;T_p\end{array}}{(s,\{{{\mathrm{\&gamma;\&sigma;}}^{\&prime;}}_p\}\&cup;{\left\{{\mathrm{\&sigma;}}_{p^{\&prime;}}\right\}}_{p^{\&prime;}\&Element;(P\backslash \{p\left\}\right)},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})\stackrel{\mathrm{act}}{\&RightArrow;}(s^{\&prime;},\{{{\mathrm{\&sigma;}}^{\&prime;}}_p\}\&cup;{\left\{{\mathrm{\&sigma;}}_{p^{\&prime;}}\right\}}_{p^{\&prime;}\&Element;(P\backslash \{p\left\}\right)},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})}$

根据动作集合Act₀，Act₁，Act₂相应的动作，可以同以上规则匹配，得出R的语义；

步骤（1.3）、用一个多栈下推系统模拟良序消息队列的并发递归程序的执行

根据转换方法可构造出多栈下推系统其中：

S是R的有限状态集合，s₀=l∈{T,F}是初始状态；

St={st_p}_p∈P∪{st_q}_q∈Q是栈集合，其中P={p₀,p₁,p₂}，Q={q₀,q₁,q₂}；

是有限的字母表，其中∏＝{a,b,c}，Г是进程对应的局部栈的字母表；迁移规则Δ=Δ_int∪Δ_pop∪Δ_push。

多栈下推系统的下推规则（迁移关系）如表1所示：

表1下推规则（迁移关系集合）及其变量定义域

在以上下推规则做如下约定：

p_{_i}表示进程p的控制位置，其中i表示控制位置所在程序代码的行号（如p_{_0}表示控制位置是进程p的第0行的位置）；

控制位置p_{_i}对应的下推规则，分别属于进程p的下推规则（迁移关系）；

其中各个符号的含义如下：

符号l表示程序R的全局布尔变量，变量l初始化为T或者F；

符号x,m,n∈N，x表示程序R定义的整型变量；

符号r，z是下推规则（迁移关系）中定义的临时变量，分别存储函数调用的返回的整型值和函数返回地址；

符号e₁,e₂,e₃∈e，表示程序中三个事件的符号化表示，其取值可以为a，b，c；

符号σ_q∈{a,b,c}^*表示消息队列q中的内容；

符号“-”表示变量在规则中未被使用；

为了表示简便，将dequeue简写为de，enqueue简写为en，分别使用de_0和en_0表示dequeue函数的入口地址和enqueue函数的入口地址。

表1中的规则<(l),(p_{0_2},e₁,x)>→<(l),(en_{_0},q₁,b)(p_{0_3},e₁,x)>表示进程p₀对应的下推系统能执行的下推规则，该规则表示的含义如下：进程p₀执行到控制位置p_{0_2}（即进程p₀的第2行），执行动作enqueue(q₁,b)，向队列q₁发送消息b，执行该动作之后，迁移到控制位置p_{0_3}（即进程p₀的第3行），全局变量l的取值不变；该规则表示程序R的进程p₀向进程p₁的消息队列q₁发送消息b，即进程p₀与进程p₁之间的通信。

此外规则<(l),(f_{_2},x)>→<(l),(f_{_0},x-1)(f_{_2′},x)>表示函数f的递归调用，规则<(l),(f_{_3},z)>→<(l,z),ε>表示函数f执行结束，函数f的返回值通过临时变量z返回给调用函数。

步骤（2）、基于K上下文切换可达算法Post^*的计算可达格局集合Reach

步骤（2.1）初始化多栈下推系统

设立多栈下推系统和上下文切换次数K=1，其中：

S是有限的状态集合；{s₀=(l)}∈S是初始状态；

St={st_w∪{st_p}_p∈P∪{st_q}_q∈Q}，初始时，各栈st∈St的栈内容σ_st为空，表示为σ_st=ε；

其中：Π队列对应的局部栈字母表，Γ进程对应的局部栈的字母表，总称字母表；

Δ=Δ_int∪_pop∪Δ_push，详细定义如表1所示；

假定：多栈下推系统的格局是一个元组c=(s,σ_st∈St)，其中s是全局变量的赋值，对于每个进程的栈st_p∈St，σ_st=(CP,L)^*，其中CP是程序的控制位置，L是局部变量的赋值；对于每个队列对应的栈st_q∈St，栈内容σ_st∈Π^*；

初始格局c_in=((l),σ_st∈St)，即当前全局变量的值是l∈{T,F}，其他下推系统对应的栈内容为空；

步骤（2.2）、建立工作列表WL

按照所述并发递归程序的执行顺序把所述上下文(p,q)转换为依次衔接的格局项(c,k)，k≤1的编号存储于工作列表内，并初始化所述初始格为c_in=((l),ε，ε，ε，ε，ε，ε)。

步骤（2.3）、初始上下文(p,q)选择

定义二元组（p,q）是所述并发递归程序的一个执行上下文，其中p是进程，q是进程间通信的队列。指定上下文（p₀,q₀）为初始上下文，并对各栈st初始化：根据队列q和进程p对应的迁移关系集合Δ，把队列q对应栈st_q的内容压入工作栈st_w的底部，将进程p对应的栈st_p内容压入工作栈st_w的顶部，并初始化自动机A_p0。

步骤（2.4）、按以下步骤从所述初始上下文（p₀,q₀）开始，对所述工作队列表中各个格局项编号中的内容进行上下文切换可达性计算。

步骤（2.5）、根据Post^*算法计算接受上下文（p₀,q₀）正向可达格局的下推自动机A′_p0，修改A′_p0的状态，修改后的格局添加到工作列表WL、可达格局集合Reach。

最后计算出多栈下推系统在一次上下文切换内可达格局集合Reach(1)=Reach((p₀,q₀))∪Reach((p₀,q₀)→(p₁,q₁))∪Reach((p₀,q₀)→(p₁,q₁))，如表2所示，其中：

Reach((p₀,q₀))是上下文(p₀,q₀)执行的正向可达格局集合；Reach((p₀,q₀)→(p₁,q₁))是上下文(p₀,q₀)切换到(p₁,q₁)执行的正向可达格局集合；Reach((p₀,q₀)→(p₁,q₁))是上下文(p₀,q₀)切换到(p₂,q₂)执行的正向可达格局集合。

表2可达格局集合Reach

其中全局共享变量l的赋值为0或者1；符号“⊥”表示变量尚未赋值；

符号“ε”表示进程或者队列对应的栈内容为空，或者当前进程的控制位置的值为空（执行结束返回）；

其中格局<(l),(f_{_0},3)(f_{_0},4)(f_{_0},5)(p_{0_1},⊥,⊥),ε,ε,a,ε,ε>表示程序R的状态、各个栈的内容、各个队列的内容的情况，即全局变量l赋值为T或者F，进程p₀执行到控制位置p_{0_1}，调用函数f，其中函数f对应的局部变量取值分别为3，4，5，依次存储在进程p₀的调用栈中，其中(f_{_0},3)位于栈顶位置，(p_{0_1},⊥,⊥)位于栈底位置，即函数f执行结束后的返回地址；进程p₁和进程p₂的调用栈分别为空，消息队列q₁中存储消息a，消息队列q₂和q₃为空；

根据计算出的每个格局，能够清楚地了解程序R中出现的变量、调用栈、消息队列的取值和内容，当程序执行到某个错误状态s时，能够充分利用执行路径中各个格局提供的信息查找错误产生的原因。

步骤（3）、目标可达性的判定分析

给定目标状态集合T={<0,(ε,a,120),ε,(ε,c),ε,b,ε>；<1,(ε,a,24),(p_{1_1},⊥,0,0),ε,ε,b,c>}，通过判断计算出的可达格局集合Reach(1)的交集是否为空，得出目标状态的可达性如下：

Reach(1)∩T＝{<0,(ε,a,120),ε,(ε,c),ε,b,ε>}，二者的交集不为空，因此得出结论：

（1）目标状态集合T的状态<0,(ε,a,120),ε,(ε,c),ε,b,ε>在1次上下文切换执行内是可达的；

（2）目标状态集合T的状态<1,(ε,a,24),(p_{1_1},⊥,0,0),ε,ε,b,c>在1次上下文切换执行内是不可达的。

上述实施实例，仅为对本发明的目的、技术方案进一步详细说明的具体个例，本发明并非限定于此。凡在本发明的公开的范围之内所做的任何修改、等同替换、改进等，均包含在本发明的保护范围之内。

Claims (1)

1.基于上下文定界的消息队列通信并发递归程序的验证方法，其特征在于：是一种基于良序消息队列通信的递归队列并发程序RQCP上下文切换定界的可达性辨识之上的程序验证方法，所述良序消息队列里是仅当进程的局部栈为空时，进程才能从队列中读取消息中途不允许被中断，直至执行结束时才处理下一个任务，所述的递归队列并发程序，以下简称RQCP，用R表示，是在一台多核处理器中依次按以下步骤实现验证的，

步骤(1)、依次按以下步骤把所述的R转换为一个多栈下推系统，用表示，以便把上下文(p,q)切换定界可达性问题转换为多栈下推系统的阶定界可达性问题，其中k次上下文切换对应于3k+1个阶，其目的在于把基于良序消息队列通信的递归队列并发程序R转换为一个等价的用于模拟R执行的多栈下推系统，该多栈下推系统的执行对应于所述R所包含的动作或行为，步骤如下：

步骤(1.1)、构建R的抽象模型

给定一个体系结构A＝(P,Q,Sender,Receiver)，P是有限进程集合，Q是有限队列集合，Sender:Q→P和Receiver:Q→P是两个指派函数，分别为每个队列q∈Q唯一指派的发送进程和接收进程，并规定每个队列的发送进程和接收进程是不同的：即对于q∈Q，Sender(q)≠Receiver(q)，

设：Π表示有限的消息字母表，m∈Π表示消息，p∈P表示一个进程，q∈Q表示一个队列；

Act_p表示一个进程p的动作集合，Act＝∪_p∈P Act_p表示所有进程的动作集合；

Calls表示所有进程的调用动作的集合，表述为{p:call|p∈P}，p:call为描述过程调用的局部栈动作；

Rets表示所有进程的返回动作的集合，表述为{p:ret|p∈P}，p:ret为描述过程返回的局部栈动作；其中：

p:call相当于进程p的局部过程调用，进程p把至少包括地址、局部变量的赋值在内的数据送到局部栈的栈顶，并迁移到新状态；

p:ret相当于进程p中过程调用的返回，弹出局部栈的内容并迁移到另一个新状态，所述另一个新状态依赖于进程p的当前状态及所述的局部栈中弹出的数据；

动作p:send(q,m)表示进程p向接收队列q中写入消息m；

动作p:recv(q,m)表示进程p从所述接收队列q中读取消息m；

动作p:int表示进程p的对队列不处理的一个内部动作；

给定一个体系结构A＝(P,Q,Sender,Receiver)，在所述体系结构A上运行的递归队列并发程序是一个五元组R，R＝(S,s₀,Π,Γ,{T_p}_p∈P)，其中S是有限的状态集合，s₀∈S是初始状态，Π是所述的有限的消息字母表，Γ是有限的局部栈字母表，T_p是进程p的迁移关系集合，表示如下：

$T_p\&SubsetEqual;(S\&times;({\mathrm{Act}}_p\backslash \{p:\mathrm{call},p:\mathrm{ret}\left\}\right)\&times;S)\&cup;(S\&times;\{p:\mathrm{call}\}\&times;S\&times;\mathrm{\&Gamma;})\&cup;(S\&times;\{p:\mathrm{ret}\}\&times;\mathrm{\&Gamma;}\&times;S),$

其中进程p的动作的形式如下：

1)p:send(q,m)，其中m∈Π，q∈Q，且Sender(q)＝p；

2)p:recv(q,m)，其中m∈Π，q∈Q，且Receiver(q)＝p；

3)p:int，或者p:call或者p:ret；

步骤(1.2)、R的操作语义描述

给定递归队列并发程序R＝(S,s₀,Π,Γ,{T_p}_p∈P)，其中：

{T_p}_p∈P是所有进程p的迁移关系集合；

其格局是一个三元组(s,{σ_p}_p∈P,{μ_q}_q∈Q)，其中s∈S是状态；

符号{σ_p}∈Γ^*是进程p的进程局部栈的内容，表示为σ_p∈Γ^*，Γ^*是所述进程局部栈字母上的闭包；

符号{μ_q}∈Π^*是队列q的内容，表示为μ_q∈Π^*，Π^*是消息字母上的闭包；

假设进程p的栈顶内容位于σ_p的最左端，栈底内容位于σ_p的最右端；

队列q的队尾消息位于μ_q的最左端，队头消息位于μ_q的最右端；

使用以下操作语义描述格局之间的迁移关系：

操作 $\left[\mathrm{Internal}\right]\frac{\mathrm{act}=p:\mathrm{int}(s,p:\mathrm{int},s^{\&prime;})\&Element;T_p}{(s,{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})\stackrel{\mathrm{act}}{\&RightArrow;}(s^{\&prime;},{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})}$ 为内部动作，表示：执行动作p:int，使R的状态由但{σ_p}、{μ_q}的内容没有改变；

操作 $\left[\mathrm{Send}\right]\frac{\mathrm{act}=p:\mathrm{send}(q,m)(s,p:\mathrm{send}(q,m),s^{\&prime;})\&Element;T_p\mathrm{Sender}\left(q\right)=p}{(s,{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_{q^{\&prime;}}\right\}}_{q^{\&prime;}\&Element;(Q\backslash \{q\left\}\right)}\&cup;\{{\mathrm{\&mu;}}_q\left\}\right)\stackrel{\mathrm{act}}{\&RightArrow;}(s^{\&prime;}{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_{q^{\&prime;}}\right\}}_{q^{\&prime;}\&Element;(Q\backslash \{q\left\}\right)}\&cup;\{m\&CenterDot;{\mathrm{\&mu;}}_q\left\}\right)}$ 为写入，表示：执行动作p:send(q,m)，写入进程为p，使R的状态由使队列的内容{μ_q′}中除了{μ_q}外还写入了消息m；

操作 $\left[\mathrm{Receive}\right]\frac{\mathrm{act}=p:\mathrm{recv}(q,m)(s,p:\mathrm{recv}(q,m),s^{\&prime;})\&Element;T_p\mathrm{Receiver}\left(q\right)=p}{(s,{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_{q^{\&prime;}}\right\}}_{q^{\&prime;}\&Element;(Q\backslash \{q\left\}\right)}\&cup;\{{\mathrm{\&mu;}}_q^{\&prime;}.m\left\}\right)\stackrel{\mathrm{act}}{\&RightArrow;}(s^{\&prime;},{\left\{{\mathrm{\&sigma;}}_p\right\}}_{p\&Element;P},{\left\{{\mathrm{\&mu;}}_{q^{\&prime;}}\right\}}_{q^{\&prime;}\&Element;(Q\backslash \{q\left\}\right)}\&cup;\{{\mathrm{\&mu;}}_a^{\&prime;}\left\}\right)}$ 为接受，表示执行动作p:recv(q,m)，读取方是p，从s状态下的队列{μ′_q.m}中读取消息m，使R的状态由使队列q的内容{μ′_q}中被读取了消息m，写入时的{μ_q}不一定等于读取时的{μ′_q}；

操作 $\left[\mathrm{Call}\right]\frac{\mathrm{act}=p:\mathrm{call}(s,p:\mathrm{call},s^{\&prime;},\mathrm{\&gamma;})\&Element;T_p}{(s,\left\{{\mathrm{\&sigma;}}_p\right\}\&cup;{\left\{{\mathrm{\&sigma;}}_{p^{\&prime;}}\right\}}_{p^{\&prime;}\&Element;(P\backslash \{p\left\}\right)},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})\stackrel{\mathrm{act}}{\&RightArrow;}\left(s^{\&prime;}\right\{{\mathrm{\&gamma;\&sigma;}}_p\}\&cup;{\left\{{\mathrm{\&sigma;}}_{p^{\&prime;}}\right\}}_{p^{\&prime;}\&Element;(P\backslash \{p\left\}\right)},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})}$ 为调用，表示：执行动作p:call，在s状态下进程p根据规则γ调用至少包括地址、局部变量的赋值在内的数据送到对应于进程p的局部栈的内容{σ_p′}的最左端，使得状态由{σ_p′}添加为{γσ_p′}；

操作 $\left[\mathrm{Return}\right]\frac{\mathrm{act}=p:\mathrm{ret}(s,p:\mathrm{ret},\mathrm{\&gamma;},s^{\&prime;})\&Element;T_p}{(s,\{{{\mathrm{\&gamma;\&sigma;}}^{\&prime;}}_p\}\&cup;{\left\{{\mathrm{\&sigma;}}_{p^{\&prime;}}\right\}}_{p^{\&prime;}\&Element;(P\backslash \{p\left\}\right)},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})\stackrel{\mathrm{act}}{\&RightArrow;}(s^{\&prime;},\{{{\mathrm{\&sigma;}}^{\&prime;}}_p\}\&cup;{\left\{{\mathrm{\&sigma;}}_{p^{\&prime;}}\right\}}_{p^{\&prime;}\&Element;(P\backslash \{p\left\}\right)},{\left\{{\mathrm{\&mu;}}_q\right\}}_{q\&Element;Q})}$ 为返回，表示：执行动作p:ret，在s状态下，根据规则γ，弹出进程p的进程局部栈的内容{γσ′_p}中按规则γ调用的至少包括地址、局部变量的赋值在内的数据，剩下原先的内容{σ′_p}，使状态状态，所述调用的{γσ′_p}与返回的{σ′_p}不一定相同；

步骤(1.3)、用一个多栈下推系统模拟良序消息队列的递归队列并发程序的执行

给定：良序消息队列的递归队列并发程序R＝(S,s₀,Π,Γ,{T_p}_p∈P)，

构造一个模拟所述良序消息队列的递归队列并发程序R的k-上下文切换定界执行的多栈下推系统其中：

S是有限的状态集合，s₀∈S是初始状态；

St是局部栈集合，包括工作局部栈st_w，进程p对应的局部栈st_p，队列q∈Q对应的局部栈st_q，St表示为St＝{st_w∪{st_p}_p∈P∪{st_q}_q∈Q}，各局部栈初始化为空；

Γ_M是字母表，包括队列对应的局部栈字母表，与进程对应的局部栈的字母表，Γ_M表示为Γ_M＝Π∪Γ；

Δ是迁移关系集合，包括：

Δ_int内部迁移关系集合，

Δ_push写入迁移关系集合，包括push_q和push_p，其中：push_q与进程p的写入队列操作相关的迁移关系，push_p与进程p的入栈操作相关的迁移关系，

Δ_pop读取迁移关系集合，包括pop_q和pop_p，其中：pop_q与进程p的读取队列操作相关的迁移关系，pop_p与进程p的出栈操作相关的迁移关系，

从而得到迁移关系集合Δ的表达式为：

Δ＝Δ_int∪Δ_pop∪Δ_push，

在上下文(p,q)内，所述上下文定义为：某个进程任意长度的连续执行序列，进程p仅能从一个队列中读取消息，但可向所有输出消息的任一队列q写入消息，所述进程p能执行的迁移关系定义如下：

规则 $\left[\mathrm{internal}\right]\frac{(s,p:\mathrm{int},s^{\&prime;})\&Element;T_p}{(s,p:\mathrm{int},s^{\&prime;})\&Element;{\mathrm{\&Delta;}}_{\mathrm{int}}},$

规则 $\left[{\mathrm{push}}_q\right]\frac{(s,p:\mathrm{send}(q,m),s^{\&prime;})\&Element;T_p\mathrm{Sender}\left(q\right)=p}{(s,p:\mathrm{send}(q,m),s^{\&prime;})\&Element;{\mathrm{\&Delta;}}_{\mathrm{push}}},$

规则 $\left[{\mathrm{push}}_p\right]\frac{(s,p:\mathrm{call},s^{\&prime;},\mathrm{\&gamma;})\&Element;T_p}{(s,p:\mathrm{call},s^{\&prime;},\mathrm{\&gamma;})\&Element;{\mathrm{\&Delta;}}_{\mathrm{push}}},$

规则 $\left[{\mathrm{pop}}_q\right]\frac{(s,p:\mathrm{recv}(p,m),s^{\&prime;})\&Element;T_p\mathrm{Receiver}\left(q\right)=p}{(s,p:\mathrm{recv}(q,m),s^{\&prime;})\&Element;{\mathrm{\&Delta;}}_{\mathrm{pop}}},$

规则 $\left[{\mathrm{pop}}_p\right]\frac{(s,p:\mathrm{ret},\mathrm{\&gamma;},s^{\&prime;})\&Element;T_p}{(s,p:\mathrm{ret},\mathrm{\&gamma;},s^{\&prime;})\&Element;{\mathrm{\&Delta;}}_{\mathrm{pop}}},$

规则表示把所述的R内队列操作相关的迁移关系添加到所述的多栈下推系统中对应的迁移关系集合中去，

根据以上转换方法构造的多栈下推系统能模拟良序排队的递归队列并发程序R的执行，并且的3k+1阶定界可达问题相当于R的k上下文切换定界可达问题；

步骤(2)、按如下步骤执行基于可达算法Post^*的可达格局集合Reach计算

步骤(2.1)、初始化多栈下推系统

设立多栈下推系统和上下文切换次数K，0≤k≤K，其中：多栈下推系统是下推系统的自然扩展，包含多个栈结构；K是一个正整数，也是Post^*算法的迭代次数；其中：

S是有限的状态集合，s₀∈S是初始状态；

St＝{st_w∪{st_p}_p∈P∪{st_q}_q∈Q}，初始时，各栈st∈St的栈内容σ_st为空，表示为σ_st＝ε；

其中：Π是在多栈下推系统上运行的队列对应的局部栈字母表，Γ是进程对应的局部栈的字母表，总称字母表；

Δ是迁移关系集合，Δ＝Δ_int∪Δ_pop∪Δ_push；

定义：输出可达格局集合Reach，集合Reach中存储的是在至多k次上下文切换执行内正向可达的格局，用c表示，c＝<s₀,{σ_st}_st∈St>，σ_st表示栈st∈St的内容；多栈下推系统的初始格局是c_in＝<s₀,{σ_st}_st∈St>，以及对应的切换次数k，以格局项(c,k)的形式存储在可达格局Reach的工作列表WL上，初始时的初始格局是c_in＝<s₀,{σ_st}_st∈St>，内容σ_st为空，

给定的目标格局状态集合T，所述目标状态集合T定义为一种错误状态集合，表示为是一种在所述递归队列并发程序不可能出现的错误状态的集合，

步骤(2.2)、建立工作列表WL

按照所述递归队列并发程序的执行顺序把所述上下文(p,q)转换为依次衔接的格局项(c,k)，0≤k≤K的编号存储于工作列表内，并初始化初始格局为c_in，

步骤(2.3)、初始上下文(p,q)选择

定义二元组(p,q)是所述递归队列并发程序的一个执行上下文，其中p是进程，q是进程间通信的队列，并且随机或指定某个上下文(p,q)为初始上下文，并对各栈st初始化：根据队列q和进程p对应的迁移关系集合Δ，把队列q对应栈st_q的内容压入工作栈st_w的底部，将进程p对应的栈st_p内容压入工作栈st_w的顶部，

假定是上下文(p,q)下进程p的下推系统，建立接受上下文(p,q)的初始格局的下推自动机A_p＝(Q,Γ,→₀,P,F)，对应所述的体系结构A，其中：Q是自动机的控制位置集合，对应所述体系结构A的状态集合；Γ是自动机接受的字母表，对应所述体系结构A接受的字母表；→₀是自动机的转移函数，P是初始控制位置集合，对应所述体系结构A的初始状态集合；F是终止控制位置集合，对应所述体系结构A的终止状态集合，

对于下推自动机A_p，存在接受其正向可达格局集合的下推自动机A′_p＝post^*(A_p)，给定初始格局为<s₀,σ_st>的下推系统及其对应的迁移关系集合Δ，可以计算接受下推系统正向可达格局集合为语言的下推自动机

步骤(2.4)、按以下步骤从所述初始上下文(p,q)开始，对所述工作队列表WL中各个格局项编号中的内容进行上下文切换可达性计算，

步骤(2.4.1)、从工作列表WL中取出一个编号对应于初始上下文(p,q)的格局项，并分别存储在进程局部栈st_p和队列局部栈st_q中：进程p逆序地存储存储在st_p和中，栈底存储队尾指向的内容，栈顶存储队头指向的内容，队列q是顺序存储在栈st_q中：栈顶存储队尾指向的内容，栈底存储队头指向的内容，

步骤(2.4.2)、再把栈st_q的内容存储在工作栈st_w的底部，栈st_p的内容存储在工作栈st_w的顶部，

步骤(2.4.3)、使另一个进程局部栈栈st_p和队列栈st_q初始化为空，在把初始上下文(p,q)切换为上下文(p′,q′)时，此时迭代次数k≤K,对工作栈st_w的顶部和底部进行出栈操作，把读取的内容分别存储到栈st_p和st_q中，

步骤(2.4.4)、按以下步骤计算进程中的初始格局是否属于正向可达格局集合的初始格局：

步骤(2.4.4.1)、若所述多栈下推系统中对应于初始上下文(p,q)的迁移关系集合是写入迁移关系集合Δ_push，δ＝(s,st_q′,a,s′)∈Δ_push，a是消息，且格局<s′,σ′_p>，σ′_p＝aσ_p，σ_p是栈st_p的内容，则向栈st_q′中入栈消息a，

步骤(2.4.4.2)、若所述多栈下推系统中对应于初始上下文(p,q)的迁移关系集合是读取迁移关系集合Δ_pop，δ＝(s,st_q,a,s′)，且格局为<s′,ε>，则弹出栈st_q内的消息a，局部栈为空，

步骤(2.4.4.3)、修改状态s′的可达格局赋值为x，把格局项(x,i+1)添加到工作列表WL中，

步骤(2.4.4.4)、在继续从初始上下文(p,q)开始向下执行上下文切换之后，执行步骤(2.5)，

步骤(2.5)、根据Post^*算法计算接受上下文(p,q)正向可达格局集合的下推自动机A′_p＝Post^*(A_p)，A_p是接受进程p初始格局的下推自动机，修改A′_p的状态，修改后的格局添加到工作列表WL，以及可达格局集合Reach，

步骤(2.5.1)、对于s′∈S(A′_p)，如果下推自动机A_p∈{P\p}的初始状态与状态s相同，使用rename(A_p∈{P\p},s′)修改A_p∈{P\p}的初始状态为s′，避免自动机A′_p的初始状态与自动机A_p中的状态重名而产生冲突，

步骤(2.5.2)、使用函数update(A′_p,s′)重命名A′_p中除s′之外的其他状态，并更新S不包含的状态，即修改格局的赋值为x＝<s′,update(A′_p,s′),rename(A_p∈{P\p},s′),update(σ_st\{p∈P})>，

步骤(2.5.3)、最后修改后的可达格局赋值为x，将格局项(x,k+1)添加到工作列表WL，并将格局x添加到集合Reach，

步骤(3)、目标可达性的判定分析

根据正向可达格局集合Reach(k)和给定的目标状态集合T，目标状态集合T视为R中不可能出现的状态的集合，也称错误状态集合，进而计算集合Reach和集合 的交集是否为空，上下文切换次数k的值从0不断增大，直至可用计算资源被耗尽，

步骤(3.1)、若Reach∩T非空，则经过k次上下文切换的运行，某个目标状态s∈S是可达的，则存在一个起始于初始格局的执行路径能够到达该错误状态，进而根据进程在各个状态的局部栈的内容和消息队列的内容，尝试查找产生错误的原因，

步骤(3.2)、若Reach∩T为空，则经过k次上下文切换的运行，目标状态s∈S是不可达的，状态s不可达的判断步骤如下：

a)经过k次上下文切换的运行，搜索的状态空间覆盖度不足以覆盖目标状态，此时可以增大k的值并继续求解，直至耗尽所有可用的计算资源；

b)若根据步骤a)仍不能判定目标状态是可达的，则得出结论：在现有计算能力下目标状态是不可能出现的。