JIT: Prototype an aggressive SSA-based dead code elimination phase

[jakobbotsch]

Unlike normal liveness based DCE, this algorithm is able to remove loops that do not compute any values that are externally visible.

The algorithm implemented here appears in Cytron, Ron, et al. "Efficiently computing static single assignment form and the control dependence graph.". It was implemented in collaboration with @AndyAyersMS and @TIHan.

Example:

publicstaticvoidMain(){for(inti=0;i<100;i++){}Console.WriteLine("Hello");}

Before:

G_M48905_IG01: ;; offset=0x0000subrsp,40 ;; size=4 bbWeight=1 PerfScore 0.25G_M48905_IG02: ;; offset=0x0004movecx,100align[0 bytes for IG03] ;; size=5 bbWeight=1 PerfScore 0.25G_M48905_IG03: ;; offset=0x0009dececxjne SHORT G_M48905_IG03 ;; size=4 bbWeight=4 PerfScore 5.00G_M48905_IG04: ;; offset=0x000Dmovrcx,0x1ECD7572C30 ; 'Hello'call[System.Console:WriteLine(System.String)]nop ;; size=17 bbWeight=1 PerfScore 3.50G_M48905_IG05: ;; offset=0x001Eaddrsp,40ret ;; size=5 bbWeight=1 PerfScore 1.25

After:

G_M48905_IG01: ;; offset=0x0000subrsp,40 ;; size=4 bbWeight=4 PerfScore 1.00G_M48905_IG02: ;; offset=0x0004movrcx,0x277EDA22C30 ; 'Hello'call[System.Console:WriteLine(System.String)]nop ;; size=17 bbWeight=4 PerfScore 14.00G_M48905_IG03: ;; offset=0x0015addrsp,40ret ;; size=5 bbWeight=4 PerfScore 5.00

[dotnet-policy-service]

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

[jakobbotsch]

This algorithm unfortunately does not seem to be compatible with IL semantics. In particular it is very non-trivial to identify when we can get rid of conditional backedges because it requires us to prove that the forward edge will eventually be taken. That is, for an example like

publicstaticvoidTest(intk){for(inti=0;i<=k;i++){}}

the algorithm naturally uncovers that the loop has no side effect, and will happily delete i++ and mark the loop condition as dead. However, it is not correct to actually remove this loop, since we do not know whether it will be infinite or not. Detecting in general whether a cycle in the flow graph will be taken indefinitely seems intractable for us. In C/C++ removing these loops is ok because it is UB for them to be infinite.

[jakobbotsch]

Unlike normal liveness based DCE, this algorithm is able to remove loops that do not compute any values that are externally visible.

The algorithm implemented here appears in Cytron, Ron, et al. "Efficiently computing static single assignment form and the control dependence graph.". It was implemented in collaboration with @AndyAyersMS and @TIHan.

Example:

publicstaticvoidMain(){for(inti=0;i<100;i++){}Console.WriteLine("Hello");}

Before:

G_M48905_IG01: ;; offset=0x0000subrsp,40 ;; size=4 bbWeight=1 PerfScore 0.25G_M48905_IG02: ;; offset=0x0004movecx,100align[0 bytes for IG03] ;; size=5 bbWeight=1 PerfScore 0.25G_M48905_IG03: ;; offset=0x0009dececxjne SHORT G_M48905_IG03 ;; size=4 bbWeight=4 PerfScore 5.00G_M48905_IG04: ;; offset=0x000Dmovrcx,0x1ECD7572C30 ; 'Hello'call[System.Console:WriteLine(System.String)]nop ;; size=17 bbWeight=1 PerfScore 3.50G_M48905_IG05: ;; offset=0x001Eaddrsp,40ret ;; size=5 bbWeight=1 PerfScore 1.25

After:

G_M48905_IG01: ;; offset=0x0000subrsp,40 ;; size=4 bbWeight=4 PerfScore 1.00G_M48905_IG02: ;; offset=0x0004movrcx,0x277EDA22C30 ; 'Hello'call[System.Console:WriteLine(System.String)]nop ;; size=17 bbWeight=4 PerfScore 14.00G_M48905_IG03: ;; offset=0x0015addrsp,40ret ;; size=5 bbWeight=4 PerfScore 5.00

[dotnet-policy-service]

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

[jakobbotsch]

This algorithm unfortunately does not seem to be compatible with IL semantics. In particular it is very non-trivial to identify when we can get rid of conditional backedges because it requires us to prove that the forward edge will eventually be taken. That is, for an example like

publicstaticvoidTest(intk){for(inti=0;i<=k;i++){}}

the algorithm naturally uncovers that the loop has no side effect, and will happily delete i++ and mark the loop condition as dead. However, it is not correct to actually remove this loop, since we do not know whether it will be infinite or not. Detecting in general whether a cycle in the flow graph will be taken indefinitely seems intractable for us. In C/C++ removing these loops is ok because it is UB for them to be infinite.

[jakobbotsch]

Unlike normal liveness based DCE, this algorithm is able to remove loops that do not compute any values that are externally visible.

The algorithm implemented here appears in Cytron, Ron, et al. "Efficiently computing static single assignment form and the control dependence graph.". It was implemented in collaboration with @AndyAyersMS and @TIHan.

Example:

publicstaticvoidMain(){for(inti=0;i<100;i++){}Console.WriteLine("Hello");}

Before:

G_M48905_IG01: ;; offset=0x0000subrsp,40 ;; size=4 bbWeight=1 PerfScore 0.25G_M48905_IG02: ;; offset=0x0004movecx,100align[0 bytes for IG03] ;; size=5 bbWeight=1 PerfScore 0.25G_M48905_IG03: ;; offset=0x0009dececxjne SHORT G_M48905_IG03 ;; size=4 bbWeight=4 PerfScore 5.00G_M48905_IG04: ;; offset=0x000Dmovrcx,0x1ECD7572C30 ; 'Hello'call[System.Console:WriteLine(System.String)]nop ;; size=17 bbWeight=1 PerfScore 3.50G_M48905_IG05: ;; offset=0x001Eaddrsp,40ret ;; size=5 bbWeight=1 PerfScore 1.25

After:

G_M48905_IG01: ;; offset=0x0000subrsp,40 ;; size=4 bbWeight=4 PerfScore 1.00G_M48905_IG02: ;; offset=0x0004movrcx,0x277EDA22C30 ; 'Hello'call[System.Console:WriteLine(System.String)]nop ;; size=17 bbWeight=4 PerfScore 14.00G_M48905_IG03: ;; offset=0x0015addrsp,40ret ;; size=5 bbWeight=4 PerfScore 5.00

[dotnet-policy-service]

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

[jakobbotsch]

This algorithm unfortunately does not seem to be compatible with IL semantics. In particular it is very non-trivial to identify when we can get rid of conditional backedges because it requires us to prove that the forward edge will eventually be taken. That is, for an example like

publicstaticvoidTest(intk){for(inti=0;i<=k;i++){}}

the algorithm naturally uncovers that the loop has no side effect, and will happily delete i++ and mark the loop condition as dead. However, it is not correct to actually remove this loop, since we do not know whether it will be infinite or not. Detecting in general whether a cycle in the flow graph will be taken indefinitely seems intractable for us. In C/C++ removing these loops is ok because it is UB for them to be infinite.

[jakobbotsch]

Unlike normal liveness based DCE, this algorithm is able to remove loops that do not compute any values that are externally visible.

The algorithm implemented here appears in Cytron, Ron, et al. "Efficiently computing static single assignment form and the control dependence graph.". It was implemented in collaboration with @AndyAyersMS and @TIHan.

Example:

publicstaticvoidMain(){for(inti=0;i<100;i++){}Console.WriteLine("Hello");}

Before:

G_M48905_IG01: ;; offset=0x0000subrsp,40 ;; size=4 bbWeight=1 PerfScore 0.25G_M48905_IG02: ;; offset=0x0004movecx,100align[0 bytes for IG03] ;; size=5 bbWeight=1 PerfScore 0.25G_M48905_IG03: ;; offset=0x0009dececxjne SHORT G_M48905_IG03 ;; size=4 bbWeight=4 PerfScore 5.00G_M48905_IG04: ;; offset=0x000Dmovrcx,0x1ECD7572C30 ; 'Hello'call[System.Console:WriteLine(System.String)]nop ;; size=17 bbWeight=1 PerfScore 3.50G_M48905_IG05: ;; offset=0x001Eaddrsp,40ret ;; size=5 bbWeight=1 PerfScore 1.25

After:

G_M48905_IG01: ;; offset=0x0000subrsp,40 ;; size=4 bbWeight=4 PerfScore 1.00G_M48905_IG02: ;; offset=0x0004movrcx,0x277EDA22C30 ; 'Hello'call[System.Console:WriteLine(System.String)]nop ;; size=17 bbWeight=4 PerfScore 14.00G_M48905_IG03: ;; offset=0x0015addrsp,40ret ;; size=5 bbWeight=4 PerfScore 5.00

[dotnet-policy-service]

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

[jakobbotsch]

This algorithm unfortunately does not seem to be compatible with IL semantics. In particular it is very non-trivial to identify when we can get rid of conditional backedges because it requires us to prove that the forward edge will eventually be taken. That is, for an example like

publicstaticvoidTest(intk){for(inti=0;i<=k;i++){}}

the algorithm naturally uncovers that the loop has no side effect, and will happily delete i++ and mark the loop condition as dead. However, it is not correct to actually remove this loop, since we do not know whether it will be infinite or not. Detecting in general whether a cycle in the flow graph will be taken indefinitely seems intractable for us. In C/C++ removing these loops is ok because it is UB for them to be infinite.

[jakobbotsch]

Unlike normal liveness based DCE, this algorithm is able to remove loops that do not compute any values that are externally visible.

The algorithm implemented here appears in Cytron, Ron, et al. "Efficiently computing static single assignment form and the control dependence graph.". It was implemented in collaboration with @AndyAyersMS and @TIHan.

Example:

publicstaticvoidMain(){for(inti=0;i<100;i++){}Console.WriteLine("Hello");}

Before:

G_M48905_IG01: ;; offset=0x0000subrsp,40 ;; size=4 bbWeight=1 PerfScore 0.25G_M48905_IG02: ;; offset=0x0004movecx,100align[0 bytes for IG03] ;; size=5 bbWeight=1 PerfScore 0.25G_M48905_IG03: ;; offset=0x0009dececxjne SHORT G_M48905_IG03 ;; size=4 bbWeight=4 PerfScore 5.00G_M48905_IG04: ;; offset=0x000Dmovrcx,0x1ECD7572C30 ; 'Hello'call[System.Console:WriteLine(System.String)]nop ;; size=17 bbWeight=1 PerfScore 3.50G_M48905_IG05: ;; offset=0x001Eaddrsp,40ret ;; size=5 bbWeight=1 PerfScore 1.25

After:

G_M48905_IG01: ;; offset=0x0000subrsp,40 ;; size=4 bbWeight=4 PerfScore 1.00G_M48905_IG02: ;; offset=0x0004movrcx,0x277EDA22C30 ; 'Hello'call[System.Console:WriteLine(System.String)]nop ;; size=17 bbWeight=4 PerfScore 14.00G_M48905_IG03: ;; offset=0x0015addrsp,40ret ;; size=5 bbWeight=4 PerfScore 5.00

[dotnet-policy-service]

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

[jakobbotsch]

This algorithm unfortunately does not seem to be compatible with IL semantics. In particular it is very non-trivial to identify when we can get rid of conditional backedges because it requires us to prove that the forward edge will eventually be taken. That is, for an example like

publicstaticvoidTest(intk){for(inti=0;i<=k;i++){}}

the algorithm naturally uncovers that the loop has no side effect, and will happily delete i++ and mark the loop condition as dead. However, it is not correct to actually remove this loop, since we do not know whether it will be infinite or not. Detecting in general whether a cycle in the flow graph will be taken indefinitely seems intractable for us. In C/C++ removing these loops is ok because it is UB for them to be infinite.

[jakobbotsch]

Unlike normal liveness based DCE, this algorithm is able to remove loops that do not compute any values that are externally visible.

The algorithm implemented here appears in Cytron, Ron, et al. "Efficiently computing static single assignment form and the control dependence graph.". It was implemented in collaboration with @AndyAyersMS and @TIHan.

Example:

publicstaticvoidMain(){for(inti=0;i<100;i++){}Console.WriteLine("Hello");}

Before:

G_M48905_IG01: ;; offset=0x0000subrsp,40 ;; size=4 bbWeight=1 PerfScore 0.25G_M48905_IG02: ;; offset=0x0004movecx,100align[0 bytes for IG03] ;; size=5 bbWeight=1 PerfScore 0.25G_M48905_IG03: ;; offset=0x0009dececxjne SHORT G_M48905_IG03 ;; size=4 bbWeight=4 PerfScore 5.00G_M48905_IG04: ;; offset=0x000Dmovrcx,0x1ECD7572C30 ; 'Hello'call[System.Console:WriteLine(System.String)]nop ;; size=17 bbWeight=1 PerfScore 3.50G_M48905_IG05: ;; offset=0x001Eaddrsp,40ret ;; size=5 bbWeight=1 PerfScore 1.25

After:

G_M48905_IG01: ;; offset=0x0000subrsp,40 ;; size=4 bbWeight=4 PerfScore 1.00G_M48905_IG02: ;; offset=0x0004movrcx,0x277EDA22C30 ; 'Hello'call[System.Console:WriteLine(System.String)]nop ;; size=17 bbWeight=4 PerfScore 14.00G_M48905_IG03: ;; offset=0x0015addrsp,40ret ;; size=5 bbWeight=4 PerfScore 5.00

[dotnet-policy-service]

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

[jakobbotsch]

This algorithm unfortunately does not seem to be compatible with IL semantics. In particular it is very non-trivial to identify when we can get rid of conditional backedges because it requires us to prove that the forward edge will eventually be taken. That is, for an example like

publicstaticvoidTest(intk){for(inti=0;i<=k;i++){}}

the algorithm naturally uncovers that the loop has no side effect, and will happily delete i++ and mark the loop condition as dead. However, it is not correct to actually remove this loop, since we do not know whether it will be infinite or not. Detecting in general whether a cycle in the flow graph will be taken indefinitely seems intractable for us. In C/C++ removing these loops is ok because it is UB for them to be infinite.

[jakobbotsch]

Unlike normal liveness based DCE, this algorithm is able to remove loops that do not compute any values that are externally visible.

The algorithm implemented here appears in Cytron, Ron, et al. "Efficiently computing static single assignment form and the control dependence graph.". It was implemented in collaboration with @AndyAyersMS and @TIHan.

Example:

publicstaticvoidMain(){for(inti=0;i<100;i++){}Console.WriteLine("Hello");}

Before:

G_M48905_IG01: ;; offset=0x0000subrsp,40 ;; size=4 bbWeight=1 PerfScore 0.25G_M48905_IG02: ;; offset=0x0004movecx,100align[0 bytes for IG03] ;; size=5 bbWeight=1 PerfScore 0.25G_M48905_IG03: ;; offset=0x0009dececxjne SHORT G_M48905_IG03 ;; size=4 bbWeight=4 PerfScore 5.00G_M48905_IG04: ;; offset=0x000Dmovrcx,0x1ECD7572C30 ; 'Hello'call[System.Console:WriteLine(System.String)]nop ;; size=17 bbWeight=1 PerfScore 3.50G_M48905_IG05: ;; offset=0x001Eaddrsp,40ret ;; size=5 bbWeight=1 PerfScore 1.25

After:

G_M48905_IG01: ;; offset=0x0000subrsp,40 ;; size=4 bbWeight=4 PerfScore 1.00G_M48905_IG02: ;; offset=0x0004movrcx,0x277EDA22C30 ; 'Hello'call[System.Console:WriteLine(System.String)]nop ;; size=17 bbWeight=4 PerfScore 14.00G_M48905_IG03: ;; offset=0x0015addrsp,40ret ;; size=5 bbWeight=4 PerfScore 5.00

[dotnet-policy-service]

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

[jakobbotsch]

This algorithm unfortunately does not seem to be compatible with IL semantics. In particular it is very non-trivial to identify when we can get rid of conditional backedges because it requires us to prove that the forward edge will eventually be taken. That is, for an example like

publicstaticvoidTest(intk){for(inti=0;i<=k;i++){}}

the algorithm naturally uncovers that the loop has no side effect, and will happily delete i++ and mark the loop condition as dead. However, it is not correct to actually remove this loop, since we do not know whether it will be infinite or not. Detecting in general whether a cycle in the flow graph will be taken indefinitely seems intractable for us. In C/C++ removing these loops is ok because it is UB for them to be infinite.