github.com/matthieu/go-ethereum@v1.13.2/core/state/snapshot/difflayer.go (about) 1 // Copyright 2019 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package snapshot 18 19 import ( 20 "encoding/binary" 21 "fmt" 22 "math" 23 "math/rand" 24 "sort" 25 "sync" 26 "sync/atomic" 27 "time" 28 29 "github.com/matthieu/go-ethereum/common" 30 "github.com/matthieu/go-ethereum/rlp" 31 "github.com/steakknife/bloomfilter" 32 ) 33 34 var ( 35 // aggregatorMemoryLimit is the maximum size of the bottom-most diff layer 36 // that aggregates the writes from above until it's flushed into the disk 37 // layer. 38 // 39 // Note, bumping this up might drastically increase the size of the bloom 40 // filters that's stored in every diff layer. Don't do that without fully 41 // understanding all the implications. 42 aggregatorMemoryLimit = uint64(4 * 1024 * 1024) 43 44 // aggregatorItemLimit is an approximate number of items that will end up 45 // in the agregator layer before it's flushed out to disk. A plain account 46 // weighs around 14B (+hash), a storage slot 32B (+hash), a deleted slot 47 // 0B (+hash). Slots are mostly set/unset in lockstep, so thet average at 48 // 16B (+hash). All in all, the average entry seems to be 15+32=47B. Use a 49 // smaller number to be on the safe side. 50 aggregatorItemLimit = aggregatorMemoryLimit / 42 51 52 // bloomTargetError is the target false positive rate when the aggregator 53 // layer is at its fullest. The actual value will probably move around up 54 // and down from this number, it's mostly a ballpark figure. 55 // 56 // Note, dropping this down might drastically increase the size of the bloom 57 // filters that's stored in every diff layer. Don't do that without fully 58 // understanding all the implications. 59 bloomTargetError = 0.02 60 61 // bloomSize is the ideal bloom filter size given the maximum number of items 62 // it's expected to hold and the target false positive error rate. 63 bloomSize = math.Ceil(float64(aggregatorItemLimit) * math.Log(bloomTargetError) / math.Log(1/math.Pow(2, math.Log(2)))) 64 65 // bloomFuncs is the ideal number of bits a single entry should set in the 66 // bloom filter to keep its size to a minimum (given it's size and maximum 67 // entry count). 68 bloomFuncs = math.Round((bloomSize / float64(aggregatorItemLimit)) * math.Log(2)) 69 70 // the bloom offsets are runtime constants which determines which part of the 71 // the account/storage hash the hasher functions looks at, to determine the 72 // bloom key for an account/slot. This is randomized at init(), so that the 73 // global population of nodes do not all display the exact same behaviour with 74 // regards to bloom content 75 bloomDestructHasherOffset = 0 76 bloomAccountHasherOffset = 0 77 bloomStorageHasherOffset = 0 78 ) 79 80 func init() { 81 // Init the bloom offsets in the range [0:24] (requires 8 bytes) 82 bloomDestructHasherOffset = rand.Intn(25) 83 bloomAccountHasherOffset = rand.Intn(25) 84 bloomStorageHasherOffset = rand.Intn(25) 85 86 // The destruct and account blooms must be different, as the storage slots 87 // will check for destruction too for every bloom miss. It should not collide 88 // with modified accounts. 89 for bloomAccountHasherOffset == bloomDestructHasherOffset { 90 bloomAccountHasherOffset = rand.Intn(25) 91 } 92 } 93 94 // diffLayer represents a collection of modifications made to a state snapshot 95 // after running a block on top. It contains one sorted list for the account trie 96 // and one-one list for each storage tries. 97 // 98 // The goal of a diff layer is to act as a journal, tracking recent modifications 99 // made to the state, that have not yet graduated into a semi-immutable state. 100 type diffLayer struct { 101 origin *diskLayer // Base disk layer to directly use on bloom misses 102 parent snapshot // Parent snapshot modified by this one, never nil 103 memory uint64 // Approximate guess as to how much memory we use 104 105 root common.Hash // Root hash to which this snapshot diff belongs to 106 stale uint32 // Signals that the layer became stale (state progressed) 107 108 // destructSet is a very special helper marker. If an account is marked as 109 // deleted, then it's recorded in this set. However it's allowed that an account 110 // is included here but still available in other sets(e.g. storageData). The 111 // reason is the diff layer includes all the changes in a *block*. It can 112 // happen that in the tx_1, account A is self-destructed while in the tx_2 113 // it's recreated. But we still need this marker to indicate the "old" A is 114 // deleted, all data in other set belongs to the "new" A. 115 destructSet map[common.Hash]struct{} // Keyed markers for deleted (and potentially) recreated accounts 116 accountList []common.Hash // List of account for iteration. If it exists, it's sorted, otherwise it's nil 117 accountData map[common.Hash][]byte // Keyed accounts for direct retrival (nil means deleted) 118 storageList map[common.Hash][]common.Hash // List of storage slots for iterated retrievals, one per account. Any existing lists are sorted if non-nil 119 storageData map[common.Hash]map[common.Hash][]byte // Keyed storage slots for direct retrival. one per account (nil means deleted) 120 121 diffed *bloomfilter.Filter // Bloom filter tracking all the diffed items up to the disk layer 122 123 lock sync.RWMutex 124 } 125 126 // destructBloomHasher is a wrapper around a common.Hash to satisfy the interface 127 // API requirements of the bloom library used. It's used to convert a destruct 128 // event into a 64 bit mini hash. 129 type destructBloomHasher common.Hash 130 131 func (h destructBloomHasher) Write(p []byte) (n int, err error) { panic("not implemented") } 132 func (h destructBloomHasher) Sum(b []byte) []byte { panic("not implemented") } 133 func (h destructBloomHasher) Reset() { panic("not implemented") } 134 func (h destructBloomHasher) BlockSize() int { panic("not implemented") } 135 func (h destructBloomHasher) Size() int { return 8 } 136 func (h destructBloomHasher) Sum64() uint64 { 137 return binary.BigEndian.Uint64(h[bloomDestructHasherOffset : bloomDestructHasherOffset+8]) 138 } 139 140 // accountBloomHasher is a wrapper around a common.Hash to satisfy the interface 141 // API requirements of the bloom library used. It's used to convert an account 142 // hash into a 64 bit mini hash. 143 type accountBloomHasher common.Hash 144 145 func (h accountBloomHasher) Write(p []byte) (n int, err error) { panic("not implemented") } 146 func (h accountBloomHasher) Sum(b []byte) []byte { panic("not implemented") } 147 func (h accountBloomHasher) Reset() { panic("not implemented") } 148 func (h accountBloomHasher) BlockSize() int { panic("not implemented") } 149 func (h accountBloomHasher) Size() int { return 8 } 150 func (h accountBloomHasher) Sum64() uint64 { 151 return binary.BigEndian.Uint64(h[bloomAccountHasherOffset : bloomAccountHasherOffset+8]) 152 } 153 154 // storageBloomHasher is a wrapper around a [2]common.Hash to satisfy the interface 155 // API requirements of the bloom library used. It's used to convert an account 156 // hash into a 64 bit mini hash. 157 type storageBloomHasher [2]common.Hash 158 159 func (h storageBloomHasher) Write(p []byte) (n int, err error) { panic("not implemented") } 160 func (h storageBloomHasher) Sum(b []byte) []byte { panic("not implemented") } 161 func (h storageBloomHasher) Reset() { panic("not implemented") } 162 func (h storageBloomHasher) BlockSize() int { panic("not implemented") } 163 func (h storageBloomHasher) Size() int { return 8 } 164 func (h storageBloomHasher) Sum64() uint64 { 165 return binary.BigEndian.Uint64(h[0][bloomStorageHasherOffset:bloomStorageHasherOffset+8]) ^ 166 binary.BigEndian.Uint64(h[1][bloomStorageHasherOffset:bloomStorageHasherOffset+8]) 167 } 168 169 // newDiffLayer creates a new diff on top of an existing snapshot, whether that's a low 170 // level persistent database or a hierarchical diff already. 171 func newDiffLayer(parent snapshot, root common.Hash, destructs map[common.Hash]struct{}, accounts map[common.Hash][]byte, storage map[common.Hash]map[common.Hash][]byte) *diffLayer { 172 // Create the new layer with some pre-allocated data segments 173 dl := &diffLayer{ 174 parent: parent, 175 root: root, 176 destructSet: destructs, 177 accountData: accounts, 178 storageData: storage, 179 storageList: make(map[common.Hash][]common.Hash), 180 } 181 switch parent := parent.(type) { 182 case *diskLayer: 183 dl.rebloom(parent) 184 case *diffLayer: 185 dl.rebloom(parent.origin) 186 default: 187 panic("unknown parent type") 188 } 189 // Sanity check that accounts or storage slots are never nil 190 for accountHash, blob := range accounts { 191 if blob == nil { 192 panic(fmt.Sprintf("account %#x nil", accountHash)) 193 } 194 } 195 for accountHash, slots := range storage { 196 if slots == nil { 197 panic(fmt.Sprintf("storage %#x nil", accountHash)) 198 } 199 } 200 // Determine memory size and track the dirty writes 201 for _, data := range accounts { 202 dl.memory += uint64(common.HashLength + len(data)) 203 snapshotDirtyAccountWriteMeter.Mark(int64(len(data))) 204 } 205 // Determine memory size and track the dirty writes 206 for _, slots := range storage { 207 for _, data := range slots { 208 dl.memory += uint64(common.HashLength + len(data)) 209 snapshotDirtyStorageWriteMeter.Mark(int64(len(data))) 210 } 211 } 212 dl.memory += uint64(len(destructs) * common.HashLength) 213 return dl 214 } 215 216 // rebloom discards the layer's current bloom and rebuilds it from scratch based 217 // on the parent's and the local diffs. 218 func (dl *diffLayer) rebloom(origin *diskLayer) { 219 dl.lock.Lock() 220 defer dl.lock.Unlock() 221 222 defer func(start time.Time) { 223 snapshotBloomIndexTimer.Update(time.Since(start)) 224 }(time.Now()) 225 226 // Inject the new origin that triggered the rebloom 227 dl.origin = origin 228 229 // Retrieve the parent bloom or create a fresh empty one 230 if parent, ok := dl.parent.(*diffLayer); ok { 231 parent.lock.RLock() 232 dl.diffed, _ = parent.diffed.Copy() 233 parent.lock.RUnlock() 234 } else { 235 dl.diffed, _ = bloomfilter.New(uint64(bloomSize), uint64(bloomFuncs)) 236 } 237 // Iterate over all the accounts and storage slots and index them 238 for hash := range dl.destructSet { 239 dl.diffed.Add(destructBloomHasher(hash)) 240 } 241 for hash := range dl.accountData { 242 dl.diffed.Add(accountBloomHasher(hash)) 243 } 244 for accountHash, slots := range dl.storageData { 245 for storageHash := range slots { 246 dl.diffed.Add(storageBloomHasher{accountHash, storageHash}) 247 } 248 } 249 // Calculate the current false positive rate and update the error rate meter. 250 // This is a bit cheating because subsequent layers will overwrite it, but it 251 // should be fine, we're only interested in ballpark figures. 252 k := float64(dl.diffed.K()) 253 n := float64(dl.diffed.N()) 254 m := float64(dl.diffed.M()) 255 snapshotBloomErrorGauge.Update(math.Pow(1.0-math.Exp((-k)*(n+0.5)/(m-1)), k)) 256 } 257 258 // Root returns the root hash for which this snapshot was made. 259 func (dl *diffLayer) Root() common.Hash { 260 return dl.root 261 } 262 263 // Parent returns the subsequent layer of a diff layer. 264 func (dl *diffLayer) Parent() snapshot { 265 return dl.parent 266 } 267 268 // Stale return whether this layer has become stale (was flattened across) or if 269 // it's still live. 270 func (dl *diffLayer) Stale() bool { 271 return atomic.LoadUint32(&dl.stale) != 0 272 } 273 274 // Account directly retrieves the account associated with a particular hash in 275 // the snapshot slim data format. 276 func (dl *diffLayer) Account(hash common.Hash) (*Account, error) { 277 data, err := dl.AccountRLP(hash) 278 if err != nil { 279 return nil, err 280 } 281 if len(data) == 0 { // can be both nil and []byte{} 282 return nil, nil 283 } 284 account := new(Account) 285 if err := rlp.DecodeBytes(data, account); err != nil { 286 panic(err) 287 } 288 return account, nil 289 } 290 291 // AccountRLP directly retrieves the account RLP associated with a particular 292 // hash in the snapshot slim data format. 293 // 294 // Note the returned account is not a copy, please don't modify it. 295 func (dl *diffLayer) AccountRLP(hash common.Hash) ([]byte, error) { 296 // Check the bloom filter first whether there's even a point in reaching into 297 // all the maps in all the layers below 298 dl.lock.RLock() 299 hit := dl.diffed.Contains(accountBloomHasher(hash)) 300 if !hit { 301 hit = dl.diffed.Contains(destructBloomHasher(hash)) 302 } 303 dl.lock.RUnlock() 304 305 // If the bloom filter misses, don't even bother with traversing the memory 306 // diff layers, reach straight into the bottom persistent disk layer 307 if !hit { 308 snapshotBloomAccountMissMeter.Mark(1) 309 return dl.origin.AccountRLP(hash) 310 } 311 // The bloom filter hit, start poking in the internal maps 312 return dl.accountRLP(hash, 0) 313 } 314 315 // accountRLP is an internal version of AccountRLP that skips the bloom filter 316 // checks and uses the internal maps to try and retrieve the data. It's meant 317 // to be used if a higher layer's bloom filter hit already. 318 func (dl *diffLayer) accountRLP(hash common.Hash, depth int) ([]byte, error) { 319 dl.lock.RLock() 320 defer dl.lock.RUnlock() 321 322 // If the layer was flattened into, consider it invalid (any live reference to 323 // the original should be marked as unusable). 324 if dl.Stale() { 325 return nil, ErrSnapshotStale 326 } 327 // If the account is known locally, return it 328 if data, ok := dl.accountData[hash]; ok { 329 snapshotDirtyAccountHitMeter.Mark(1) 330 snapshotDirtyAccountHitDepthHist.Update(int64(depth)) 331 snapshotDirtyAccountReadMeter.Mark(int64(len(data))) 332 snapshotBloomAccountTrueHitMeter.Mark(1) 333 return data, nil 334 } 335 // If the account is known locally, but deleted, return it 336 if _, ok := dl.destructSet[hash]; ok { 337 snapshotDirtyAccountHitMeter.Mark(1) 338 snapshotDirtyAccountHitDepthHist.Update(int64(depth)) 339 snapshotDirtyAccountInexMeter.Mark(1) 340 snapshotBloomAccountTrueHitMeter.Mark(1) 341 return nil, nil 342 } 343 // Account unknown to this diff, resolve from parent 344 if diff, ok := dl.parent.(*diffLayer); ok { 345 return diff.accountRLP(hash, depth+1) 346 } 347 // Failed to resolve through diff layers, mark a bloom error and use the disk 348 snapshotBloomAccountFalseHitMeter.Mark(1) 349 return dl.parent.AccountRLP(hash) 350 } 351 352 // Storage directly retrieves the storage data associated with a particular hash, 353 // within a particular account. If the slot is unknown to this diff, it's parent 354 // is consulted. 355 // 356 // Note the returned slot is not a copy, please don't modify it. 357 func (dl *diffLayer) Storage(accountHash, storageHash common.Hash) ([]byte, error) { 358 // Check the bloom filter first whether there's even a point in reaching into 359 // all the maps in all the layers below 360 dl.lock.RLock() 361 hit := dl.diffed.Contains(storageBloomHasher{accountHash, storageHash}) 362 if !hit { 363 hit = dl.diffed.Contains(destructBloomHasher(accountHash)) 364 } 365 dl.lock.RUnlock() 366 367 // If the bloom filter misses, don't even bother with traversing the memory 368 // diff layers, reach straight into the bottom persistent disk layer 369 if !hit { 370 snapshotBloomStorageMissMeter.Mark(1) 371 return dl.origin.Storage(accountHash, storageHash) 372 } 373 // The bloom filter hit, start poking in the internal maps 374 return dl.storage(accountHash, storageHash, 0) 375 } 376 377 // storage is an internal version of Storage that skips the bloom filter checks 378 // and uses the internal maps to try and retrieve the data. It's meant to be 379 // used if a higher layer's bloom filter hit already. 380 func (dl *diffLayer) storage(accountHash, storageHash common.Hash, depth int) ([]byte, error) { 381 dl.lock.RLock() 382 defer dl.lock.RUnlock() 383 384 // If the layer was flattened into, consider it invalid (any live reference to 385 // the original should be marked as unusable). 386 if dl.Stale() { 387 return nil, ErrSnapshotStale 388 } 389 // If the account is known locally, try to resolve the slot locally 390 if storage, ok := dl.storageData[accountHash]; ok { 391 if data, ok := storage[storageHash]; ok { 392 snapshotDirtyStorageHitMeter.Mark(1) 393 snapshotDirtyStorageHitDepthHist.Update(int64(depth)) 394 if n := len(data); n > 0 { 395 snapshotDirtyStorageReadMeter.Mark(int64(n)) 396 } else { 397 snapshotDirtyStorageInexMeter.Mark(1) 398 } 399 snapshotBloomStorageTrueHitMeter.Mark(1) 400 return data, nil 401 } 402 } 403 // If the account is known locally, but deleted, return an empty slot 404 if _, ok := dl.destructSet[accountHash]; ok { 405 snapshotDirtyStorageHitMeter.Mark(1) 406 snapshotDirtyStorageHitDepthHist.Update(int64(depth)) 407 snapshotDirtyStorageInexMeter.Mark(1) 408 snapshotBloomStorageTrueHitMeter.Mark(1) 409 return nil, nil 410 } 411 // Storage slot unknown to this diff, resolve from parent 412 if diff, ok := dl.parent.(*diffLayer); ok { 413 return diff.storage(accountHash, storageHash, depth+1) 414 } 415 // Failed to resolve through diff layers, mark a bloom error and use the disk 416 snapshotBloomStorageFalseHitMeter.Mark(1) 417 return dl.parent.Storage(accountHash, storageHash) 418 } 419 420 // Update creates a new layer on top of the existing snapshot diff tree with 421 // the specified data items. 422 func (dl *diffLayer) Update(blockRoot common.Hash, destructs map[common.Hash]struct{}, accounts map[common.Hash][]byte, storage map[common.Hash]map[common.Hash][]byte) *diffLayer { 423 return newDiffLayer(dl, blockRoot, destructs, accounts, storage) 424 } 425 426 // flatten pushes all data from this point downwards, flattening everything into 427 // a single diff at the bottom. Since usually the lowermost diff is the largest, 428 // the flattening builds up from there in reverse. 429 func (dl *diffLayer) flatten() snapshot { 430 // If the parent is not diff, we're the first in line, return unmodified 431 parent, ok := dl.parent.(*diffLayer) 432 if !ok { 433 return dl 434 } 435 // Parent is a diff, flatten it first (note, apart from weird corned cases, 436 // flatten will realistically only ever merge 1 layer, so there's no need to 437 // be smarter about grouping flattens together). 438 parent = parent.flatten().(*diffLayer) 439 440 parent.lock.Lock() 441 defer parent.lock.Unlock() 442 443 // Before actually writing all our data to the parent, first ensure that the 444 // parent hasn't been 'corrupted' by someone else already flattening into it 445 if atomic.SwapUint32(&parent.stale, 1) != 0 { 446 panic("parent diff layer is stale") // we've flattened into the same parent from two children, boo 447 } 448 // Overwrite all the updated accounts blindly, merge the sorted list 449 for hash := range dl.destructSet { 450 parent.destructSet[hash] = struct{}{} 451 delete(parent.accountData, hash) 452 delete(parent.storageData, hash) 453 } 454 for hash, data := range dl.accountData { 455 parent.accountData[hash] = data 456 } 457 // Overwrite all the updated storage slots (individually) 458 for accountHash, storage := range dl.storageData { 459 // If storage didn't exist (or was deleted) in the parent, overwrite blindly 460 if _, ok := parent.storageData[accountHash]; !ok { 461 parent.storageData[accountHash] = storage 462 continue 463 } 464 // Storage exists in both parent and child, merge the slots 465 comboData := parent.storageData[accountHash] 466 for storageHash, data := range storage { 467 comboData[storageHash] = data 468 } 469 parent.storageData[accountHash] = comboData 470 } 471 // Return the combo parent 472 return &diffLayer{ 473 parent: parent.parent, 474 origin: parent.origin, 475 root: dl.root, 476 destructSet: parent.destructSet, 477 accountData: parent.accountData, 478 storageData: parent.storageData, 479 storageList: make(map[common.Hash][]common.Hash), 480 diffed: dl.diffed, 481 memory: parent.memory + dl.memory, 482 } 483 } 484 485 // AccountList returns a sorted list of all accounts in this difflayer, including 486 // the deleted ones. 487 // 488 // Note, the returned slice is not a copy, so do not modify it. 489 func (dl *diffLayer) AccountList() []common.Hash { 490 // If an old list already exists, return it 491 dl.lock.RLock() 492 list := dl.accountList 493 dl.lock.RUnlock() 494 495 if list != nil { 496 return list 497 } 498 // No old sorted account list exists, generate a new one 499 dl.lock.Lock() 500 defer dl.lock.Unlock() 501 502 dl.accountList = make([]common.Hash, 0, len(dl.destructSet)+len(dl.accountData)) 503 for hash := range dl.accountData { 504 dl.accountList = append(dl.accountList, hash) 505 } 506 for hash := range dl.destructSet { 507 if _, ok := dl.accountData[hash]; !ok { 508 dl.accountList = append(dl.accountList, hash) 509 } 510 } 511 sort.Sort(hashes(dl.accountList)) 512 dl.memory += uint64(len(dl.accountList) * common.HashLength) 513 return dl.accountList 514 } 515 516 // StorageList returns a sorted list of all storage slot hashes in this difflayer 517 // for the given account. If the whole storage is destructed in this layer, then 518 // an additional flag *destructed = true* will be returned, otherwise the flag is 519 // false. Besides, the returned list will include the hash of deleted storage slot. 520 // Note a special case is an account is deleted in a prior tx but is recreated in 521 // the following tx with some storage slots set. In this case the returned list is 522 // not empty but the flag is true. 523 // 524 // Note, the returned slice is not a copy, so do not modify it. 525 func (dl *diffLayer) StorageList(accountHash common.Hash) ([]common.Hash, bool) { 526 dl.lock.RLock() 527 _, destructed := dl.destructSet[accountHash] 528 if _, ok := dl.storageData[accountHash]; !ok { 529 // Account not tracked by this layer 530 dl.lock.RUnlock() 531 return nil, destructed 532 } 533 // If an old list already exists, return it 534 if list, exist := dl.storageList[accountHash]; exist { 535 dl.lock.RUnlock() 536 return list, destructed // the cached list can't be nil 537 } 538 dl.lock.RUnlock() 539 540 // No old sorted account list exists, generate a new one 541 dl.lock.Lock() 542 defer dl.lock.Unlock() 543 544 storageMap := dl.storageData[accountHash] 545 storageList := make([]common.Hash, 0, len(storageMap)) 546 for k := range storageMap { 547 storageList = append(storageList, k) 548 } 549 sort.Sort(hashes(storageList)) 550 dl.storageList[accountHash] = storageList 551 dl.memory += uint64(len(dl.storageList)*common.HashLength + common.HashLength) 552 return storageList, destructed 553 }