Comparison of decimal floating-point types in Swift

This is a small project which compares two different implementations for a Swift Decimal64 struct against the builtin types Double and Decimal.

DecimalFP64 (deprecated)

This is a struct which conforms to the FloatingPoint protocol. (It compiles fine but not all functions are implemented) It tries to follow IEEE 754 as closely as possible and supports +/- Infinity, signed zeros and NaNs.

Internal structure:

Part | Bits | Comment -|-|- Sign | 63 | separate bit Exponent | 54..62 | with room for NaN and Inf Significand | 0..53| 16 decimal digits

Decimal64

This struct doesn't conform to the FloatingPoint protocol and uses a different internal representation of the numbers. It has no support for +/- Infinity, uses a 2's complement for negative numbers (i.e. no signed zeros) and ignores NaNs.

Internal structure:

Part | Bits | Comment -|-|- Significand | 9..63 | 16 decimal digits and sign Exponent | 0..8 | from -256 to +255

Decimal (builtin, for reference, deprecated)

This is an Apple provided struct with 160bit. Does not conform to the FloatingPoint protocol. Removed from current benchmarks. It is just too slow.

Double (builtin, for reference)

Internal floating-point type with 64bit.

Performance

To test the performance of a few basic operations (+,*,/ and conversion to string) a small benchmark was used to compare the four different types.

As Double and DecimalFP64 both conformed to the FloatingPoint protocol, these were tested with a generic version too.

Testing was concluded with Xcode 10.2.1 on an iMac (Retina 5K, 27", 2017) with 4.2 GHz Intel Core i7 and macOS Mojave 10.14.5

Update for version v1.1: Decimal64 and DecimalFP64 now conform to the TextOutputStreamable protocol.

Number Type | Debug | Release | rel. | Debug v1.1 | Release v1.1 | rel. -|-|-|-|-|-|- Decimal | 0.427s | 0.417s | -2% | 0.427s | 0.417s | -3% Decimal64 | 0.543s | 0.102s | -81% | 0.521s | 0.078s | -85% DecimalFP64 | 0.784s | 0.101s | -87% | 0.481s | 0.079s | -84% DecimalFP64 (generic) | 0.850s | 0.151s | -82% | 0.529s | 0.110s | -79% Double | 0.100s | 0.094s | -5% | 0.102s | 0.095s | -9% Double (generic) | 0.137s | 0.124s | -8% | 0.137s | 0.125s | -10%

Key findings v1.0:

• The debug performance didn't look very promising, but llvm can optimize this code very well.
• The difference between the two new implementations is negligible.
• There is a very bad performance penalty if someone tries to use numbers in a generic way. (i.e. protocol witness overhead) Update After discussion on https://forums.swift.org/t/performance-overhead-for-protocols/27104 Joe Groff opened https://bugs.swift.org/browse/SR-11158 (i.e. rdar://problem/53285593)
• The own implementation is just 5% slower than the builtin Double (which is unsuitable for most currency calculations)

Key findings v1.1:

• I have never heard of TextOutputStreamable before. (Thanks Brent!) This is a tremendous performance benefit.
• DecimalFP64 and Decimal64 are now faster than Double. They need 18% less time to complete the benchmark test.
• The performance difference to Decimal is even higher: The benchmark test is completed in 1/5th of the time.

Performance Update for Apple M1 Chip

I've done some more testing with my new MacBook Air M1 (8GPU, 16GB, 512GB). All test with Big Sur (11.0.1) (exception MacBook Air with 1.6GHz i5 is on 11.1) and Xcode 12.2.

Update: Some more tests with a Mac Studio M1 Max running Ventura 13.2.1 with Xcode 14.2

All times in seconds for 100 tests.

Number Type | MBA x86 Deb | MBA x86 Rel | iMac x86 Deb | iMac x86 Rel | MBA M1 Deb | MBA M1 Rel | Studio Max Deb | Studio Max Rel -|-|-|-|-|-|-|-|- Decimal | 7.308 | 6.635 | 5.535 | 4.795 | 4.121 | 3.737 | 3.237 | 2.847 Decimal64 | 34.237 | 1.578 | 25.237 | 1.212 | 16.965 | 0.890 | 4.752 | 0.509 DecimalFP64 | 23.192 | 1.594 | 15.753 | 1.217 | 10.476 | 0.911 | 3.404 | 0.512 DecimalFP64 (generic) | 23.139 | 2.261 | 16.467 | 1.713 | 11.005 | 1.226 | 3.823 | 0.790 Double | 2.567 | 1.640 | 1.697 | 1.193 | 1.227 | 0.885 | 0.614 | 0.365 Double (generic) | 3.521 | 2.256 | 2.273 | 1.684 | 1.589 | 1.203 | 0.997 | 0.700

Performance Update for Apple M4 Pro Chip

I've done some more testing with my new MacBookPro M4Pro (12CPU (8+4), 16GPU, 24GB, 512GB). All test with Sequioa (15.1) and Xcode 16.1

All times in seconds for 100 tests. Only release mode shown in table.

Number Type | MBA M1 | MS M1Max | MBP M4Pro -|-|-|- Decimal | n/a | n/a | n/a Decimal64 | 0.488 | 0.496 | 0.258 DecimalFP64 | 0.483 | 0.485 | 0.253 DecimalFP64 (generic) | 0.811 | 0.814 | 0.461 Double | 0.356 | 0.356 | 0.248 Double (generic) | 0.737 | 0.736 | 0.461

Interesting note: M1 and M1 Max are nearly identical for single core applications (as expected). The M4 Pro is twice as fast for integer calculations but only 1.5 times faster for FPU calculations.