Performance of Trigonometric math function have unbelievable loss at .NET8

[kingsznhone]

Description

I have a compute program that have intense Trigonometric calculation.

I try to compile with .NET 8 . Then run a benchmark.

Compute speed drop more than 10 times more.

Configuration

OS: Windows 11 x64
Runtime: .NET 6 7 8

Data

Analysis

The function I use is (su,cu)= Math.SinCos(u);

It's faster than

su = Math.Sin(u);
cu = Math.Cos(u);

on .NET 6 & .NET 7

Then I change my code to

su = Math.Sin(u);
cu = Math.Cos(u);

Here is benchmark result.

I think there are some serious problem with internal implementation of Math.SinCos() method.

Tagging subscribers to this area: @dotnet/area-system-numerics
See info in area-owners.md if you want to be subscribed.

Issue Details

---

Description

I have a compute program that have intense Trigonometric calculation.

I try to compile with .NET 8 . Then run a benchmark.

Compute speed drop more than 10 times more.

Configuration

OS: Windows 11 x64
Runtime: .NET 6 7 8

Data

Analysis

The function I use is (su,cu)= Math.SinCos(u);

It's faster than

su = Math.Sin(u);
cu = Math.Cos(u);

on .NET 6 & .NET 7

Then I change my code to

su = Math.Sin(u);
cu = Math.Cos(u);

Here is benchmark result.

I think there are some serious problem with internal implementation of Math.SinCos() method.

Author:	kingsznhone
Assignees:	-
Labels:	area-System.Numerics, tenet-performance
Milestone:	-

[huoyaoyuan]

I don's see a performance difference in the following benchmark. Can you share more information about your benchmark?

Method	Job	Runtime	Angle	Mean	Error	StdDev	Ratio
Separate	.NET 6.0	.NET 6.0	123.45	13.89 ns	0.132 ns	0.123 ns	1.00
SinCos	.NET 6.0	.NET 6.0	123.45	14.24 ns	0.031 ns	0.029 ns	1.03
Separate	.NET 7.0	.NET 7.0	123.45	13.56 ns	0.186 ns	0.174 ns	1.00
SinCos	.NET 7.0	.NET 7.0	123.45	13.68 ns	0.043 ns	0.036 ns	1.01
Separate	.NET 8.0	.NET 8.0	123.45	13.46 ns	0.028 ns	0.026 ns	1.00
SinCos	.NET 8.0	.NET 8.0	123.45	13.74 ns	0.036 ns	0.034 ns	1.02

[SimpleJob(RuntimeMoniker.Net60)]
[SimpleJob(RuntimeMoniker.Net70)]
[SimpleJob(RuntimeMoniker.Net80)]
public class Program
{
    static void Main()
    {
        BenchmarkRunner.Run<Program>();
    }

    [Params(123.45)]
    public double Angle { get; set; }

    [Benchmark(Baseline = true)]
    public double Separate()
    {
        double sin = Math.Sin(Angle);
        double cos = Math.Cos(Angle);
        return sin + cos;
    }

    [Benchmark]
    public double SinCos()
    {
        (double sin, double cos) = Math.SinCos(Angle);
        return sin + cos;
    }
}

[kingsznhone]

Here is a performance profiler result for 1000 loop of the hotspot function.

In debug mode, .NET7 and .NET8 are in the same behaviour.

.NET 7 DEBUG

.NET 8 DEBUG

But in Release mode , .NET8 Cost many times than .NET7.

.NET 7 Release

.NET 8 Release

As I mentioned before, change code to seperate sin&cos gonna make .NET 7 and 8 in same execute time.

So my inference is that SinCos() in certain context after REALEASE optimize cause performance loss.

[kingsznhone]

I'm going deep in Assembly level and found this blowing my mind.
The compiler does a lot of negative optimizations in this hotspot.
I have no idea why this happened.

.NET 7 REALEASE

               for (int n = 0; n < terms.Length; n++)
00007FFF232B3E63  xor         r9d,r9d  
00007FFF232B3E66  mov         r10d,dword ptr [rcx+8]  
00007FFF232B3E6A  mov         dword ptr [rbp+1Ch],r10d  
00007FFF232B3E6E  test        r10d,r10d  
00007FFF232B3E71  jle         Calculate(VariableTable, Double)+0169h (07FFF232B3EE9h)  
                {
                    u = terms[n].aa + terms[n].bb * tj;
00007FFF232B3E73  mov         dword ptr [rbp+3Ch],r9d  
00007FFF232B3E77  mov         r11d,r9d  
00007FFF232B3E7A  shl         r11,5  
00007FFF232B3E7E  mov         qword ptr [rbp+20h],r11  
00007FFF232B3E82  vmulsd      xmm0,xmm6,mmword ptr [rcx+r11+28h]  
00007FFF232B3E89  vaddsd      xmm0,xmm0,mmword ptr [rcx+r11+20h]  
00007FFF232B3E90  lea         rdx,[rbp+30h]  
00007FFF232B3E94  lea         r8,[rbp+28h]  
00007FFF232B3E98  call        00007FFF82F98DE0  
00007FFF232B3E9D  vmovsd      xmm1,qword ptr [rbp+30h]  
00007FFF232B3EA2  vmovsd      xmm0,qword ptr [rbp+28h]  
                    result += t[it] * (terms[n].ss * su + terms[n].cc * cu);
00007FFF232B3EA7  cmp         r12d,15h  
00007FFF232B3EAB  jae         Calculate(VariableTable, Double)+01E8h (07FFF232B3F68h)  
00007FFF232B3EB1  mov         rcx,qword ptr [rbp+8]  
00007FFF232B3EB5  mov         r11,qword ptr [rbp+20h]  
00007FFF232B3EB9  vmulsd      xmm1,xmm1,mmword ptr [rcx+r11+10h]  
00007FFF232B3EC0  vmulsd      xmm0,xmm0,mmword ptr [rcx+r11+18h]  
00007FFF232B3EC7  vaddsd      xmm1,xmm1,xmm0  
00007FFF232B3ECB  mov         rax,qword ptr [rbp+10h]  
00007FFF232B3ECF  vmulsd      xmm1,xmm1,mmword ptr [r15+rax*8]  
00007FFF232B3ED5  vaddsd      xmm7,xmm1,xmm7 
        for (int n = 0; n < terms.Length; n++)

.NET 8 REALEASE

                for (int n = 0; n < terms.Length; n++)
00007FFE52398E2A  xor         ecx,ecx  
00007FFE52398E2C  mov         dword ptr [rbp+74h],ecx  
00007FFE52398E2F  nop  
00007FFE52398E30  jmp         Calculate(VariableTable, Double)+032Ah (07FFE52398F4Ah)  
                {
                    u = terms[n].aa + terms[n].bb * tj;
00007FFE52398E35  mov         rcx,qword ptr [rbp+80h]  
00007FFE52398E3C  mov         eax,dword ptr [rbp+74h]  
00007FFE52398E3F  cmp         eax,dword ptr [rcx+8]  
00007FFE52398E42  jb          Calculate(VariableTable, Double)+0229h (07FFE52398E49h)  
00007FFE52398E44  call        00007FFEB1FD2DB0  
00007FFE52398E49  mov         edx,eax  
00007FFE52398E4B  imul        rdx,rdx,20h  
00007FFE52398E4F  lea         rcx,[rcx+rdx+10h]  
00007FFE52398E54  vmovsd      xmm1,qword ptr [rcx+10h]  
00007FFE52398E59  mov         rcx,qword ptr [rbp+80h]  
00007FFE52398E60  mov         eax,dword ptr [rbp+74h]  
00007FFE52398E63  cmp         eax,dword ptr [rcx+8]  
00007FFE52398E66  jb          Calculate(VariableTable, Double)+024Dh (07FFE52398E6Dh)  
00007FFE52398E68  call        00007FFEB1FD2DB0  
00007FFE52398E6D  mov         edx,eax  
00007FFE52398E6F  imul        rdx,rdx,20h  
00007FFE52398E73  lea         rcx,[rcx+rdx+10h]  
00007FFE52398E78  vmovsd      xmm0,qword ptr [rcx+18h]  
00007FFE52398E7D  vmulsd      xmm0,xmm0,mmword ptr [rbp+0B8h]  
00007FFE52398E85  vaddsd      xmm1,xmm1,xmm0  
00007FFE52398E89  lea         rcx,[rbp+20h]  
00007FFE52398E8D  call        qword ptr [CLRStub[MethodDescPrestub]@00007FFE526D4FA8 (07FFE526D4FA8h)]  
                    (su, cu) = Math.SinCos(u);
00007FFE52398E93  vmovsd      xmm0,qword ptr [rbp+20h]  
00007FFE52398E98  vmovsd      qword ptr [rbp+98h],xmm0  
00007FFE52398EA0  vmovsd      xmm0,qword ptr [rbp+28h]  
00007FFE52398EA5  vmovsd      qword ptr [rbp+90h],xmm0  
                    result += t[it] * (terms[n].ss * su + terms[n].cc * cu);
00007FFE52398EAD  vmovsd      xmm0,qword ptr [rbp+0A0h]  
00007FFE52398EB5  vmovsd      qword ptr [rbp+18h],xmm0  
00007FFE52398EBA  lea         rcx,[rbp+0A8h]  
00007FFE52398EC1  mov         edx,dword ptr [rbp+78h]  
00007FFE52398EC4  call        qword ptr [CLRStub[MethodDescPrestub]@00007FFE52A16760 (07FFE52A16760h)]  
00007FFE52398ECA  mov         qword ptr [rbp+10h],rax  
00007FFE52398ECE  mov         rax,qword ptr [rbp+10h]  
00007FFE52398ED2  vmovsd      xmm1,qword ptr [rax]  
00007FFE52398ED6  mov         rax,qword ptr [rbp+80h]  
00007FFE52398EDD  mov         ecx,dword ptr [rbp+74h]  
00007FFE52398EE0  cmp         ecx,dword ptr [rax+8]  
00007FFE52398EE3  jb          Calculate(VariableTable, Double)+02CAh (07FFE52398EEAh)  
00007FFE52398EE5  call        00007FFEB1FD2DB0  
00007FFE52398EEA  mov         edx,ecx  
00007FFE52398EEC  imul        rdx,rdx,20h  
00007FFE52398EF0  lea         rax,[rax+rdx+10h]  
00007FFE52398EF5  vmovsd      xmm0,qword ptr [rax]  
00007FFE52398EF9  vmulsd      xmm0,xmm0,mmword ptr [rbp+98h]  
00007FFE52398F01  mov         rax,qword ptr [rbp+80h]  
00007FFE52398F08  mov         ecx,dword ptr [rbp+74h]  
00007FFE52398F0B  cmp         ecx,dword ptr [rax+8]  
00007FFE52398F0E  jb          Calculate(VariableTable, Double)+02F5h (07FFE52398F15h)  
00007FFE52398F10  call        00007FFEB1FD2DB0  
00007FFE52398F15  mov         edx,ecx  
00007FFE52398F17  imul        rdx,rdx,20h  
00007FFE52398F1B  lea         rax,[rax+rdx+10h]  
00007FFE52398F20  vmovsd      xmm2,qword ptr [rax+8]  
00007FFE52398F25  vmulsd      xmm2,xmm2,mmword ptr [rbp+90h]  
00007FFE52398F2D  vaddsd      xmm0,xmm0,xmm2  
00007FFE52398F31  vmulsd      xmm1,xmm1,xmm0  
00007FFE52398F35  vaddsd      xmm1,xmm1,mmword ptr [rbp+18h]  
00007FFE52398F3A  vmovsd      qword ptr [rbp+0A0h],xmm1  
        for (int n = 0; n < terms.Length; n++)

compiler is far beyond my knowledge. Hope these infomations will be useful

[gfoidl]

This looks like Tier-0 (unoptimized code).
Did you have a debugger attached, etc?

For BenchmarkDotNet you can use the [Disassembly]-diagnoser to get the asm.

[kingsznhone]

This looks like Tier-0 (unoptimized code). Did you have a debugger attached, etc?

For BenchmarkDotNet you can use the [Disassembly]-diagnoser to get the asm.

Even DEBUG is faster than RELEASE .
I think it's negative optimize for sure :(

[stephentoub]

Please share the full benchmark you're running.

[kingsznhone]

Please share the full benchmark you're running.

Check this Repo. VSOP2013
Add net-8.0 in target framework.
then Add [SimpleJob(RuntimeMoniker.Net80)] in /Demo/PerfTest.cs

run demo will lead to benchmark result

[andrewjsaid]

I am unable to reproduce this when running the project as per your instructions.

[kingsznhone]

I am unable to reproduce this when running the project as per your instructions.

I run benckmark on another computer with fresh SDK
Here is result.

Another Result from Windows 10 in Hyper-V.

Result from my friend's AMD PC.
Is it a bug of the compiler on Intel processor?

[tannergooding]

Can you add the [DisassemblyDiagnoser] attribute to the benchmark and share the result: https://benchmarkdotnet.org/articles/features/disassembler.html

It's possible this is something like the JCC Erratum that exists on Intel processors. It's also possible there is some subtle codegen difference that is impacting things here.

Notably this currently just defers down to the C Runtime and there were no explicit changes to the logic done in the .NET 7/8 timeframe.

[saucecontrol]

I'm seeing a regression on Intel 11th gen (Tiger Lake) as well, though not of the same magnitude as shown on the hybrid models above

Here's the DisassemblyDiagnoser output

Edit: Oops, pasted without reading. It's useless...

Expand

.NET 6.0.25 (6.0.2523.51912), X64 RyuJIT AVX2

; Demo.PerfTest.Compute()
       mov       [rsp+8],rcx
       mov       rcx,[rcx+8]
       mov       r8,[rsp+8]
       mov       r8,[r8+10]
       mov       edx,4
       cmp       [rcx],ecx
       jmp       near ptr VSOP2013.Calculator.GetPlanetPosition(VSOP2013.VSOPBody, VSOP2013.VSOPTime)
; Total bytes of code 30

; VSOP2013.Calculator.GetPlanetPosition(VSOP2013.VSOPBody, VSOP2013.VSOPTime)
       push      rdi
       push      rsi
       push      rbp
       push      rbx
       sub       rsp,38
       mov       rsi,rcx
       mov       ebx,edx
       mov       rdi,r8
       mov       rcx,offset MT_VSOP2013.Calculator+<>c__DisplayClass4_0
       call      CORINFO_HELP_NEWSFAST
       mov       rbp,rax
       lea       rcx,[rbp+10]
       mov       rdx,rsi
       call      CORINFO_HELP_ASSIGN_REF
       mov       [rbp+20],ebx
       lea       rcx,[rbp+18]
       mov       rdx,rdi
       call      CORINFO_HELP_ASSIGN_REF
       mov       rcx,offset MT_System.Double[]
       mov       edx,6
       call      CORINFO_HELP_NEWARR_1_VC
       lea       rcx,[rbp+8]
       mov       rdx,rax
       call      CORINFO_HELP_ASSIGN_REF
       mov       rcx,offset MT_System.Action`1[[System.Int32, System.Private.CoreLib]]
       call      CORINFO_HELP_NEWSFAST
       mov       rsi,rax
       lea       rcx,[rsi+8]
       mov       rdx,rbp
       call      CORINFO_HELP_ASSIGN_REF
       mov       rcx,offset VSOP2013.Calculator+<>c__DisplayClass4_0.<GetPlanetPosition>b__0(Int32)
       mov       [rsi+18],rcx
       lea       rcx,[rsp+20]
       mov       r9,rsi
       xor       edx,edx
       mov       r8d,6
       call      System.Threading.Tasks.Parallel.For(Int32, Int32, System.Action`1<Int32>)
       mov       rcx,offset MT_VSOP2013.VSOPResult_ELL
       call      CORINFO_HELP_NEWSFAST
       mov       rsi,rax
       mov       edx,[rbp+20]
       mov       rax,[rbp+18]
       mov       rdi,[rbp+8]
       mov       [rsi+18],edx
       lea       rcx,[rsi+8]
       mov       rdx,rax
       call      CORINFO_HELP_ASSIGN_REF
       lea       rcx,[rsi+10]
       mov       rdx,rdi
       call      CORINFO_HELP_ASSIGN_REF
       mov       rax,rsi
       add       rsp,38
       pop       rbx
       pop       rbp
       pop       rsi
       pop       rdi
       ret
; Total bytes of code 226

.NET 8.0.0 (8.0.23.53103), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI

; Demo.PerfTest.Compute()
       mov       r8,rcx
       mov       rcx,[r8+8]
       mov       r8,[r8+10]
       mov       edx,4
       cmp       [rcx],ecx
       jmp       qword ptr [7FFC1FB8F960]; VSOP2013.Calculator.GetPlanetPosition(VSOP2013.VSOPBody, VSOP2013.VSOPTime)
; Total bytes of code 24

; VSOP2013.Calculator.GetPlanetPosition(VSOP2013.VSOPBody, VSOP2013.VSOPTime)
       push      rbp
       push      r14
       push      rdi
       push      rsi
       push      rbx
       sub       rsp,70
       lea       rbp,[rsp+90]
       mov       rbx,rcx
       mov       edi,edx
       mov       rsi,r8
       mov       rcx,offset MT_VSOP2013.Calculator+<>c__DisplayClass4_0
       call      CORINFO_HELP_NEWSFAST
       mov       r14,rax
       lea       rcx,[r14+10]
       mov       rdx,rbx
       call      CORINFO_HELP_ASSIGN_REF
       mov       [r14+20],edi
       lea       rcx,[r14+18]
       mov       rdx,rsi
       call      CORINFO_HELP_ASSIGN_REF
       mov       rcx,offset MT_System.Double[]
       mov       edx,6
       call      CORINFO_HELP_NEWARR_1_VC
       lea       rcx,[r14+8]
       mov       rdx,rax
       call      CORINFO_HELP_ASSIGN_REF
       mov       rcx,offset MT_System.Action`1[[System.Int32, System.Private.CoreLib]]
       call      CORINFO_HELP_NEWSFAST
       mov       rbx,rax
       lea       rcx,[rbx+8]
       mov       rdx,r14
       call      CORINFO_HELP_ASSIGN_REF
       mov       rcx,7FFC200B8888
       mov       [rbx+18],rcx
       mov       rcx,1B07C404478
       mov       rcx,[rcx]
       mov       [rsp+20],rcx
       mov       [rsp+28],rbx
       xor       ecx,ecx
       mov       [rsp+30],rcx
       mov       [rsp+38],rcx
       mov       [rsp+40],rcx
       mov       [rsp+48],rcx
       lea       rcx,[rbp-38]
       mov       rdx,offset MD_System.Threading.Tasks.Parallel.ForWorker[[System.Object, System.Private.CoreLib],[System.Int32, System.Private.CoreLib]](Int32, Int32, System.Threading.Tasks.ParallelOptions, System.Action`1<Int32>, System.Action`2<Int32,System.Threading.Tasks.ParallelLoopState>, System.Func`4<Int32,System.Threading.Tasks.ParallelLoopState,System.Object,System.Object>, System.Func`1<System.Object>, System.Action`1<System.Object>)
       xor       r8d,r8d
       mov       r9d,6
       call      qword ptr [7FFC1FBE55A8]; System.Threading.Tasks.Parallel.ForWorker[[System.__Canon, System.Private.CoreLib],[System.Int32, System.Private.CoreLib]](Int32, Int32, System.Threading.Tasks.ParallelOptions, System.Action`1<Int32>, System.Action`2<Int32,System.Threading.Tasks.ParallelLoopState>, System.Func`4<Int32,System.Threading.Tasks.ParallelLoopState,System.__Canon,System.__Canon>, System.Func`1<System.__Canon>, System.Action`1<System.__Canon>)
       mov       rcx,offset MT_VSOP2013.VSOPResult_ELL
       call      CORINFO_HELP_NEWSFAST
       mov       rbx,rax
       mov       ecx,[r14+20]
       mov       rdx,[r14+18]
       mov       rsi,[r14+8]
       mov       [rbx+18],ecx
       lea       rcx,[rbx+8]
       call      CORINFO_HELP_ASSIGN_REF
       lea       rcx,[rbx+10]
       mov       rdx,rsi
       call      CORINFO_HELP_ASSIGN_REF
       mov       rax,rbx
       add       rsp,70
       pop       rbx
       pop       rsi
       pop       rdi
       pop       r14
       pop       rbp
       ret
; Total bytes of code 290