Faster and cached square root

[potuz]

This PR adds a different method to compute the integer square root of a number. It first uses a simple mutex and a cache for the last computation done. If there is a cache miss, then it uses simple Newton approximation to find the new square root.

Rationale:

Square roots of total balances are computed when computing

• AttestationsDeltas in the epoch precompute.
• When computing the base reward per increment (this is used when computing several rewards)

In all cases we pass the total effective balance of validators that were active in the current epoch. This number stays constant throughout the epoch and changes slowly, by multiples of 10**9 Gwei, on epoch transitions.

This makes us believe that a single value cache is already good enough to avoid this computation on block processing, as the effective balance will not change intra-epoch. And In case of a cache miss, we can start a Newton approximation with the latest cached value that is guaranteed to be close to the actual value.

Possible improvemnents:

• We could use a map with 2 or three cached values given that in some places we use only balances that have participated in the current or previous epoch (for attestation rewards for example) and in others we use the full active balance.
• We could improve the Newton approximation by using the fact that balances only change in multiples of 1ETH instead of arbitrary integer numbers. We felt the complication of this would give us very little gain

Some Benchmarks

Below there are some benchmarks on a AMD Ryzen 5 3600. On computing raw square roots for over 52 bits our method is about x2.3 faster, that is comparable with Golang's square root computation for numbers under 52 bits.

-----------------------------------------------------------------------------
goos: linux
goarch: amd64
cpu: AMD Ryzen 5 3600 6-Core Processor
BenchmarkIntegerSquareRootBelow52Bits-12       	34503249	        59.55 ns/op
BenchmarkIntegerSquareRootAbove52Bits-12       	11731746	        97.91 ns/op
BenchmarkSquareRootEffectiveBalance-12         	35858377	        46.14 ns/op
BenchmarkSquareRootBabylonian-12               	41247252	        27.98 ns/op
BenchmarkSquareRootOldWay-12                   	21897693	        55.02 ns/op
BenchmarkIntegerSquareRoot_WithDatatable-12    	85549964	        14.38 ns/op
PASS

[terencechain]

Qustion on general usages for this function. Is this only intended for EffectiveBalance, if yes then we should move the function to a better location not general math helper

If it's not only intended for EffectiveBalance such that it could be applied to other usages, we can rename this function to SquareRootCached or something else

[potuz]

Depending on the size of the cache it can be used for everything, I could move the cache to a map.

[terencechain]

Looking at this function again, given it's just a single value, it might be best to move (hide) it to core pkg because we don't want to share it among others. Imagine Alice joins the team tomorrow and start using SquareRootEffectiveBalance for something less relevant

[potuz]

Tested that the function returns the same value as our previous method for balances between 700K validators and 5 million validators.