C【金沙官网线上】#编译器优化那点事

使用C#编写程序,给最终用户的程序,是需要使用release配置的,而release配置和debug配置,有一个关键区别,就是release的编译器优化默认是启用的。
优化代码开关即optimize开关,和debug开关一起,有以下几种组合。
金沙官网线上 1

1.4 Executing Your Assembly’s Code 执行程序集代码

在Visual Sutdio中新建一个C#项目时,
项目的“调试”(Debug)配置的是/optimize-和/debug:full开关,
而“发布”(Release)配置指定的是/optimize+和/debug:pdbonly开关

 

optimize-/+决定了编译器是否优化代码,optimize-就是不优化了,但是通常,有一些基本的“优化”工作,无论是否指定optimize+,都会执行。

如前所述,托管程序集同时包含元数据和IL。 IL是由Microsoft在咨询了一些商业和学术上的语言编译器作者后创建的一种独立于CPU的机器语言。 IL是一种比大多数CPU机器语言更高层次的语言。IL可以访问和操纵的对象类型,创建和初始化对象,调用对象的虚方法,操作数组元素。它甚至能抛出和捕获异常的错误处理。你可以认为IL是一种面向对象的机器语言。 

optimize- and optimize+

该项功能主要用于动态语义分析,帮助我们更好地编写代码。

 

- 常量计算

在写程序的时候,有时能看见代码下面划了一道红波浪线,那就是编译器动态检查。常量计算,就是这样,编译器会计算常量,帮助判断其他错误。  
![](https://images2018.cnblogs.com/blog/616093/201805/616093-20180501011736735-1016278688.png)

通常,开发人员会使用一门高级语言编程,如C#和C++/ CLI中,或Visual Basic。这些高级语言的编译器产生IL。然而,正如任何其他机器语言,IL可以用汇编语言编写,微软也确实提供了IL汇编器,ILAsm.exe。微软还提供了IL反汇编,ILDasm.exe。 

- 简单分支检查

如果swtich写了两个以上的相同条件,或者分支明显无法访问到,都会弹出提示。  
![](https://images2018.cnblogs.com/blog/616093/201805/616093-20180501011749912-993405991.png)

 

- 未使用变量

不多说明,直接看图。  
![](https://images2018.cnblogs.com/blog/616093/201805/616093-20180501012150677-566406144.png)

请记住,任何高级的语言最多只能使用CLR全部特性一个子集。而IL汇编语言允许开发人员获取CLR的所有特性。因此,如果你真的想使用被你的编程语言隐藏掉的CLR特性,你可以在IL汇编器中编写或者使用另一种编程语言来完成你需要的CLR功能。 

- 使用未赋值变量

不多说,看图。  
![](https://images2018.cnblogs.com/blog/616093/201805/616093-20180501011804349-1464238631.png)

 

局限

使用变量参与计算,随便写一个算式,就可以绕过一些检查,虽然我们看来是明显有问题的。
金沙官网线上 2

了解CLR提供了哪些功能的唯一途径就是阅读有关CLR的文档。本书重点讲述CLR的一些特性,以及它们在C#语言中哪些是提供的,哪些是没有提供的。我想很多其他的书籍和文章都会从一门语言的角度去探讨CLR,并且大多数开发人员也倾向于相信CLR仅提供了他选所选择的语言所展现的功能。如果大家选额的语言能够实现想做的事情,那么这种理解也并非坏事,虽然有些混乱。

optimize+ only

首先需要了解c#代码编译的过程,如下图:
金沙官网线上 3
图片来自http://www.cnblogs.com/rush/p/3155665.html

C# compiler将C#代码生成IL代码的就是所谓的编译器优化。先说重点。
.NET的JIT机制,主要优化在JIT中完成,编译器optimize只做一点简单的工作。(划重点)

探究一下到底干了点啥吧,以下是使用到的工具。

Tools:
Visual studio 2017 community targeting .net core 2.0
IL DASM(vs自带)

 

使用IL DASM可以查看编译器生成的IL代码,这样就能看到优化的作用了。IL代码的用途与机制不是本文的重点,不明白的同学可以先去看看《C# via CLR》(好书推荐)。

按照优化的类型进行了简单的分类。

重点:我觉得这种语序在编程语言间方便切换和高度集成的能力是CLR一个非常厉害的功能(an awesome feature of the CLR)。不行的是,许多开发人员经常会护士这个特性。我们知道,C#和Visual Basic善于进行I/O操作,而APL在高级工程和金融计算时则非常突出。通过CLR,我们可以用C#来编写应用程序的I/O部分,然后再用APL来编写应用程序的工程计算部分,CLR提供的语言之间的继承能力是前所未有的,这也是的混合编程值得很多开发项目考虑。

- 从未使用变量

代码如下:
using System;
using System.Threading.Tasks;

namespace CompileOpt
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 3;
            Console.WriteLine("sg");
        }
    }
}

未优化的时候

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // 代码大小       15 (0xf)
  .maxstack  1
  .locals init (int32 V_0)
  IL_0000:  nop
  IL_0001:  ldc.i4.3
  IL_0002:  stloc.0
  IL_0003:  ldstr      "sg"
  IL_0008:  call       void [System.Console]System.Console::WriteLine(string)
  IL_000d:  nop
  IL_000e:  ret
} // end of method Program::Main

使用优化开关优化之后:

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // 代码大小       11 (0xb)
  .maxstack  8
  IL_0000:  ldstr      "sg"
  IL_0005:  call       void [System.Console]System.Console::WriteLine(string)
  IL_000a:  ret
} // end of method Program::Main

.locals init (int32 V_0)消失了(局部变量,类型为int32)
ldc.i4.3(将3推送到堆栈上)和stloc.0(将值从堆栈弹出到局部变量 0)也消失了。
所以,整个没有使用的变量,在设置为优化的时候,就直接消失了,就像从来没有写过一样。

 

- 空try catch语句

代码如下:
using System;
using System.Threading.Tasks;

namespace CompileOpt
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {

            }
            catch (Exception)
            {
                Console.WriteLine(DateTime.Now);
            }

            try
            {

            }
            catch (Exception)
            {
                Console.WriteLine(DateTime.Now);

            }
            finally
            {
                Console.WriteLine(DateTime.Now);

            }
        }
    }
}

未优化

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // 代码大小       74 (0x4a)
  .maxstack  1
  IL_0000:  nop
  .try
  {
    IL_0001:  nop
    IL_0002:  nop
    IL_0003:  leave.s    IL_001a
  }  // end .try
  catch [System.Runtime]System.Exception 
  {
    IL_0005:  pop
    IL_0006:  nop
    IL_0007:  call       valuetype [System.Runtime]System.DateTime [System.Runtime]System.DateTime::get_Now()
    IL_000c:  box        [System.Runtime]System.DateTime
    IL_0011:  call       void [System.Console]System.Console::WriteLine(object)
    IL_0016:  nop
    IL_0017:  nop
    IL_0018:  leave.s    IL_001a
  }  // end handler
  IL_001a:  nop
  .try
  {
    .try
    {
      IL_001b:  nop
      IL_001c:  nop
      IL_001d:  leave.s    IL_0034
    }  // end .try
    catch [System.Runtime]System.Exception 
    {
      IL_001f:  pop
      IL_0020:  nop
      IL_0021:  call       valuetype [System.Runtime]System.DateTime [System.Runtime]System.DateTime::get_Now()
      IL_0026:  box        [System.Runtime]System.DateTime
      IL_002b:  call       void [System.Console]System.Console::WriteLine(object)
      IL_0030:  nop
      IL_0031:  nop
      IL_0032:  leave.s    IL_0034
    }  // end handler
    IL_0034:  leave.s    IL_0049
  }  // end .try
  finally
  {
    IL_0036:  nop
    IL_0037:  call       valuetype [System.Runtime]System.DateTime [System.Runtime]System.DateTime::get_Now()
    IL_003c:  box        [System.Runtime]System.DateTime
    IL_0041:  call       void [System.Console]System.Console::WriteLine(object)
    IL_0046:  nop
    IL_0047:  nop
    IL_0048:  endfinally
  }  // end handler
  IL_0049:  ret
} // end of method Program::Main

优化开关开启:

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // 代码大小       19 (0x13)
  .maxstack  1
  .try
  {
    IL_0000:  leave.s    IL_0012
  }  // end .try
  finally
  {
    IL_0002:  call       valuetype [System.Runtime]System.DateTime [System.Runtime]System.DateTime::get_Now()
    IL_0007:  box        [System.Runtime]System.DateTime
    IL_000c:  call       void [System.Console]System.Console::WriteLine(object)
    IL_0011:  endfinally
  }  // end handler
  IL_0012:  ret
} // end of method Program::Main

很明显可以看到,空的try catch直接消失了,但是空的try catch finally代码是不会消失的,但是也不会直接调用finally内的代码(即还是会生成try代码段)。

在执行一个方法的时候,它的IL首先要转化成当地的CPU指令。这是CLR中(JIT--just-in-time)编译器的工作。

- 分支简化

代码如下:
using System;
using System.Threading.Tasks;

namespace CompileOpt
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 3;
            if (x == 3)
                goto LABEL1;
            else
                goto LABEL2;
            LABEL2: return;
            LABEL1: return;
        }
    }
}

未优化的情况下:

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // 代码大小       22 (0x16)
  .maxstack  2
  .locals init (int32 V_0,
           bool V_1)
  IL_0000:  nop
  IL_0001:  ldc.i4.3
  IL_0002:  stloc.0
  IL_0003:  ldloc.0
  IL_0004:  ldc.i4.3
  IL_0005:  ceq
  IL_0007:  stloc.1
  IL_0008:  ldloc.1
  IL_0009:  brfalse.s  IL_000d
  IL_000b:  br.s       IL_0012
  IL_000d:  br.s       IL_000f
  IL_000f:  nop
  IL_0010:  br.s       IL_0015
  IL_0012:  nop
  IL_0013:  br.s       IL_0015
  IL_0015:  ret
} // end of method Program::Main

优化:

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // 代码大小       5 (0x5)
  .maxstack  8
  IL_0000:  ldc.i4.3
  IL_0001:  ldc.i4.3
  IL_0002:  pop
  IL_0003:  pop
  IL_0004:  ret
} // end of method Program::Main

优化的情况下,一些分支会被简化,使得调用更加简洁。

图1-4展示了一个方法第一次被调用时的情况

- 跳转简化

代码如下:
using System;
using System.Threading.Tasks;

namespace CompileOpt
{
    class Program
    {
        static void Main(string[] args)
        {
            goto LABEL1;
            LABEL2: Console.WriteLine("234");
            Console.WriteLine("123");
            return;
            LABEL1: goto LABEL2;
        }     
    }
}

未优化:

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // 代码大小       32 (0x20)
  .maxstack  8
  IL_0000:  nop
  IL_0001:  br.s       IL_001c
  IL_0003:  nop
  IL_0004:  ldstr      "234"
  IL_0009:  call       void [System.Console]System.Console::WriteLine(string)
  IL_000e:  nop
  IL_000f:  ldstr      "123"
  IL_0014:  call       void [System.Console]System.Console::WriteLine(string)
  IL_0019:  nop
  IL_001a:  br.s       IL_001f
  IL_001c:  nop
  IL_001d:  br.s       IL_0003
  IL_001f:  ret
} // end of method Program::Main

优化后:

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // 代码大小       21 (0x15)
  .maxstack  8
  IL_0000:  ldstr      "234"
  IL_0005:  call       void [System.Console]System.Console::WriteLine(string)
  IL_000a:  ldstr      "123"
  IL_000f:  call       void [System.Console]System.Console::WriteLine(string)
  IL_0014:  ret
} // end of method Program::Main

一些多层的标签跳转会得到简化,优化器就是人狠话不多。

 

- 临时变量消除

一些临时变量(中间变量)会被简化消除。代码如下:
using System;
using System.Threading.Tasks;

namespace CompileOpt
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int i = 0; i < 3; i++)
            {
                Console.WriteLine(i);
            }
            for (int i = 0; i < 3; i++)
            {
                Console.WriteLine(i + 1);
            }
        }
    }
}

只显示最关键的变量声明部分,未优化的代码如下:

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // 代码大小       54 (0x36)
  .maxstack  2
  .locals init (int32 V_0,
           bool V_1,
           int32 V_2,
           bool V_3)
  IL_0000:  nop

优化后:

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // 代码大小       39 (0x27)
  .maxstack  2
  .locals init (int32 V_0,
           int32 V_1)
  IL_0000:  ldc.i4.0

很显然,中间的bool型比较变量消失了。

金沙官网线上 4

- 空指令删除

看第一个例子,很明显,代码中没有了nop字段,程序更加紧凑了。

编译器版本不同,对应的优化手段也不尽相同,以上只列出了一些,应该还有一些没有讲到的,欢迎补充。

 

延伸阅读:.NET中的优化(转载自http://blog.jobbole.com/84712/

在.NET的编译模型中没有链接器。但是有一个源代码编译器(C# compiler)和即时编译器(JIT compiler),源代码编译器只进行很小的一部分优化。比如它不会执行函数内联和循环优化。

从优化能力上来讲RyuJIT和Visual C++有什么不同呢?因为RyuJIT是在运行时完成其工作的,所以它可以完成一些Visual C++不能完成的工作。比如在运行时,RyuJIT可能会判定,在这次程序的运行中一个if语句的条件永远不会为true,所以就可以将它移除。RyuJIT也可以利用他所运行的处理器的能力。比如如果处理器支持SSE4.1,即时编译器就会只写出sumOfCubes函数的SSE4.1指令,让生成打的代码更加紧凑。但是它不能花更多的时间来优化代码,因为即时编译所花的时间会影响到程序的性能。

在当前控制托管代码的能力是很有限的。C#和VB编译器只允许使用/optimize编译器开关打开或者关闭优化功能。为了控制即时编译优化,你可以在方法上使用System.Runtime.Compiler­Services.MethodImpl属性和MethodImplOptions中指定的选项。NoOptimization选项可以关闭优化,NoInlining阻止方法被内联,AggressiveInlining (.NET 4.5)选项推荐(不仅仅是提示)即时编译器将一个方法内联。

在Main方法执行之前,CLR会检查Main中代码引用到的所有类型。这会导致CLR分配一个内部的数据结构,该数据结构用于管理对所引用到的类型的访问。在图1-4中,Main方法只引用了一个Console类型,CLR将会为此分配一个单独的内部结构。在这个内部数据结构中,Console类型中的每个方法都有一个条目(entry),每个条目中将保存有一个方法实现代码的地址。当初始化这个结构时,CLR将把每一个条目设置为CLR内部的一个没有正式记录的函数,我们暂且成该阐述为JITCompiler。

结语

话说整点这个东西有点什么用呢?
要说是有助于更好理解.NET的运行机制会不会有人打我...
说点实际的,有的童鞋在写延时程序时,timer.Interval = 10 * 60 * 1000,作为强迫症患者,生怕这么写不好,影响程序执行。但是,这种写法完全不会对程序的执行有任何影响,我认为还应该推荐,因为增加了程序的可读性,上面的代码段就是简单的10分钟,一看就明白,要是算出来反而可读性差。另外,分支简化也有助于我们专心依照业务逻辑去编写代码,而不需要过多考虑代码的分支问题。其他的用途各位看官自行发挥啦。

 

当Main方法第一次调用writeline,JITCompiler函数将被调用,该函数负责将一个方法的IL代码编译成本地CPU指令。因为IL代码是被“即时(just-in-time)”编译的,所以CLR的这一部分通常被称作JITter或者JIT编译器。

 

Note:如果应用程序是在x86版本的windows上或者是WoW64上跑的,JIT编译器会产生x86指令。如果应用程序是在x64版本的windows或者Itanlum版本的windows上跑,JIT编译器会分别产生x64或者IA64指定。

 

当JIT编译器(JITCompiler)函数被调用时,它会知道正在调用的是那个方法,以及该方法是由那个类型定义的。JIT编译器函数随后会在被调用方法所定义的程序集中的元函数内搜索其IL代码的位置。JIT编译器接着验证这些IL代码并将编译成本地CPU指令。本地CPU指令会被保存在动态分配的内存快中。然后JIT编译器将前面内部数据结构中被调用方法的地址替换成包含本地CPU指令的内存块地址。最后,JIT编译器会跳转到该内存块中的代码上。这里的代码就是Writeline方法(含有一个String类型参数的版本)当这些代码执行完,它将返回到Main函数中,Main函数会接着继续执行下面的代码。

 

现在,Main第二次调用WriteLine。由于writeLine已经被验证以及编译过了,所以这次将直接调用到内存快,完全跳过了JIT编译器函数。WriteLine执行完后,同样返回到Main。

 

金沙官网线上 5

本文由金沙官网线上发布于编程,转载请注明出处:C【金沙官网线上】#编译器优化那点事

您可能还会对下面的文章感兴趣: