Roy Crihfield
00141776bf
* Refactors to replace most of the code with the statediff plugin. * Adds basic CI test workflows for Gitea * Refactors fixtures to use https://git.vdb.to/cerc-io/eth-testing * Renames env vars for consistency with flags and other services: - LOGRUS_{LEVEL,FILE} => LOG_LEVEL, etc. - LVL_DB_PATH => LEVELDB_PATH - ANCIENT_DB_PATH => LEVELDB_ANCIENT - These will need to be updated wherever they are used Reviewed-on: #1
77 lines
2.1 KiB
Go
77 lines
2.1 KiB
Go
package snapshot
|
|
|
|
import (
|
|
"bytes"
|
|
)
|
|
|
|
// Estimate the number of iterations necessary to step from start to end.
|
|
func estimateSteps(start []byte, end []byte, depth int) uint64 {
|
|
// We see paths in several forms (nil, 0600, 06, etc.). We need to adjust them to a comparable form.
|
|
// For nil, start and end indicate the extremes of 0x0 and 0x10. For differences in depth, we often see a
|
|
// start/end range on a bounded iterator specified like 0500:0600, while the value returned by it.Path() may
|
|
// be shorter, like 06. Since our goal is to estimate how many steps it would take to move from start to end,
|
|
// we want to perform the comparison at a stable depth, since to move from 05 to 06 is only 1 step, but
|
|
// to move from 0500:06 is 16.
|
|
normalizePathRange := func(start []byte, end []byte, depth int) ([]byte, []byte) {
|
|
if 0 == len(start) {
|
|
start = []byte{0x0}
|
|
}
|
|
if 0 == len(end) {
|
|
end = []byte{0x10}
|
|
}
|
|
normalizedStart := make([]byte, depth)
|
|
normalizedEnd := make([]byte, depth)
|
|
for i := 0; i < depth; i++ {
|
|
if i < len(start) {
|
|
normalizedStart[i] = start[i]
|
|
}
|
|
if i < len(end) {
|
|
normalizedEnd[i] = end[i]
|
|
}
|
|
}
|
|
return normalizedStart, normalizedEnd
|
|
}
|
|
|
|
// We have no need to handle negative exponents, so uints are fine.
|
|
pow := func(x uint64, y uint) uint64 {
|
|
if 0 == y {
|
|
return 1
|
|
}
|
|
ret := x
|
|
for i := uint(0); i < y; i++ {
|
|
ret *= x
|
|
}
|
|
return x
|
|
}
|
|
|
|
// Fix the paths.
|
|
start, end = normalizePathRange(start, end, depth)
|
|
|
|
// No negative distances, if the start is already >= end, the distance is 0.
|
|
if bytes.Compare(start, end) >= 0 {
|
|
return 0
|
|
}
|
|
|
|
// Subtract each component, right to left, carrying over if necessary.
|
|
difference := make([]byte, len(start))
|
|
var carry byte = 0
|
|
for i := len(start) - 1; i >= 0; i-- {
|
|
result := end[i] - start[i] - carry
|
|
if result > 0xf && i > 0 {
|
|
result &= 0xf
|
|
carry = 1
|
|
} else {
|
|
carry = 0
|
|
}
|
|
difference[i] = result
|
|
}
|
|
|
|
// Calculate the result.
|
|
var ret uint64 = 0
|
|
for i := 0; i < len(difference); i++ {
|
|
ret += uint64(difference[i]) * pow(16, uint(len(difference)-i-1))
|
|
}
|
|
|
|
return ret
|
|
}
|