关于即时编译器的其他一些优化手段

hresh 335 0

关于即时编译器的其他一些优化手段

在前面两篇文章讲述了即时编译器的两种特殊优化技术:方法内联逃逸分析,其中基于逃逸分析结果又有三种优化方式:同步消除、栈上分配以及标量替换。

除此之外,即时编译器还有很多优化手段,其中有不少经典编译器的优化手段,也有许多针对 Java 语言,或者说针对运行在 Java 虚拟机上的所有语言进行的优化。相较于方法内联,其他优化手段理解起来并不困难。一开始没打算整理这块内容,但是看了一下,觉得和之前的《如何提升代码质量》一文息息相关,除了要熟悉重构的手段,了解更深层次的原理非常有意义。即时编译器可以帮助我们优化代码,这是有代价的,虽然我们平时不怎么接触,但并不代表不存在,开发人员如果能够注意这些细节,无疑可以提高自己的代码质量,代码性能也会有所提升。

所以本文的核心主旨是:学习即时编译器的优化手段,未来自己写代码时,在保证可读性的前提下,尽量减少编译器的工作量。

接下来我们就学习一下编译器的优化手段,不会介绍全部,仅仅介绍一些日常写代码遇得见的情况,文章将伴随大量代码案例,旨在提升代码水平。

说点题外话,在学习优化手段时,突然想到这些是即时编译器的优化措施,那如果没有触发即时编译,那不就没意义了吗?而且在讲述方法内联和逃逸分析时,一直都是用大循环来触发即时编译,如果只是单次代码调用,那不就没戏了吗?查了一下资料,最终还是想通了,实际应用中,我们写的代码不像文章中的测试代码,那么简单,实际代码是属于系统中的一部分,而系统开发出来就是要运行的,只要系统运行时间够长,程序中绝大部份方法都会触发即时编译,被编译成本地代码。所以还是好好学习一下文章中介绍的优化手段吧。

字段读取优化

首先我们需要了解 JMM(Java内存模型),关于这些知识推荐阅读本文,我们这里引入以下几个概念:

  • 线程之间的共享变量存储在主内存(Main Memory)中;

  • 每个线程都有一个私有的本地内存(Local Memory),本地内存是JMM的一个抽象概念,并不真实存在,它涵盖了缓存、写缓冲区、寄存器以及其他的硬件和编译器优化。本地内存中存储了该线程以读/写共享变量的拷贝副本。

如下图所示:

关于即时编译器的其他一些优化手段

对象的实例字段和静态字段存在堆中,属于线程共享的数据。

即时编译器会优化实例字段以及静态字段访问,以减少总的内存访问数目。具体来说,它将沿着控制流,缓存各个字段存储节点将要存储的值,或者字段读取节点所得到的值。

当即时编译器遇到对同一字段的读取节点时,如果缓存值还没有失效,那么它会将读取节点替换为该缓存值。这里说明一下缓存值为何会失效,比如说多个线程操作同一个字段,进行读写操作,如果该字段被 volatile 修饰,那么线程独自拥有的工作内存中数据会被清除掉,需要从主内存重新加载。更多细节推荐阅读我之前的文章《深入了解volatile关键字》。

下面我们来看一下缓存字段读取节点的情况。

static int bar(Foo o, int x) {
  int y = o.a + x;
  return o.a + y;
}

在上面这段代码中,实例字段 Foo.a 将被读取两次。即时编译器会将第一次读取的值缓存起来,并且替换第二次字段读取操作,以节省一次内存访问。这让我联想到日常开发中对于 getter 方法的使用,如果大于两次通过 getter 方法访问同一个字段,则最好定义一个变量。

static int bar(Foo o, int x) {
  int t = o.a;
  int y = t + x;
  return t + y;
}

如果字段读取节点被替换成一个常量,那么它将进一步触发更多优化。

static int bar(Foo o, int x) {
  o.a = 1;
  if (o.a >= 0)
    return x;
  else
    return -x;
}

上述代码很简单,bar 方法经过编译器优化后,可以直接替换为具体结果 true。所以开发人员完全可以避免让编译器费事,写代码的时候检查一下代码逻辑。

小结一下:

被 volatile 修饰的字段,编译器会在字段访问前后插入内存屏障节点,保证了不同线程对这个变量进行操作时的可见性。同样这也意味着该操作会组织编译器的字段读取优化。同理,加锁、解锁操作也会阻止此种优化手段。

字段存储优化

除了字段读取优化之外,即时编译器还将消除冗余的存储节点。如果一个字段先后被存储了两次,而且这两次存储之间没有对第一次存储内容的读取,那么即时编译器可以将第一个字段存储给消除掉。

class Foo {
  int a = 0;
  void bar() {
    a = 1;
    a = 2;
  }
}

不会有人这样写代码吧,上述代码比较简单,编译器会进行冗余存储消除优化。

class Foo {
  int a = 0;
  void bar() {
    a = 1;
    int t = a;
    a = t + 2;
  }
}
// 进行复写传播优化为
class Foo {
  int a = 0;
  void bar() {
    a = 1;
    int a = a;
    a = a + 2;
  }
}
// 进一步优化为
class Foo {
  int a = 0;
  void bar() {
    a = 3;
  }
}

上述代码除了用到冗余存储消除,还有复写传播,没有必要使用一个额外的变量 t,它与变量 a是完全相等的。

因为 volatile 除了保证了变量的可见性,还禁止指令重排序,那么即时编译器也不能将冗余的存储操作消除掉。

虽然重复给同一个变量赋值多次看起来很蠢,但实际上并不少见,比如说两个存储之间隔着许多其他代码,或者因为方法内联的缘故,将两个存储操作(如构造器中字段的初始化以及随后的更新)纳入同一个编译单元里。

死代码消除

除了字段存储优化之外,局部变量的死存储(dead store)同样也涉及了冗余存储。这是死代码消除(dead code eliminiation)的一种。不过,由于 Sea-of-Nodes IR 的特性,死存储的优化无须额外代价。

int bar(int x, int y) {
  int t = x*y;
  t = x+y;
  return t;
}

除了消除冗余存储,甚至变量 t 也没必要声明,所以优化为:

int bar(int x, int y) {
  return x+y;
}

死存储还有一种变体,即在部分程序路径上有冗余存储。

int bar(boolean f, int x, int y) {
  int t = x*y;
  if (f)
    t = x+y;
  return t;
}

上述代码中,如果布尔型变量为 true,那么变量 t会被赋值两次。如果优化之后,代码可以改为:

int bar(boolean f, int x, int y) {
  if (f)
    return x+y;
  return x*y;
}

另一种死代码消除则是不可达分支消除。不可达分支就是任何程序路径都不可到达的分支。在即时编译过程中,我们经常因为方法内联、常量传播以及基于 profile 的优化等,生成许多不可达分支。

int bar(int x) {
  if (getFlag())
    return x;
  else
    return -x;
}

比如上述代码,如果 getFlag 方法一直返回 false,那么就会一直走 else 分支,那么就会被优化为:

int bar(int x) {
  return -x;
}

我们来看一种特殊情况,编译器无法进行优化。

int bar(int x, int y) {
  int t = x/y;
  t = x+y;
  return t;
}

上述代码无法优化为直接返回 x+y,因为 x/y 有除0异常,所以编译器没法优化掉这个除法。

公共子表达式消除

公共子表达式消除是一项非常经典的、普遍应用于各种编译器的优化技术,该项技术比较简单。如果一个表达式重复出现多次,且表达式中的变量值都没有发生改变,那么该表达式可称为公共子表达式。

  public static void main(String[] args) {
    int a = 2, b = 3, c = 4;
    int d = (c * b) * 12 + a + (a + b * c);
  }

javac 编译器并不会对上述代码做任何优化,我们查看字节码文件内容如下:

stack=4, locals=5, args_size=1
0: iconst_2
1: istore_1
2: iconst_3
3: istore_2
4: iconst_4
5: istore_3
6: iload_3
7: iload_2
8: imul //c*b
9: bipush        12 //将常量12推送至栈顶
11: imul    //(c * b) * 12
12: iload_1
13: iadd    //(c * b) * 12 + a
14: iload_1
15: iload_2
16: iload_3
17: imul    //b*c
18: iadd    //a+b*c
19: iadd    //(c * b) * 12 + a + (a + b * c)
20: istore        4
22: return

这些指令都比较简单,不懂的指令可以参考本文

编译器检测到代码中 c*bb*c 是一样的表达式,而且在计算期间 b 与 c 未发生改变。因此上述代码变为:

int temp = b * c;
int d = temp * 12 + a + (a + temp);

这时候,即时编译器还会进行另一种优化——代数化简(数学中对代数方程进行简化),继续优化为:

int temp = b * c;
int d = temp * 13 + 2 * a;

不过话说回来,平时写代码时应该不会这样写,也就不必让编译器优化了。

在代码中,循环都扮演着非常重要的角色。为了提升循环的运行效率,即时编译器也提供了不少面向循环的编译优化方式,如循环无关代码外提,循环展开等。

循环无关代码外提

所谓的循环无关代码(Loop-invariant Code),指的是循环中值不变的表达式。如果能够在不改变程序语义的情况下,将这些循环无关代码提出循环之外,那么程序便可以避免重复执行这些表达式,从而达到性能提升的效果。

  public static int foo(int x, int y, int[] a) {
    int sum = 0;
    for (int i = 0; i < a.length; i++) {
      sum += x * y + a[i];
    }
    return sum;
  }

对应字节码为:

public static int foo(int, int, int[]);
    descriptor: (II[I)I
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=4, locals=5, args_size=3
         0: iconst_0
         1: istore_3
         2: iconst_0
         3: istore        4
         //循环开始
         5: iload         4
         7: aload_2
         8: arraylength //获取数组长度,压入栈顶
         9: if_icmpge     29
        12: iload_3
        13: iload_0
        14: iload_1
        15: imul
        16: aload_2
        17: iload         4
        19: iaload
        20: iadd
        21: iadd
        22: istore_3
        23: iinc          4, 1
        26: goto          5
        //循环结束
        29: iload_3
        30: ireturn

上述代码中,循环体中的表达式 x*y,以及循环判断条件中的 a.length 均属于循环不变代码。前者是一个整数乘法运算,而后者则是内存访问操作,读取数组对象a的长度。(数组的长度存放于数组对象的对象头中,可通过 arraylength 指令来访问。)

首先表达式 x*y 又属于公共子表达式,按理来说应该声明一个变量来消除它,为了减少计算量,把变量放在循环外声明。

然后来处理循环条件中的 a.length,每次循环时会去访问一下内存,按理说将其单独定义为一个变量更好,但是我们在写循环代码时早已习惯这种方式,所以我个人认为不必强制要求代码中声明变量来存储 a.length,可读性更高一些。

综上,我们得到如下代码:

  public static int foo(int x, int y, int[] a) {
    int sum = 0;
    int temp = x*y;
    for (int i = 0; i < a.length; i++) {
      sum += temp + a[i];
    }
    return sum;
  }

我们看一下下面这段代码,思考一下 Object 对象声明的位置应该在哪呢?是在循环体内,还是循环体外。

Object o;
for (int i = 0; i < 2000; i++) {
  o = new Object();
  o.hashCode();
}

上述格式是我常写的格式,把变量放在循环外声明,自以为循环外申明变量内存占用会小一些。

但关于变量声明在循环体内还是循环体外一直存在争论,后来学习了字节码后,再结合网友们的讨论,得出如下结论:变量声明优先考虑在循环体内定义。

循环展开

编译器还有一项非常重要的循环优化是循环展开(Loop Unrolling)。它指的是在循环体中重复多次循环迭代,并减少循环次数的编译优化。

int foo(int[] a) {
  int sum = 0;
  for (int i = 0; i < 64; i++) {
    sum += (i % 2 == 0) ? a[i] : -a[i];
  }
  return sum;
}

上面的代码经过循环展开之后将形成下面的代码:

int foo(int[] a) {
  int sum = 0;
  for (int i = 0; i < 64; i += 2) {
    sum += a[i];
    sum += -a[i + 1];
  }
  return sum;
}

在 C2 中,只有计数循环(Counted Loop)才能被展开。所谓的计数循环需要满足如下四个条件:

  • 维护一个循环计数器,并且基于计数器的循环出口只有一个(但可以有基于其他判断条件的出口,比如说循环体内的if-break语句)。
  • 循环计数器的类型为 int、short 或者 char(既不能是 byte、long,更不能是 float 或者 double)。
  • 每个迭代循环计数器的增量为常数。
  • 循环计数器的上限(增量为正数)或下限(增量为负数)是循环无关的数值。

循环展开有一种特殊情况,那便是完全展开(Full Unroll)。当循环的次数是固定值而且非常小时,循环语句会被替换为普通的赋值语句。

int foo(int[] a) {
  int sum = 0;
  for (int i = 0; i < 4; i++) {
    sum += a[i];
  }
  return sum;
}
//替换为
int foo(int[] a) {
  int sum = 0;
  sum += a[0];
  sum += a[1];
  sum += a[2];
  sum += a[3];
  return sum;
}

关于这种优化手段,个人觉得仅做了解即可,日常开发没必要在乎这些,代码可读性不怎么高。

循环判断外提

循环判断外提指的是将循环中的 if 语句外提至循环之前,并且在该 if 语句的两个分支中分别放置一份循环代码。

int foo(int[] a) {
  int sum = 0;
  for (int i = 0; i < a.length; i++) {
    if (a.length > 4) {
      sum += a[i];
    }else {
      sum += 2* a[i] - 1;
    }
  }
  return sum;
}

优化后变为:

int foo(int[] a) {
  int sum = 0;
  if (a.length > 4) {
    for (int i = 0; i < a.length; i++) {
      sum += a[i];
    }
  } else {
    for (int i = 0; i < a.length; i++) {
      sum += 2* a[i] -1;
    }
  }
  return sum;
}

关于这种优化,个人感觉意义不大,日常开发还是从可读性的角度出发吧。

总结

以上介绍的七种优化手段,有时候会嵌套使用,比如说字段存储优化过程中还会使用到复写传播的手段,当然也有某些优化比较复杂,可读性不高,比如说循环展开和循环判断外提。综上,我们需要学习的优化手段最好先保证良好的可读性,在此基础上省略即时编译器的工作。

上文介绍的只是即时编译器的某些优化措施,关于提高用户代码质量,在如何提升代码质量一文提到了不少书籍和代码库,后续有时间阅读,会做整理介绍的。

参考文献

《深入理解Java虚拟机》

发表评论 取消回复
表情 图片 链接 代码

分享