Improve Math.BigMul to fix Decimal compare perf regression

[Daniel-Svensson]

Improve the worst case performance of Math.BigMul which will hopefully resolve #112432 (regression i Decimal comparision)
This also allows Math.BigMul to do partial constant propagation (of the low part)

The regression seems to be caused by extra stack spilling caused by usage of MultiplyNoFlags

This PR applies the workaround suggested by @tevador in #11782 (comment) (se link for benchmarks) to Math.BigMul, which removes the extra push/pop which will hopefully restore performance.

See sharplab.io for codegen (Change BigMul2 to BigMul for code in main)

New

Main

Benchmark

1. Se in Bmi2.MultiplyNoFlags issues #11782 (comment)

2. Benchmark for orderby with and without this pr (main is commit where decimal code was merged)

BenchmarkDotNet v0.14.1-nightly.20250107.205, Windows 11 (10.0.26100.3915)
AMD Ryzen 7 5800X 3.80GHz, 1 CPU, 16 logical and 8 physical cores
.NET SDK 10.0.100-alpha.1.25077.2
  [Host]     : .NET 10.0.0 (10.0.25.7313), X64 RyuJIT AVX2
  Job-NQDAQW : .NET 10.0.0 (42.42.42.42424), X64 RyuJIT AVX2
  Job-CICNHA : .NET 10.0.0 (42.42.42.42424), X64 RyuJIT AVX2

PowerPlanMode=00000000-0000-0000-0000-000000000000  IterationTime=250ms  MaxIterationCount=20  
MinIterationCount=15  WarmupCount=1  

Method	Job	Toolchain	Mean	Error	StdDev	Median	Min	Max	Ratio	RatioSD	Gen0	Allocated	Alloc Ratio
Order00LinqQueryX	Job-NQDAQW	\main\10.0.0\corerun.exe	39.28 ms	1.002 ms	1.153 ms	39.75 ms	36.01 ms	40.28 ms	1.06	0.04	3500.0000	56.65 MB	1.00
Order00LinqQueryX	Job-CICNHA	\pr\10.0.0\corerun.exe	37.25 ms	0.798 ms	0.919 ms	37.56 ms	34.65 ms	38.16 ms	1.00	0.04	3428.5714	56.65 MB	1.00
Order00LinqMethodX	Job-NQDAQW	\main\10.0.0\corerun.exe	39.09 ms	0.766 ms	0.882 ms	39.30 ms	36.25 ms	39.95 ms	1.06	0.04	3428.5714	56.65 MB	1.00
Order00LinqMethodX	Job-CICNHA	\pr\10.0.0\corerun.exe	36.96 ms	1.012 ms	1.082 ms	37.31 ms	33.85 ms	38.07 ms	1.00	0.04	3428.5714	56.65 MB	1.00
Order00ManualX	Job-NQDAQW	\main\10.0.0\corerun.exe	77.68 ms	0.331 ms	0.309 ms	77.69 ms	77.21 ms	78.11 ms	1.01	0.01	750.0000	15.26 MB	1.00
Order00ManualX	Job-CICNHA	\pr\10.0.0\corerun.exe	76.65 ms	0.344 ms	0.305 ms	76.68 ms	75.90 ms	77.09 ms	1.00	0.01	750.0000	15.26 MB	1.00

builting x86 multiply approach (x86_multiply branch)

I've updated the code forther to make Math.BigMul a single mul instruction on all x64 platforms (not just those with BMI2) and the code

Benchmarks

currently rerunning after rebase ...

Exampels of new code

[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.AggressiveOptimization)]
static void TestBigMul2(ref ulong x, ref ulong y)
{
    x = Math.BigMul(x, y, out y);
}

[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.AggressiveOptimization)]
static void TestBigMul1(ref long x, ref long y)
{
    x = Math.BigMul(x, y, out y);
}

Produces the following (code from just before rebase)

; Method Program:<<Main>$>g__TestBigMul2|0_1(byref,byref) (FullOpts)
G_M19919_IG01:  ;; offset=0x0000
						;; size=0 bbWeight=1 PerfScore 0.00

G_M19919_IG02:  ;; offset=0x0000
       mov      rax, qword ptr [rcx]
       mov      bword ptr [rsp+0x10], rdx
       mul      rdx:rax, qword ptr [rdx]
       mov      r8, bword ptr [rsp+0x10]
       mov      qword ptr [r8], rax
       mov      qword ptr [rcx], rdx
						;; size=22 bbWeight=1 PerfScore 12.00

G_M19919_IG03:  ;; offset=0x0016
       ret      
						;; size=1 bbWeight=1 PerfScore 1.00
; Total bytes of code: 23


; Method Program:<<Main>$>g__TestBigMul1|0_2(byref,byref) (FullOpts)
G_M20175_IG01:  ;; offset=0x0000
						;; size=0 bbWeight=1 PerfScore 0.00

G_M20175_IG02:  ;; offset=0x0000
       mov      rax, qword ptr [rcx]
       mov      bword ptr [rsp+0x10], rdx
       imul     rdx:rax, qword ptr [rdx]
       mov      r8, bword ptr [rsp+0x10]
       mov      qword ptr [r8], rax
       mov      qword ptr [rcx], rdx
						;; size=22 bbWeight=1 PerfScore 12.00

G_M20175_IG03:  ;; offset=0x0016
       ret      
						;; size=1 bbWeight=1 PerfScore 1.00
; Total bytes of code: 23

Current code according to goodbolt goodbolt

Further code samples with array access

static long TestBigMulArr2(long[] x, ref long y)
{
    return Math.BigMul(y, x[1], out y);
}

				
static void TestBigMulArr12(long[] x, ref long y)
{
    x[1] = Math.BigMul(y, x[1], out y);
}
		

; Method Program:<<Main>$>g__TestBigMulArr2|0_5(long[],byref):long (FullOpts)
G_M60604_IG01:  ;; offset=0x0000
       sub      rsp, 40
						;; size=4 bbWeight=1 PerfScore 0.25

G_M60604_IG02:  ;; offset=0x0004
       mov      bword ptr [rsp+0x38], rdx
       mov      rax, qword ptr [rdx]
       cmp      dword ptr [rcx+0x08], 1
       jbe      SHORT G_M60604_IG04
       imul     rdx:rax, qword ptr [rcx+0x18]
       mov      rcx, bword ptr [rsp+0x38]
       mov      qword ptr [rcx], rax
       mov      rax, rdx
						;; size=29 bbWeight=1 PerfScore 15.25

G_M60604_IG03:  ;; offset=0x0021
       add      rsp, 40
       ret      
						;; size=5 bbWeight=1 PerfScore 1.25
											
						; Method Program:<<Main>$>g__TestBigMulArr12|0_6(long[],byref) (FullOpts)
G_M53374_IG01:  ;; offset=0x0000
       sub      rsp, 40
						;; size=4 bbWeight=1 PerfScore 0.25

G_M53374_IG02:  ;; offset=0x0004
       mov      bword ptr [rsp+0x38], rdx
       mov      rax, qword ptr [rdx]
       mov      r8d, dword ptr [rcx+0x08]
       cmp      r8d, 1
       jbe      SHORT G_M53374_IG04
       imul     rdx:rax, qword ptr [rcx+0x18]
       mov      r8, bword ptr [rsp+0x38]
       mov      qword ptr [r8], rax
       mov      qword ptr [rcx+0x18], rdx
						;; size=34 bbWeight=1 PerfScore 15.25

G_M53374_IG03:  ;; offset=0x0026
       add      rsp, 40
       ret      
						;; size=5 bbWeight=1 PerfScore 1.25

G_M53374_IG04:  ;; offset=0x002B
       call     CORINFO_HELP_RNGCHKFAIL
       int3     
						;; size=6 bbWeight=0 PerfScore 0.00
; Total bytes of code: 49

[Copilot]

Pull Request Overview

This PR aims to fix a regression in Decimal comparisons by improving the worst-case performance of Math.BigMul through reducing extra stack spilling.

• Removed unused TARGET_32BIT branch code in BigMul(uint, uint).
• Added conditional logic for non-ARM64 platforms and refactored BigMul methods to remove unsafe code while leveraging BMI2 support.
• Updated comments to reflect the current implementation and performance considerations.

[Daniel-Svensson]

I've updated the benchmark since it seems like i had mixed up the corelib.dll for the pr and my "old" branch.

[Daniel-Svensson]

converting to draft since I want to run a quick test against calling the basic x86 mul as instrinct instead of bmi2 mulx

[dotnet-policy-service]

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