本章是系列文章的第五章,介绍了指针分析方法。指针分析在C/C++语言中非常重要,分析的结果可以有效提升指针的优化效率。

5.1 概念

  • 指针是许多重要编程语言的特性之一
  • 指针的使用,可以避免大量的数据拷贝
  • 指针的分析的难度很大,并且一直是理解和修改程序的主要障碍
  • 指针分析(Pointer Analysis),又可以称为别名分析(Alias Analysis),或者指向分析(Points-To Analysis)

5.2 为什么需要指针分析

1 #include <stdio.h>
2 int main() {
3   int i = 7;
4   int *p = &i;
5   *p = 13;
6   printf("The value of i = %d\n", i);
7 }

给定上面的例子。gcc的-O1选项能优化成什么样子?

将上述代码保存到pta5.1.cc,并使用“gcc -O1 pta5.1.cc -S”进行编译,生成的汇编代码如下:

 1     .file   "pta5.1.cc"
 2     .section    .rodata.str1.1,"aMS",@progbits,1
 3 .LC0:
 4     .string "The value of i = %d\n"
 5     .text
 6     .globl  main
 7     .type   main, @function
 8 main:
 9 .LFB30:
10     .cfi_startproc
11     subq    $8, %rsp
12     .cfi_def_cfa_offset 16
13     movl    $13, %edx
14     movl    $.LC0, %esi
15     movl    $1, %edi
16     movl    $0, %eax
17     call    __printf_chk
18     movl    $0, %eax
19     addq    $8, %rsp
20     .cfi_def_cfa_offset 8
21     ret
22     .cfi_endproc
23 .LFE30:
24     .size   main, .-main
25     .ident  "GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.12) 5.4.0 20160609"
26     .section    .note.GNU-stack,"",@progbits

 

 

从汇编代码看,程序直接忽略掉了第3行和第4行的初始化和传地址操作,直接实现了第5行的赋值和第6行的打印。性能是不是强大了很多。

再看个例子:

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 void sum0(int *a, int *b, int *r, int N) {
 4   int i;
 5   for (i = 0; i < N; i++) {
 6     r[i] = a[i];
 7     if (!b[i]) {
 8       r[i] = b[i];
 9     }
10   }
11 }
12 void sum1(int *a, int *b, int *r, int N) {
13   int i;
14   for (i = 0; i < N; i++) {
15     int tmp = a[i];
16     if (!b[i]) {
17       tmp = b[i];
18     }
19     r[i] = tmp;
20   }
21 }
22 void print(int *a, int N) {
23   int i;
24   for (i = 0; i < N; i++) {
25     if (i % 10 == 0) {
26       printf("\n");
27     }
28     printf("%8d", a[i]);
29   }
30 }
31 #define SIZE 10000
32 #define LOOP 100000
33 int main(int argc, char **argv) {
34   int *a = (int *)malloc(SIZE * 4);
35   int *b = (int *)malloc(SIZE * 4);
36   int *c = (int *)malloc(SIZE * 4);
37   int i;
38   for (i = 0; i < SIZE; i++) {
39     a[i] = i;
40     b[i] = i % 2;
41   }
42   if (argc % 2) {
43     printf("sum0\n");
44     for (i = 0; i < LOOP; i++) {
45       sum0(a, b, c, SIZE);
46     }
47   } else {
48     printf("sum1\n");
49     for (i = 0; i < LOOP; i++) {
50       sum1(a, b, c, SIZE);
51     }
52   }
53 }

在教材中提供的编译器编译的结果看,-O1无法有效优化sum0的指针操作,但对sum1手工优化后的代码能很好的进行指针优化。这是教材中提供的运行数据:

 1 $> time ./a.out
 2 sum0
 3 0 1 0 3
 4 0 11 0 13
 5 real 0m6.299s
 6 user 0m6.285s
 7 sys 0m0.008s
 8 $> time ./a.out a
 9 sum1
10 0 1 0 3
11 0 11 0 13
12 real 0m1.345s
13 user 0m1.340s
14 sys 0m0.004s

但我用gcc5编译实测下来的结果是-O0,确实不会优化,-O1仍然有很好的优化(时间是-O0的十分之一),并且sum0和sum1性能上差别不大,说明编译器进化的非常快。

 1 ronghua.zhou@794bb5fbd58a:~/DCC888$ gcc pta5.2.c -O0
 2 ronghua.zhou@794bb5fbd58a:~/DCC888$ time ./a.out
 3 sum0
 4  
 5 real    0m5.772s
 6 user    0m5.767s
 7 sys     0m0.004s
 8 ronghua.zhou@794bb5fbd58a:~/DCC888$ time ./a.out a
 9 sum1
10  
11 real    0m4.766s
12 user    0m4.761s
13 sys     0m0.004s
14 ronghua.zhou@794bb5fbd58a:~/DCC888$ gcc pta5.2.c -O1
15 ronghua.zhou@794bb5fbd58a:~/DCC888$ time ./a.out
16 sum0
17  
18 real    0m0.542s
19 user    0m0.541s
20 sys     0m0.000s
21 ronghua.zhou@794bb5fbd58a:~/DCC888$ time ./a.out a
22 sum1
23  
24 real    0m0.473s
25 user    0m0.473s
26 sys     0m0.000s

由于sum0和sum1本身计算时间相差不大,所以外面主要对比一下sum0在-O0时的代码和-O1时的代码的差别。

不优化的结果:

 1 sum0:
 2 .LFB2:
 3     .cfi_startproc
 4     pushq   %rbp
 5     .cfi_def_cfa_offset 16
 6     .cfi_offset 6, -16
 7     movq    %rsp, %rbp
 8     .cfi_def_cfa_register 6
 9     movq    %rdi, -24(%rbp)
10     movq    %rsi, -32(%rbp)
11     movq    %rdx, -40(%rbp)
12     movl    %ecx, -44(%rbp)
13     movl    $0, -4(%rbp)
14     jmp .L2
15 .L4:
16     movl    -4(%rbp), %eax
17     cltq
18     leaq    0(,%rax,4), %rdx
19     movq    -40(%rbp), %rax
20     addq    %rax, %rdx
21     movl    -4(%rbp), %eax
22     cltq
23     leaq    0(,%rax,4), %rcx
24     movq    -24(%rbp), %rax
25     addq    %rcx, %rax
26     movl    (%rax), %eax
27     movl    %eax, (%rdx)
28     movl    -4(%rbp), %eax
29     cltq
30     leaq    0(,%rax,4), %rdx
31     movq    -32(%rbp), %rax
32     addq    %rdx, %rax
33     movl    (%rax), %eax
34     testl   %eax, %eax
35     jne .L3
36     movl    -4(%rbp), %eax
37     cltq
38     leaq    0(,%rax,4), %rdx
39     movq    -40(%rbp), %rax
40     addq    %rax, %rdx
41     movl    -4(%rbp), %eax
42     cltq
43     leaq    0(,%rax,4), %rcx
44     movq    -32(%rbp), %rax
45     addq    %rcx, %rax
46     movl    (%rax), %eax
47     movl    %eax, (%rdx)
48 .L3:
49     addl    $1, -4(%rbp)
50 .L2:
51     movl    -4(%rbp), %eax
52     cmpl    -44(%rbp), %eax
53     jl  .L4
54     nop
55     popq    %rbp
56     .cfi_def_cfa 7, 8
57     ret
58     .cfi_endproc
59 .LFE2:
60     .size   sum0, .-sum0
61     .globl  sum1
62     .type   sum1, @function

 

 

O1优化后的结果:

 1 sum0:
 2 .LFB38:
 3     .cfi_startproc
 4     testl   %ecx, %ecx
 5     jle .L1
 6     movl    $0, %eax
 7 .L4:
 8     movl    (%rdi,%rax,4), %r9d
 9     movl    %r9d, (%rdx,%rax,4)
10     movl    (%rsi,%rax,4), %r8d
11     testl   %r8d, %r8d
12     cmovne  %r9d, %r8d
13     movl    %r8d, (%rdx,%rax,4)
14     addq    $1, %rax
15     cmpl    %eax, %ecx
16     jg  .L4
17 .L1:
18     rep ret
19     .cfi_endproc
20 .LFE38:
21     .size   sum0, .-sum0
22     .globl  sum1
23     .type   sum1, @function

 

 

这个函数从O0到O1的优化过程中使用了很多优化方法,对于这里说的指针分析,由于指针的求地址和解引用非常耗时,O1使用cmovne将必要和拷贝优化成单个指令,起到了很好的效果。

在大多数情况下,sum0和sum1是等价的,但如果b和r这2个指针指向同一个地址的时候,2个算法就会有一些差别,所以编译器不能直接将sum0优化成sum1。

5.3 指针分析

指针分析的目标是找到每个指针指向的地址。

指针分析经常使用基于约束系统的分析方法来描述和解决。

性能最好的指针分析算法的复杂度是O(n3)。

为了提升效率和精准度,指针分析是编译器设计中仅次于寄存器分配方法的第二大课题。

5.4 尝试使用数据流分析方法解决指针分析

如下图所示,由于l2和l5会相互影响,但很难通过简单的语法分析就能找到他们之间的联系,所以基本的数据流分析对指针分析会失效。

 

 

5.5 ANDERSEN指针分析算法

常见的四种指针构造过程(控制流分析里面原来用⊆表达右边是左边的约束,但这个很容易和之前求指针分析时的约束弄混,因为约束是⊇,换算成控制流要转向成⊆,不知道别人会不会晕,反正我被弄晕了。所以最后我改成<-表示控制流图里面的边的方向,这样看着稍微好懂点):

指令
约束名
约束
控制流分析结果
a = &bbaseP(a)⊇ {b}lhs <- rhs
a = bsimpleP(a)⊇ P(b)lhs <- rhs
a = *bload∈ P(b)⇒ P(a)⊇ P(t){t} <- rhs'  lhs <- rhs
*a = bstore∈ P(a)⇒ P(t)⊇ P(b){t} <- rhs'  lhs <- rhs

Andersen指针分析法,又称为基于集合包含的的约束分析法。Anderson的指向图算法:

 1 let G = (V, E)
 2 W = V
 3 while W ≠ [] do
 4     n = hd(W)
 5     for each v ∈ P(n) do
 6         for each load "a = *n" do
 7             if (v, a) ∉ E then
 8                 E = E ∪ {(v, a)}
 9                 W = v::W
10         for each store "*n = b" do
11             if (b, v) ∉ E then
12                 E = E ∪ {(v, a)}
13                 W = b::W
14     for each (n, z) ∈ E do
15         P(z) = P(z) ∪ P(n)
16         if P(z) has changed then
17             W = z::W

 

 

上面的算法做一些解释:

W = v::W  的含义是将W这个数组的头部增加一个元素v。

n = hd(W) 表示从数组W中取出头结点,赋值给n。

例如,对下面的代码:

1 b = &a
2 a = &c
3 d = a
4 *d = b
5 a = *d

 

 

生成的指向图是这样的:

 

 

5.6 循环坍塌(COLLAPSING CYCLES)

找到图的传递闭包的算法复杂度达到O(n3),使得科学家们一直没停止过对它的优化。

循环坍塌是二十一世纪出发现的一种优化方法,循环坍塌的理论基础是强连通图的拓扑一致性,在指向分析图中,表示形成循环的所有节点,都有一致的指向分析集合。

算法能用和算法在实际中能用是两个概念。

5.6.1 循环识别

DFS可以发现循环,但发现的复杂度也不低。DFS的目标是遍历所有节点,但如果想要通过DFS发现环的话,就不但要记录节点,还要记录节点的所有边,这样才能区别一个节点的子结点已经遍历过的情况下判断出只是菱形依赖,还是环。

常见的循环识别方法有波传递算法(Wave propagation),深度传递算法(Deep propagation)和惰性循环检测方法(Lazy cycle detection)。

5.6.2 惰性循环检测(Lazy Cycle Detection)

参见The ant and the grasshopper: fast and accurate pointer analysis for millions of lines of code, 2007。这篇文章实际提出了两种循环检测方法,一种是惰性循环检测,一种是混合循环检测。

增加惰性循环检测之后的算法相对于没有循环检测的方法,主要增加了第2行和第16~18行。其中第2行是增加了一个集合初始化(用来避免重复进行循环检测)。16~18行主要是发现某条边的2个节点的指向集合相等的情况下触发循环检测,检测成功就直接触发循环坍塌。不论是否检测到循环,都会将疑似循环的边加入到已检测的集合中。

 1 let G = (V, E)
 2 R = {}
 3 W = V
 4 while W ≠ [] do
 5     n = hd(W)
 6     for each v ∈ P(n) do
 7         for each load "a = *n" do
 8             if (v, a) ∉ E then
 9                 E = E ∪ {(v, a)}
10                 W = v::W
11         for each store "*n = b" do
12             if (b, v) ∉ E then
13                 E = E ∪ {(v, a)}
14                 W = b::W
15     for each (n, z) ∈ E do
16         if P(z) = P(n) and (n, z) ∉ R then
17             DETECTANDCOLLAPSECYCLES(z)
18             R = R∪ {(n, z)}
19         P(z) = P(z) ∪ P(n)
20         if P(z) has changed then
21             W = z::W

优点:仅在非常大可能性能找到环的情况下才触发环形检测;概念简单,容易实现。

缺点:触发检测前环已经存在一段时间,会降低部分性能;即使概率很大的时候,环形检测还是有可能失败(当前还没有失败的证据)。

对下面的伪代码:

1 c = &d
2 e = &a
3 a = b
4 b = c
5 c = *e

 

 

生成的指向图如下(其中a/b/c触发了循环坍塌):

 

 

 

 

5.6.3 波传递算法(Wave Propagation)

波传递算法的伪代码如下:

 1 repeat
 2     changed = false
 3     collapse Strongly Connected Components
 4     WAVEPROPAGATION
 5     ADDNEWEDGES
 6     if a new edge has been added to G then
 7         changed = true
 8 until changed = false
 9  
10  
11 WAVEPROPAGATION(G, P, T)
12     while T ≠ []
13     v = hd(T)
14     Pdif = Pcur(v) – Pold(v)
15     Pold(v) = Pcur(v)
16     if Pdif ≠ {}
17         for each w such that (v, w) ∈ E do
18             Pcur(w) = Pcur(w) ∪ Pdif
19  
20  
21 ADDNEWEDGES(G = (E, V), C)
22     for each operation c such as l = *r ∈ C do
23         Pnew = Pcur(r) – Pcache(c)
24         Pcache(c) = Pcache(c) ∪ Pnew
25         for each v ∈ Pnew do
26             if (v, l) ∉ E then
27                 E = E ∪ {(v, l)}
28                 Pcur(l) = Pcur(l) ∪ Pold(v)
29     for each operation c such as *l = r do
30         Pnew = Pcur(l) – Pcache(c)
31         Pcache(c) = Pcache(c) ∪ Pnew
32         for each v ∈ Pnew do
33             if (r, v) ∉ E then
34                 E = E ∪ {(r, v)}
35                 Pcur(v) = Pcur(v) ∪ Pold(r)

上述算法中的参数的含义如下:

  • G:指向图
  • P:指向集合
  • T:G中所有节点的拓扑顺序
  • Pcache:上一次计算出来的指向集合,初始化为{}

对下面的伪代码:

 1 h = &c
 2 e = &g
 3 b = c
 4 h = &g
 5 h = a
 6 c = b
 7 a = &e
 8 f = d
 9 b = a
10 d = *h
11 *e = f
12 f = &a

 

 

生成的指向图如下(其中b/c和d/f/g触发了循环坍塌):

 

 

对应的堆内存拓扑图如下:

 

 

5.7 STEENSGAARD指针分析算法

如果把Anderson指针分析算法中的集合包含换成等号(将包含符号左右两侧的集合先求并集,然后赋值给原来的两个集合),就形成了Steensgaard指针分析算法,也称为基于集合并集的指针分析算法。

对下面的伪代码:

1 x = &a;
2 y = &b;
3 p = &x;
4 p = &y;

 

 

生成的指向图如下:

 

 

5.7.1 Union-Find

基于链式并集计算的复杂度可以达到α(n),其中α是Ackermann function的简称,该算法实现也称为Union-Find。算法的具体描述参见An Improved Equivalence Algorithms (1964)

5.7.2 Steensgaard指针分析算法没有Anderson指针分析算法精准

例如上面例子生成的两个堆的拓扑图,按Steensgaard的分析结论,x可能指向b,y可能指向a。但Anderson的分析结论,x不可能指向b,y不可能指向a,显然Anderson的分析结论更接近事实。

 

 

5.8 总结

5.8.1 一种通用模式(A Common Pattern)

迄今为止,所有分析算法都遵循一种模式:迭代,直到找到一个不动点(也就是说,如果某次迭代后,所有变量都不变,后面再触发迭代,也不会再改变)。

这个通用模式适用于数据流分析、控制流分析和指向分析。

5.8.2 流相关性(Flow Sensitiveness)

尽管Anderson分析算法比Steensgaard算法精确,但由于它是流无关算法,所以仍然存在一些结论是实际运行中不可能出现,或者不可能同时出现的,这就是流无关分析算法(Flow Insensitive)的局限性。

但是如果按照流相关分析算法(Flow Sensitive)进行分析,每个程序点都需要保留一份独立的分析结论,这对大规模程序的分析是非常昂贵的(常常会带来OOM:))。

5.8.3 指针分析简史

    • Andersen, L. "Program Analysis and Specialization for the C Programming Language", PhD Thesis, University of Copenhagen, (1994)
    • Hardekopf, B. and Lin, C. "The Ant and the Grasshopper: fast and accurate pointer analysis for millions of lines of code", PLDI, pp 290-299 (2007)
    • Pereira, F. and Berlin, D. "Wave Propagation and Deep Propagation for Pointer Analysis", CGO, pp 126-135 (2009)
    • Steensgaard, B., "Points-to Analysis in Almost Linear Time", POPL, pp 32-41 (1995)

 

作者:|周荣华|,原文链接: https://www.cnblogs.com/zhouronghua/p/16323320.html

文章推荐

一个恢复CSI挂载信息的解决方法

聊聊C#中的Mixin

Change Buffer 只适用于非唯一索引页?错

C# 蓄水池抽样

什么是请求参数、表单参数、url参数、header参数、Cookie参...

MyBatis 结果映射总结

使用 oh-my-posh 美化 windows terminal,让其接近oh-my-zsh

『忘了再学』Shell基础 — 15、环境变量(三)

逆向进阶,利用 AST 技术还原 JavaScript 混淆代码

python多线程同步售票系统解决思路

手把手带你自定义 Gradle 插件 —— Gradle 系列(2)

数据分析:线性回归