Skip to content

BigDec operation speedups #8006

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
ValarDragon merged 10 commits into from
Apr 11, 2024
Merged

BigDec operation speedups #8006

Show file tree
Hide file tree
Changes from 9 commits
Commits
Show all changes
10 commits
Select commit Hold shift + click to select a range
939fc9a
Rename precisionReuse and use squaredPrecisionReuse properly
ValarDragon Apr 10, 2024
1e44832
Remove redundant copies for chop operations
ValarDragon Apr 10, 2024
78800bd
Speedup RoundUpMut failed, just committing benchmark
ValarDragon Apr 10, 2024
5ea9e64
CL notes
ValarDragon Apr 10, 2024
6c727bd
Speedup Truncate routines by saving ~2 word sizes
ValarDragon Apr 10, 2024
75274eb
Add BigDec x Dec fns
ValarDragon Apr 10, 2024
dfe1b43
Minor approx root spedup
ValarDragon Apr 10, 2024
717447d
Driveby, better mut usage in stableswap
ValarDragon Apr 10, 2024
0ddea0b
Add AbsMut
ValarDragon Apr 10, 2024
47d4f52
Auto: update go.mod after push to dev/bigdec_speedups that modified d…
invalid-email-address Apr 10, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 2 additions & 0 deletions CHANGELOG.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -46,6 +46,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

### State Compatible

* [#8006](https://github.com/osmosis-labs/osmosis/pull/8006) Speedup many BigDec operations

## v24.0.1

* [#7994](https://github.com/osmosis-labs/osmosis/pull/7994) Async pruning for IAVL v1
Expand Down
183 changes: 133 additions & 50 deletions osmomath/decimal.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -37,15 +37,20 @@ const (
)

var (
precisionReuse = new(big.Int).Exp(big.NewInt(10), big.NewInt(BigDecPrecision), nil)
squaredPrecisionReuse = new(big.Int).Mul(precisionReuse, precisionReuse)
precisionReuseSDK = new(big.Int).Exp(big.NewInt(10), big.NewInt(DecPrecision), nil)
defaultBigDecPrecisionReuse = new(big.Int).Exp(big.NewInt(10), big.NewInt(BigDecPrecision), nil)
precisionReuseSDKDec = new(big.Int).Exp(big.NewInt(10), big.NewInt(DecPrecision), nil)

bigDecDecPrecision = new(big.Int).Mul(defaultBigDecPrecisionReuse, precisionReuseSDKDec)
squaredPrecisionReuse = new(big.Int).Mul(defaultBigDecPrecisionReuse, defaultBigDecPrecisionReuse)
bigDecDecPrecisionFactorDiff = new(big.Int).Exp(big.NewInt(10), big.NewInt(BigDecPrecision-DecPrecision), nil)
fivePrecision = new(big.Int).Quo(precisionReuse, big.NewInt(2))
precisionMultipliers []*big.Int
zeroInt = big.NewInt(0)
oneInt = big.NewInt(1)
tenInt = big.NewInt(10)

fivePrecision = new(big.Int).Quo(defaultBigDecPrecisionReuse, big.NewInt(2))
fivePrecisionSDKDec = new(big.Int).Quo(precisionReuseSDKDec, big.NewInt(2))

precisionMultipliers []*big.Int
zeroInt = big.NewInt(0)
oneInt = big.NewInt(1)
tenInt = big.NewInt(10)

// log_2(e)
// From: https://www.wolframalpha.com/input?i=log_2%28e%29+with+37+digits
Expand Down Expand Up @@ -88,7 +93,7 @@ func init() {
}

func precisionInt() *big.Int {
return new(big.Int).Set(precisionReuse)
return new(big.Int).Set(defaultBigDecPrecisionReuse)
}

func ZeroBigDec() BigDec { return BigDec{new(big.Int).Set(zeroInt)} }
Expand Down Expand Up @@ -256,7 +261,8 @@ func (d BigDec) LT(d2 BigDec) bool { return (d.i).Cmp(d2.i) < 0 } /
func (d BigDec) LTE(d2 BigDec) bool { return (d.i).Cmp(d2.i) <= 0 } // less than or equal
func (d BigDec) Neg() BigDec { return BigDec{new(big.Int).Neg(d.i)} } // reverse the decimal sign
// nolint: stylecheck
func (d BigDec) Abs() BigDec { return BigDec{new(big.Int).Abs(d.i)} } // absolute value
func (d BigDec) Abs() BigDec { return BigDec{new(big.Int).Abs(d.i)} } // absolute value
func (d BigDec) AbsMut() BigDec { d.i.Abs(d.i); return d } // absolute value

// BigInt returns a copy of the underlying big.Int.
func (d BigDec) BigInt() *big.Int {
Expand Down Expand Up @@ -297,7 +303,13 @@ func (d BigDec) AddMut(d2 BigDec) BigDec {

// subtraction
func (d BigDec) Sub(d2 BigDec) BigDec {
res := new(big.Int).Sub(d.i, d2.i)
copy := d.Clone()
copy.SubMut(d2)
return copy
}

func (d BigDec) SubMut(d2 BigDec) BigDec {
res := d.i.Sub(d.i, d2.i)

if res.BitLen() > maxDecBitLen {
panic("Int overflow")
Expand Down Expand Up @@ -338,10 +350,36 @@ func (d BigDec) MulMut(d2 BigDec) BigDec {
return BigDec{d.i}
}

func (d BigDec) MulDec(d2 Dec) BigDec {
copy := d.Clone()
copy.MulDecMut(d2)
return copy
}

func (d BigDec) MulDecMut(d2 Dec) BigDec {
d.i.Mul(d.i, d2.BigIntMut())
d.i = chopPrecisionAndRoundSdkDec(d.i)

if d.i.BitLen() > maxDecBitLen {
panic("Int overflow")
}
Comment on lines +363 to +365
Copy link
Copy Markdown
Member

@czarcas7ic czarcas7ic Apr 10, 2024

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

nit: this logic gets reused 5/6 times in this PR, maybe could be a single line helper.

Copy link
Copy Markdown
Member Author

@ValarDragon ValarDragon Apr 11, 2024

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Lets do that in a second PR, agreed tho

return BigDec{d.i}
}

// multiplication truncate
func (d BigDec) MulTruncate(d2 BigDec) BigDec {
mul := new(big.Int).Mul(d.i, d2.i)
chopped := chopPrecisionAndTruncate(mul)
chopped := chopPrecisionAndTruncateMut(mul, defaultBigDecPrecisionReuse)

if chopped.BitLen() > maxDecBitLen {
panic("Int overflow")
}
return BigDec{chopped}
}

func (d BigDec) MulTruncateDec(d2 Dec) BigDec {
mul := new(big.Int).Mul(d.i, d2.BigIntMut())
chopped := chopPrecisionAndTruncateMut(mul, precisionReuseSDKDec)

if chopped.BitLen() > maxDecBitLen {
panic("Int overflow")
Expand All @@ -352,7 +390,7 @@ func (d BigDec) MulTruncate(d2 BigDec) BigDec {
// multiplication round up
func (d BigDec) MulRoundUp(d2 BigDec) BigDec {
mul := new(big.Int).Mul(d.i, d2.i)
chopped := chopPrecisionAndRoundUpBigDec(mul)
chopped := chopPrecisionAndRoundUpMut(mul, defaultBigDecPrecisionReuse)

if chopped.BitLen() > maxDecBitLen {
panic("Int overflow")
Expand Down Expand Up @@ -391,8 +429,7 @@ func (d BigDec) Quo(d2 BigDec) BigDec {
// mutative quotient
func (d BigDec) QuoMut(d2 BigDec) BigDec {
// multiply precision twice
d.i.Mul(d.i, precisionReuse)
d.i.Mul(d.i, precisionReuse)
d.i.Mul(d.i, squaredPrecisionReuse)

d.i.Quo(d.i, d2.i)
chopPrecisionAndRound(d.i)
Expand All @@ -404,7 +441,7 @@ func (d BigDec) QuoMut(d2 BigDec) BigDec {
}
func (d BigDec) QuoRaw(d2 int64) BigDec {
// multiply precision, so we can chop it later
mul := new(big.Int).Mul(d.i, precisionReuse)
mul := new(big.Int).Mul(d.i, defaultBigDecPrecisionReuse)

quo := mul.Quo(mul, big.NewInt(d2))
chopped := chopPrecisionAndRound(quo)
Expand All @@ -418,25 +455,45 @@ func (d BigDec) QuoRaw(d2 int64) BigDec {
// quotient truncate
func (d BigDec) QuoTruncate(d2 BigDec) BigDec {
// multiply precision twice
mul := new(big.Int).Mul(d.i, precisionReuse)
mul.Mul(mul, precisionReuse)

mul := new(big.Int).Mul(d.i, defaultBigDecPrecisionReuse)
quo := mul.Quo(mul, d2.i)
chopped := chopPrecisionAndTruncate(quo)

if chopped.BitLen() > maxDecBitLen {
if quo.BitLen() > maxDecBitLen {
panic("Int overflow")
}
return BigDec{chopped}
return BigDec{quo}
}

// quotient truncate (mutative)
func (d BigDec) QuoTruncateMut(d2 BigDec) BigDec {
// multiply precision twice
d.i.Mul(d.i, squaredPrecisionReuse)
// multiply bigDec precision
d.i.Mul(d.i, defaultBigDecPrecisionReuse)
d.i.Quo(d.i, d2.i)

chopPrecisionAndTruncateMut(d.i)
if d.i.BitLen() > maxDecBitLen {
panic("Int overflow")
}
return d
}

// quotient truncate
func (d BigDec) QuoTruncateDec(d2 Dec) BigDec {
// multiply Dec Precision
mul := new(big.Int).Mul(d.i, precisionReuseSDKDec)
quo := mul.Quo(mul, d2.BigIntMut())

if quo.BitLen() > maxDecBitLen {
panic("Int overflow")
}
return BigDec{quo}
}

// quotient truncate (mutative)
func (d BigDec) QuoTruncateDecMut(d2 Dec) BigDec {
// multiply Dec Precision
d.i.Mul(d.i, precisionReuseSDKDec)
d.i.Quo(d.i, d2.BigIntMut())

if d.i.BitLen() > maxDecBitLen {
panic("Int overflow")
}
Expand All @@ -446,11 +503,10 @@ func (d BigDec) QuoTruncateMut(d2 BigDec) BigDec {
// quotient, round up
func (d BigDec) QuoRoundUp(d2 BigDec) BigDec {
// multiply precision twice
mul := new(big.Int).Mul(d.i, precisionReuse)
mul.Mul(mul, precisionReuse)
mul := new(big.Int).Mul(d.i, squaredPrecisionReuse)

quo := new(big.Int).Quo(mul, d2.i)
chopped := chopPrecisionAndRoundUpBigDec(quo)
quo := mul.Quo(mul, d2.i)
chopped := chopPrecisionAndRoundUpMut(quo, defaultBigDecPrecisionReuse)

if chopped.BitLen() > maxDecBitLen {
panic("Int overflow")
Expand All @@ -464,7 +520,7 @@ func (d BigDec) QuoRoundUpMut(d2 BigDec) BigDec {
d.i.Mul(d.i, squaredPrecisionReuse)
d.i.Quo(d.i, d2.i)

chopPrecisionAndRoundUpMut(d.i, precisionReuse)
chopPrecisionAndRoundUpMut(d.i, defaultBigDecPrecisionReuse)

if d.i.BitLen() > maxDecBitLen {
panic("Int overflow")
Expand Down Expand Up @@ -506,7 +562,7 @@ func (d BigDec) ApproxRoot(root uint64) (guess BigDec, err error) {
return absRoot.MulInt64(-1), err
}

if root == 1 || d.IsZero() || d.Equal(OneBigDec()) {
if root == 1 || d.IsZero() || d.Equal(oneBigDec) {
return d, nil
}

Expand All @@ -523,7 +579,7 @@ func (d BigDec) ApproxRoot(root uint64) (guess BigDec, err error) {
prev = SmallestBigDec()
}
delta = d.Quo(prev)
delta = delta.Sub(guess)
delta.SubMut(guess)
delta = delta.QuoInt(rootInt)

guess = guess.Add(delta)
Expand All @@ -534,13 +590,14 @@ func (d BigDec) ApproxRoot(root uint64) (guess BigDec, err error) {

// ApproxSqrt is a wrapper around ApproxRoot for the common special case
// of finding the square root of a number. It returns -(sqrt(abs(d)) if input is negative.
// TODO: Optimize this to be faster just using native big int sqrt.
func (d BigDec) ApproxSqrt() (BigDec, error) {
return d.ApproxRoot(2)
}

// is integer, e.g. decimals are zero
func (d BigDec) IsInteger() bool {
return new(big.Int).Rem(d.i, precisionReuse).Sign() == 0
return new(big.Int).Rem(d.i, defaultBigDecPrecisionReuse).Sign() == 0
}

// format decimal state
Expand Down Expand Up @@ -746,7 +803,7 @@ func chopPrecisionAndRound(d *big.Int) *big.Int {

// get the truncated quotient and remainder
quo, rem := d, big.NewInt(0)
quo, rem = quo.QuoRem(d, precisionReuse, rem)
quo, rem = quo.QuoRem(d, defaultBigDecPrecisionReuse, rem)

if rem.Sign() == 0 { // remainder is zero
return quo
Expand All @@ -766,19 +823,44 @@ func chopPrecisionAndRound(d *big.Int) *big.Int {
}
}

// chopPrecisionAndRoundUpBigDec removes a Precision amount of rightmost digits and rounds up.
// Non-mutative.
func chopPrecisionAndRoundUpBigDec(d *big.Int) *big.Int {
// make copy
copy := new(big.Int).Set(d)
return chopPrecisionAndRoundUpMut(copy, precisionReuse)
// TODO: Abstract code
func chopPrecisionAndRoundSdkDec(d *big.Int) *big.Int {
// remove the negative and add it back when returning
if d.Sign() == -1 {
// make d positive, compute chopped value, and then un-mutate d
d = d.Neg(d)
d = chopPrecisionAndRoundSdkDec(d)
d = d.Neg(d)
return d
}

// get the truncated quotient and remainder
quo, rem := d, big.NewInt(0)
quo, rem = quo.QuoRem(d, precisionReuseSDKDec, rem)

if rem.Sign() == 0 { // remainder is zero
return quo
}

switch rem.Cmp(fivePrecisionSDKDec) {
case -1:
return quo
case 1:
return quo.Add(quo, oneInt)
default: // bankers rounding must take place
// always round to an even number
if quo.Bit(0) == 0 {
return quo
}
return quo.Add(quo, oneInt)
}
}

// chopPrecisionAndRoundUpDec removes DecPrecision amount of rightmost digits and rounds up.
// chopPrecisionAndRoundUpDec removes DecPrecision amount of rightmost digits and rounds up.
// Non-mutative.
func chopPrecisionAndRoundUpDec(d *big.Int) *big.Int {
copy := new(big.Int).Set(d)
return chopPrecisionAndRoundUpMut(copy, precisionReuseSDK)
return chopPrecisionAndRoundUpMut(copy, precisionReuseSDKDec)
}

// chopPrecisionAndRoundUp removes a Precision amount of rightmost digits and rounds up.
Expand All @@ -792,7 +874,7 @@ func chopPrecisionAndRoundUpMut(d *big.Int, precisionReuse *big.Int) *big.Int {
// make d positive, compute chopped value, and then un-mutate d
d = d.Neg(d)
// truncate since d is negative...
d = chopPrecisionAndTruncateMut(d)
d = chopPrecisionAndTruncateMut(d, precisionReuse)
d = d.Neg(d)
return d
}
Expand Down Expand Up @@ -828,19 +910,19 @@ func (d BigDec) RoundInt() BigInt {

// chopPrecisionAndTruncate is similar to chopPrecisionAndRound,
// but always rounds down. It does not mutate the input.
func chopPrecisionAndTruncate(d *big.Int) *big.Int {
func chopPrecisionAndTruncate(d *big.Int, precisionReuse *big.Int) *big.Int {
return new(big.Int).Quo(d, precisionReuse)
}

// chopPrecisionAndTruncate is similar to chopPrecisionAndRound,
// but always rounds down. It mutates the input.
func chopPrecisionAndTruncateMut(d *big.Int) *big.Int {
func chopPrecisionAndTruncateMut(d, precisionReuse *big.Int) *big.Int {
return d.Quo(d, precisionReuse)
}

// TruncateInt64 truncates the decimals from the number and returns an int64
func (d BigDec) TruncateInt64() int64 {
chopped := chopPrecisionAndTruncate(d.i)
chopped := chopPrecisionAndTruncate(d.i, defaultBigDecPrecisionReuse)
if !chopped.IsInt64() {
panic("Int64() out of bound")
}
Expand All @@ -849,12 +931,12 @@ func (d BigDec) TruncateInt64() int64 {

// TruncateInt truncates the decimals from the number and returns an Int
func (d BigDec) TruncateInt() BigInt {
return NewBigIntFromBigInt(chopPrecisionAndTruncate(d.i))
return NewBigIntFromBigInt(chopPrecisionAndTruncate(d.i, defaultBigDecPrecisionReuse))
}

// TruncateDec truncates the decimals from the number and returns a Dec
func (d BigDec) TruncateDec() BigDec {
return NewBigDecFromBigInt(chopPrecisionAndTruncate(d.i))
return NewBigDecFromBigInt(chopPrecisionAndTruncate(d.i, defaultBigDecPrecisionReuse))
}

// Ceil returns the smallest integer value (as a decimal) that is greater than
Expand All @@ -866,7 +948,7 @@ func (d BigDec) Ceil() BigDec {

func (d BigDec) CeilMut() BigDec {
quo, rem := d.i, big.NewInt(0)
quo, rem = quo.QuoRem(quo, precisionReuse, rem)
quo, rem = quo.QuoRem(quo, defaultBigDecPrecisionReuse, rem)

// no need to round with a zero remainder regardless of sign
if rem.Sign() <= 0 {
Expand Down Expand Up @@ -1197,6 +1279,7 @@ func (d BigDec) Power(power BigDec) BigDec {
if power.Abs().GT(maxSupportedExponent) {
panic(fmt.Sprintf("integer exponent %s is too large, max (%s)", power, maxSupportedExponent))
}
// TODO: Potentially expensive??
if power.IsInteger() {
return d.PowerInteger(power.TruncateInt().Uint64())
}
Expand All @@ -1206,7 +1289,7 @@ func (d BigDec) Power(power BigDec) BigDec {
if d.IsZero() {
return ZeroBigDec()
}
if d.LT(OneBigDec()) {
if d.LT(oneBigDec) {
panic(fmt.Sprintf("Power() is not supported for base < 1, base was (%s)", d))
}
if d.Equal(twoBigDec) {
Expand Down
Loading