Proteus: Computing Disjunctive Loop Summary via Path Dependency Analysis 通过路径依赖分析计算析取形式的循环总结

摘要

对于程序分析来说，循环是非常难以处理的结构，特别是多种路径相互交错的复杂循环。
文章首先基于在循环条件中的变量的更新和循环路径的执行顺序对多路径的循环进行分类，进而来理解循环的复杂性。
之后，文章提出分析框架Proteus。该框架把循环和我们感兴趣的变量集合作为输入，然后通过分析，可以得到关于这些变量经过循环之后的变化情况的摘要。

文章主要的贡献是利用路径依赖自动机(path dependency automaton, PDA)来捕获路径之间的执行依赖。然后利用DFS遍历PDA来对所有可行的执行路径的影响进行摘要。

实验结果说明Proteus在三个方面有非常重大的应用：

• 能分析出比现有的循环边界分析技术更精确的循环边界
• 显著优于最先进的循环验证工具
• 在1秒钟内对非常深的循环产生测试样例，KLEE或者Pex面对这样的循环时可能会花费更多时间或者失败。

概览

相关定义

循环的流图，flowgraph of the loop

是一个元组：$G=(V,E,v_s,v_t,v_e,l)$

• V：节点的集合
• E：V × V是一个边的集合，链接两个顶点
• 顶点$v_s,v_t\in V$，是两个虚拟的节点，用来表示每次循环开始时的开始节点和结束节点
• $v_e$是一个虚拟节点，代表退出循环
• $l$是一个函数，为每一条边$e\in E$分配一个指令$l(e)$

如果一个节点的出度是2，并且在这两条边上的指令是布尔条件，那么我们称这个节点为分支节点。

循环路径，loop path

$G$中的一条循环路径$\pi$是一个有限的节点序列$<v_1{v}_2\cdots v_k>$，其中$k\ge 1$， $(v_i,v_{i+1})\in E,1\le i<k,v_1=v_s$并且 v k ∈ { v t , v e } v_k \in \lbrace v_t, v_e \rbrace vk​∈{vt​,ve​}。
一个路径被叫做迭代路径(iterative path),如果$v_k=v_r$。
${\theta }_{\pi }$表示路径$\pi$的条件，实际上是该路径到达该点之前，所有边上的分支条件的合取。
给定流图G，用${\Pi }_G$来表示G中所有边的集合

归纳变量，induction variable

给定流图G，一个变量x被称为归纳变量，如果$\forall \pi \in {\Pi }_G$，对于路径$\pi$的任意的$i^{th},j^{th}$次迭代，有${\Delta }_{\pi }^{i}x={\Delta }_{\pi }^{j}x$，否则，我们就称x是非归纳变量。

条件分类

每一条路径的条件都可以被转换成$E\sim 0$。这里$E$是一个表达式， ∼ ∈ { < , ≤ , > , ≥ , = } \sim \in \lbrace <, \le, >, \ge, =\rbrace ∼∈{<,≤,>,≥,=}。

• IV Condition。如果E是一个归纳变量，那么这是一个IV体哦阿健
• NIV Condition。如果E不是一个归纳变量

循环执行，loop execution

给定流图G和前置条件，循环执行${\rho }_G$是一个路径序列$<{\pi }_1,{\pi }_2,\cdots ,{\pi }_i,\cdots >$，且$\forall i\ge 1,{\pi }_i\in {\Pi }_G$。

• 我们用${\pi }_i\dots \ast {\pi }_j$表示在${\rho }_G$中从${\pi }_i$到${\pi }_j$的部分。
• 我们使用循环执行(loop execution)的概念去定义路径间交互的模式。循环的前置条件说明了在进入循环前，变量的所满足的一些约束。在不同的前置条件下，循环可能会有不同的执行。
• 如果存在$i\ne j$，${\pi }_i\to \ast {\pi }_j\to \ast {\pi }_i$是${\rho }_G$的自己，那么${\rho }_G$包含了一个环
  • 这个环是**周期的(periodic)**如果执行有类似于$<{\pi }^{k_i},\cdots ,{\pi }^{k_j},\cdots {>}^{+}$(循环周期是$<{\pi }^{k_i},\cdots ,{\pi }^{k_j},\cdots >$)这里$k_i$和$k_j$是常量值，表示${\pi }_i$和${\pi }_j$的执行次数
• 给定循环流图G，我们可以将循环执行${\rho }_G$分成三种类型：
  • 序列执行(Sequential Execution)。如果${\rho }_G$不包含任何环，他是序列执行
  • 周期执行(Periodic Execution)。如果${\rho }_G$中的所有环都是周期的，那么他是周期执行。
  • 不规律执行(Irregular Execution)。如果一个循环执行既不是周期的又不是序列的，那么我们把他叫做不规律的执行。这种情况下，循环包括环，但是路径之间相互作用的模式不能被静态的决定，所以，我们不能很容易的知道每条路径的循环次数。

循环分类，Loop classification

循环可以进行如下分类：

	IV condition($\forall$)	NIV condition($\exists$)
Sequential	Type 1	Type3
Periodic	Type1	Type3
Irregular	Type2	Type4

Path Dependency Automaton

Path dependency automaton(PDA)是一个4元组$M=(S,\text{ init, accept },\hookrightarrow )$

• S是一个有限的状态(state)集合，其中每一个元素都代表了${\Pi }_G$中的一条路径。每个状态是一个三元组$({\pi }_s,{\theta }_s,{\Delta }_{s}X)$，其中${\pi }_s\in {\Pi }_G$代表了对应的路径，${\theta }_s$是${\pi }_s$的路径条件，${\Delta }_{s}X$代表所有归纳变量在执行完一次${\pi }_s$之后数值变化情况的集合。

• $init\subseteq S$是一个初始状态的集合。

• $accept\subseteq S$是accepting state的集合，他们没有后继节点。一个accepting state被叫做exit state，如果他表示一条退出路径；被叫做terminal state如果代表了一条迭代路径。

• $\hookrightarrow \subseteq S\times S$是有限的状态转换的集合。我们使用$s_i\hookrightarrow s_j$来表示变换$(s_i,s_j)\subseteq \hookrightarrow$，并且引入一个变量$k_{ij}$来作为状态计数(state counter)，用来表示$k_{ij}$次执行$s_i$之后，可以从$s_i$转换到$s_j$。
  形如$s_i\hookrightarrow s_j$的转换都会有一个三元组的转移谓词作为注释$({\varphi }_{ij},{\psi }_{ij},U_{ij})$。其中：

  • ${\varphi }_{ij}$是关于$k_{ij}$的约束
  • ${\psi }_{ij}$是guard condition，当$s_i\hookrightarrow s_j$将被触发时将被满足。

  这里${\varphi }_{ij},{\psi }_{ij}都时变量在进入$s_i$之前的条件， $U_{ij}$是计算$X^{\prime }$的函数，$X^{\prime }$表示变量$X$在执行$k_{ij}$次状态$s_i$后的值。也就是说，$X^{\prime }=U_{ij}(X,k_{ij})$。

对于上面的例子，(b)中展示的就是从程序生成的PDA。在这个PDA中：
S = { s 1 . s 2 , s 3 } S=\lbrace s_1.s_2,s_3 \rbrace S={s1​.s2​,s3​},代表图中的三条路径。
i n i t = { s 1 , s 2 , s 3 } init=\lbrace s_1, s_2, s_3 \rbrace init={s1​,s2​,s3​}代表了初始的状态(标记为红色)，并且 a c c e p t = { s 3 } accept=\lbrace s_3 \rbrace accept={s3​}代表了退出循环的一条路径。
对于$s_1$，它代表路径${\pi }_1$，并且路径条件${\theta }_{s_1}$是$x<n\wedge z>x$。
变量经过${\pi }_1$之后的变化 Δ s 1 { x , z , n } = { 1 , 0 , 0 } \Delta_{s_1} \lbrace x,z,n\rbrace=\lbrace 1,0,0\rbrace Δs1​​{x,z,n}={1,0,0}（这里忽略了经过迭代之后不会变化的变量）。
转换上面的表格表示了转换的谓词。对于转换$s_1\hookrightarrow s_2$，它表明执行$k_{12}$次$s_1$后，状态将变成$s_2$。
第一行表明了对$k_{12}$的约束，第二行是guard condition ${\varphi }_{12}$,$z<n$表明当$z<n$满足时，$s_1$将在执行了$k_{12}$次之后，转换为$s_2$。
方程$U_{12}$为 { x ′ . z ′ , n ′ } = { z , z , n } \lbrace x'.z',n' \rbrace=\lbrace z,z,n \rbrace {x′.z′,n′}={z,z,n}，表明执行之后，x，z，n分别编程类z，z和n。这里表格中的变量x，n，z不是循环前的初始值，而是表示执行转换的源状态之前的值。

PDA构建算法

继续使用例子：

考虑转换$s_1\hookrightarrow s_2$。让$k_{12}$为变量计数，第$k_{12}-1$和第$k_{12}$次执行${\pi }_1$时，变量的状态分别是 X k 12 − 1 ′ : { x ′ = x + k 12 − 1 , n ′ = n , z ′ = z } X'_{k_{12}-1}:\lbrace x'=x+k_{12} - 1,n'=n,z'=z\rbrace Xk12​−1′​:{x′=x+k12​−1,n′=n,z′=z}， X k 12 ′ : { x ′ = x + k 12 , n ′ = n , z ′ = z } X'_{k_{12}}:\lbrace x'=x+k_{12},n'=n,z'=z\rbrace Xk12​′​:{x′=x+k12​,n′=n,z′=z}。接下来，我们将两个路径条件${\theta }_{s_1}$和${\theta }_{s_2}$中的$X$分别用$X_{k_{12}-1}^{\prime },X_{k_{12}}^{\prime }$进行替换，之后再进行合取，可以得到cond为：
$$(x+k_{12}-1<n)\wedge (z>x+k_{12}-1)\wedge (x+k_{12}<n)\wedge (z\le x+k_{12})$$
经过不等式化简之后，我们可以得到：
$${\varphi }_{ij}:z-x\le k_{12}<z-x+1$$
利用这个信息，可以进一步得到简化的cond：
$$z<n({\phi }_{12})$$
更新方程$U_{12}$为：
{ x ′ , n ′ , z ′ } = { x + 1 × k 12 , n + 0 × k 12 , z + 0 × k 12 } = { z , n , z } \lbrace x',n',z'\rbrace=\lbrace x+1\times k_{12},n+0\times k_{12},z+0 \times k_{12}\rbrace=\lbrace z,n,z \rbrace {x′,n′,z′}={x+1×k12​,n+0×k12​,z+0×k12​}={z,n,z}
同理，可以得到${\phi }_{21}=x<n$对于转换$s_2\hookrightarrow s_1$，并且${\phi }_{21}$可以被简化为$true$因为${\theta }_{s_2}$蕴含$x<n$。

分离形式的循环摘要

DLS

给定PDA M，和一些归纳变量X某一条trace $\tau \in M$的摘要可以被表示为$(t_{c_{\tau }},X_{\tau })$。这里：

• $t_{c_{\tau }}$是当trace $\tau$有效时需要满足的条件
• $X_{\tau }$是在执行完这条trace之后，变量的值

M的循环摘要$S_M$为 ∪ τ ∈ E M { ( t c τ , X τ ) } \cup_{\tau \in E_{M}} \lbrace(t_{c_{\tau}},X_{\tau})\rbrace ∪τ∈EM​​{(tcτ​​,Xτ​)}，即将所有trace的摘要进行union。

对Type 1型循环的摘要

算法2是对Type 1型循环做摘要的更细节的程序。
使用循环M的PDA作为输入，在进入循环前的前置条件，并且返回摘要$S_M$。
设X为归纳变量，包含了我们感兴趣的变量，rec是记录当前trace(从初始状态到现在状态)的摘要的map。
算法2对每个初始状态进行遍历，并且对初始状态开始的所有有效的trace做摘要。

算法3使用深度优先搜索来总结每个trace重的每一个转换，直到它到达accepting state。输入时当前的状态$s_i$，当前的trace在DFS到达当前状态之前的条件${\tau }_C$，和变量的值$X^{\prime }$在之前的循环摘要中，以及摘要map rec。
如果$s_i$在rec中存在，那么说明存在环，我们要通过周期对其进行摘要。如果$s_i$是accepting state，那么对一条trace的摘要就完成了。
如果accepting state是退出状态，兵团且$t_C$满足当前路径的条件，那么$X^{\prime }$会在最后被更新为${\Delta }_{s_i}{X}^{\prime }$。如果$s_i$是终止状态，那么当前的trace代表无限的执行。所以$X^{\prime }$会被更新为${\Delta }_{s_i}^{\infty }{X}^{\prime }$。实现时，文章用了符号无限值(symbolic infinite value)去代表无穷的更新。

另一方面，如果$s_i$不是accepting state，那么算法会继续对$s_i$和他的后继进行摘要。程序会检查当前状态能否转化成它的后续状态，如果可以，那么就进行更新。

PDA

info

从初始状态$s_3$开始，程序退出，变量没有变化，所以trace $s_3$的摘要是$(x\ge n,x^{\prime }=x\wedge z^{\prime }=z\wedge n^{\prime }=n)$;从初始状态$s_1$开始，初始条件是$x<n\wedge z>x$,如果处理后继$s_3$，那么trace condition变成$x<n\wedge z>x\wedge z\ge n$,化简为$x<n\le z$.变量被更新为 { x ′ = n ∧ z ′ = z ∧ n ′ = n } \lbrace x'=n \wedge z'=z \wedge n' = n \rbrace {x′=n∧z′=z∧n′=n}所以，$s_1\hookrightarrow s_3$的摘要为$(x<n\le z,k_{13}=n=x\wedge x^{\prime }=n\wedge z^{\prime }=z\wedge n^{\prime }=n)$

环型摘要

多重相互链接的环如(a)被视为irregular execution。对于(b)这种有周期的环，实际执行路径如©所示。执行包括两部分

• $k(\ge 0)$次执行整个环
• 一次执行剩余的部分，蓝色部分
  红色部分会被抽象成一个状态，它的执行表示$k_l,\cdots ,k_j,\cdots ,k_i$次执行状态$s_l,\cdots ,s_j,s_i$

PDA	summary

从第三行，我们可以得到$k_{12}=k_{21}=1$，并且$s_1$已经出现过。所以我们找到了一个环。下面是对该状态进行缩点之后的结果。将循环变成$s_0$。

最后我们可以得到$s_1\hookrightarrow (s_2\hookrightarrow s_1{)}^{+}\hookrightarrow s_3$的摘要是：
$$x<z<n,k_{12}=z-x\wedge k_{03}=n-z\wedge x^{\prime }=n\wedge z^{\prime }=n\wedge n^{\prime }=n$$

对Type 2，3，4类型的摘要

对这些类型提供一些近似方法，使得在某些情况下仍然有效。

NIV Condition

• 如果条件中的变量单调递增或者递减，并且我们只关心路径依赖(例如，在循环边界分析或者终止性分析中)，我们将数值的变化都变成加1或者减1。这种近似可以让变量变成一个归纳变量，这样摘要可以用来获得一些安全的结果。

  例如程序：
  
  i永远是递增的，如果我们想找到这个循环的边界，我们将i每次都增加1，这样我们可以得到bound LINT，并且这是一个safe 的bound。

• 一些NIV条件来自于数据结构的遍历，这非常难以进行摘要。在边界分析中，文章采用了基于模式的方法来解决这一类问题中的一部分。

  例如将

   for(;li! = null;li = li ->next)
  

  转换为：

  for(;li < size(li);li++)
  

• 对于基于输入的NIV条件，他们总是可以满足任何迭代，因为他们的值基于输入或者上下文而不是循环的执行，所以我们将他们抽象成true。

  例如将

   assume(i > 0); while(i >= 0&&v[i] > key) i−−; 
  

  由于v[i]>key是一个NIV条件，我们将其转换为true，可以得到：

  assume(i > 0); while(i >= 0&&true) i−−; 
  

  这样对于路径 π 1 : { } \pi_1:\lbrace \rbrace π1​:{}
  我们可以都得到：
  这时候，结果仍然是精确的，但是当数据结构在循环之间或循环内更新的时候，可能会导致错误。

• 对于Irregular执行，相互作用的模式非常难以决定，所以不考虑任何两条路径之间的相互作用，而是考虑循环整体的影响。对每一条路径${\pi }_i$引入一个计数变量$k_i$，用来计算归纳变量在$k_i$次执行之后的值。
  直觉上，假设${\pi }_i$可以转移到exit path，那么$\forall j\ne i$,在迭代$k_j$次${\pi }_j$和$k_i-1$次${\pi }_i$之后，恰好满足退出的条件；在迭代$k_j$次${\pi }_j$和$k_i$次${\pi }_i$之后，将不能满足退出条件。

  对于程序：
  
  这个例子有随你挑不规则的执行。我们引入$k_1,k_2,k_3$表示他们的执行次数。
  变量经过循环之后可以被表示为$x_1^{\prime }=x_1-k_1，x_2^{\prime }=x_2-k_2,x_3^{\prime }=x_3-k_3$
  对于能够到达exit path的${\pi }_1$，假设$k_1-1$次执行能满足退出路径的条件，$k_1$次不满足，那么我们可以得到：
  $$x_1^{\prime }-(k_1-1)>0\wedge x_2^{\prime }>0\wedge x_3^{\prime }>0\wedge x_1^{\prime }\le 0\wedge x_2^{\prime }>0\wedge x_3^{\prime }>0$$
  这样我们可以得到$x_1^{\prime }=0\wedge x_2^{\prime }>0\wedge x_3^{\prime }>0$
  同样的，如果最后一次执行是${\pi }_2$或者${\pi }_3$，那么可以得到$x_2^{\prime }=0$或者$x_3^{\prime }=0$。
  这个摘要可以被用来验证循环结束之后的性质。

讨论

精度

对于Type 1的摘要是精确的。对其他类型是不精确的，因为引入了不归纳的变量，然而在某些应用下，仍然是精确的。

限制

文章主要关注Type 1的摘要。对于非归纳变量的摘要不能很好的处理。

评估

实验的目标是：

• 了解不同类型的循环在真实世界中的分布
  

• 证明在实际应用中的准确度和效果。

  • loop bound analysis

  • program verification
    

  • Test Case Generation
    

结论

提出了多路径循环的分类，类了解循环的复杂性。基于分类，构建了路径依赖自动机，和循环分析架构来对不同类型的循环产生摘要。