Decimal benchmark

Today I will show you a simple benchmark between 2 library from previous post. Duel between https://github.com/shopspring/decimal with https://github.com/mercari/go-bps. The API of both library is similar in calculation but totally different with initialization, get amount, and conversion to string API.

In this benchmark I only compare simple calculation and string conversion.

Simple add calculation

helper function

func decimalAdd(addition decimal.Decimal, n int) decimal.Decimal {
	result := decimal.NewFromInt(0)
	for i := 0; i < n; i++ {
		result = result.Add(addition)
	}
	return result
}
func bpsAdd(addition *bps.BPS, n int) *bps.BPS {
	result := bps.NewFromAmount(0)
	for i := 0; i < n; i++ {
		result = result.Add(addition)
	}
	return result
}

Benchmark with 0.01 and 0.0000001 addition

func BenchmarkShopspring001DecimalAdd(b *testing.B) {
	addition := decimal.NewFromFloat(0.01)
	for n := 0; n < b.N; n++ {
		b.StopTimer()
		b.StartTimer()
		decimalAdd(addition, n)
	}
}
func BenchmarkShopspringPPMDecimalAdd(b *testing.B) {
	addition := decimal.NewFromFloat(0.000001)
	for n := 0; n < b.N; n++ {
		b.StopTimer()
		b.StartTimer()
		decimalAdd(addition, n)
	}
}
func BenchmarkShopspring1000DecimalAdd(b *testing.B) {
	addition := decimal.NewFromFloat(0.000001)
	for n := 0; n < b.N; n++ {
		b.StopTimer()
		b.StartTimer()
		decimalAdd(addition, 1000)
	}
}
func BenchmarkMercari001BpsAdd(b *testing.B) {
	addition := bps.NewFromPercentage(1)
	for n := 0; n < b.N; n++ {
		b.StopTimer()
		b.StartTimer()
		bpsAdd(addition, n)
	}
}
func BenchmarkMercariPPMBpsAdd(b *testing.B) {
	addition := bps.NewFromPPM(big.NewInt(1))
	for n := 0; n < b.N; n++ {
		b.StopTimer()
		b.StartTimer()
		bpsAdd(addition, n)
	}
}
func BenchmarkMercari1000BpsAdd(b *testing.B) {
	addition := bps.NewFromPercentage(1)
	for n := 0; n < b.N; n++ {
		b.StopTimer()
		b.StartTimer()
		bpsAdd(addition, 1000)
	}
}

Conversion to string

func BenchmarkShopspringStringDecimalConvert(b *testing.B) {
	value := decimal.NewFromFloat(0.000001)
	for n := 0; n < b.N; n++ {
		b.StopTimer()
		b.StartTimer()
		value.StringFixed(10)
	}
}
func BenchmarkMercariStringBpsConvert(b *testing.B) {
	value := bps.NewFromPPM(big.NewInt(1))
	for n := 0; n < b.N; n++ {
		b.StopTimer()
		b.StartTimer()
		value.FloatString(10)
	}
}

Result

Running tool: /home/linuxbrew/.linuxbrew/bin/go test -benchmem -run=^$ -bench ^(BenchmarkShopspring001DecimalAdd|BenchmarkShopspringPPMDecimalAdd|BenchmarkMercari001BpsAdd|BenchmarkMercariPPMBpsAdd|BenchmarkShopspringStringDecimalConvert|BenchmarkMercariStringBpsConvert)$ github.com/h4ckm03d/golang-playground/6-practical-benchmark
goos: linux
goarch: amd64
pkg: github.com/h4ckm03d/golang-playground/6-practical-benchmark
cpu: Intel(R) Core(TM) i5-7500 CPU @ 3.40GHz
BenchmarkShopspring001DecimalAdd-4          	   10000	    389385 ns/op	  400041 B/op	   10003 allocs/op
BenchmarkShopspringPPMDecimalAdd-4          	   10000	    380516 ns/op	  400088 B/op	   10004 allocs/op
BenchmarkMercari001BpsAdd-4                 	   10000	   1267632 ns/op	  879983 B/op	   40000 allocs/op
BenchmarkMercariPPMBpsAdd-4                 	   10000	   1300074 ns/op	  879983 B/op	   40000 allocs/op
BenchmarkShopspringStringDecimalConvert-4   	 1000000	      1026 ns/op	     240 B/op	      12 allocs/op
BenchmarkMercariStringBpsConvert-4          	  935912	      1164 ns/op	     320 B/op	      16 allocs/op
PASS
ok  	github.com/h4ckm03d/golang-playground/6-practical-benchmark	63.276s

The result of calculation above show the shopspring/decimal is faster and memory allocation is smaller compare to mercari/go-bps. But the string conversion of result is pretty similar compared to the calculation result and the winner still shopspring/decimal.

So the winner is shopspring/decimal and I think both of them is still fast because the slowest operation takes 1267632ns ~ 1.267632ms ~ 0.001267632 seconds. The choice is yours now, which one do you prefer?

Check complete codes in the https://github.com/h4ckm03d/golang-playground/blob/master/6-practical-benchmark/decimal_test.go