use triegc for trie retention

Author: tsahee

core/blockchain.go

@@ -223,6 +223,11 @@ type BlockChain struct {
 	vmConfig   vm.Config
 }
 
+type trieGcEntry struct {
+	Root      common.Hash
+	Timestamp uint64
+}
+
 // NewBlockChain returns a fully initialised block chain using information
 // available in the database. It initialises the default Ethereum Validator
 // and Processor.
@@ -870,9 +875,6 @@ func (bc *BlockChain) Stop() {
 		}
 	}
 
-	// Arbitrum: only discard tries sufficiently old in both time and height
-	retain := bc.FindRetentionBound()
-
 	// Ensure the state of a recent block is also stored to disk before exiting.
 	// We're writing three different states to catch different restart scenarios:
 	//  - HEAD:     So we don't need to reprocess any blocks in the general case
@@ -881,7 +883,7 @@ func (bc *BlockChain) Stop() {
 	if !bc.cacheConfig.TrieDirtyDisabled {
 		triedb := bc.stateCache.TrieDB()
 
-		for _, offset := range []uint64{0, 1, retain - 1} {
+		for _, offset := range []uint64{0, 1, bc.cacheConfig.TriesInMemory} {
 			if number := bc.CurrentBlock().NumberU64(); number > offset {
 				recent := bc.GetBlockByNumber(number - offset)
 				if recent.Root() == (common.Hash{}) {
@@ -901,7 +903,7 @@ func (bc *BlockChain) Stop() {
 			}
 		}
 		for !bc.triegc.Empty() {
-			triedb.Dereference(bc.triegc.PopItem().(common.Hash))
+			triedb.Dereference(bc.triegc.PopItem().(trieGcEntry).Root)
 		}
 		if size, _ := triedb.Size(); size != 0 {
 			log.Error("Dangling trie nodes after full cleanup")
@@ -1224,8 +1226,6 @@ func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain [
 	return 0, nil
 }
 
-var lastWrite uint64
-
 // writeBlockWithoutState writes only the block and its metadata to the database,
 // but does not write any state. This is used to construct competing side forks
 // up to the point where they exceed the canonical total difficulty.
@@ -1286,18 +1286,18 @@ func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.
 	}
 	triedb := bc.stateCache.TrieDB()
 
-	// Arbitrum: only discard tries sufficiently old in both time and height
-	retain := bc.FindRetentionBound()
-
 	// If we're running an archive node, always flush
 	if bc.cacheConfig.TrieDirtyDisabled {
 		return triedb.Commit(root, false, nil)
 	} else {
 		// Full but not archive node, do proper garbage collection
 		triedb.Reference(root, common.Hash{}) // metadata reference to keep trie alive
-		bc.triegc.Push(root, -int64(block.NumberU64()))
+		bc.triegc.Push(trieGcEntry{root, block.Header().Time}, -int64(block.NumberU64()))
 
-		if current := block.NumberU64(); current > retain {
+		blockLimit := int64(block.NumberU64()) - int64(bc.cacheConfig.TriesInMemory)   // only cleared if below that
+		timeLimit := time.Now().Unix() - int64(bc.cacheConfig.TrieRetention.Seconds()) // only cleared if less than that
+
+		if blockLimit > 0 && timeLimit > 0 {
 			// If we exceeded our memory allowance, flush matured singleton nodes to disk
 			var (
 				nodes, imgs = triedb.Size()
@@ -1306,36 +1306,39 @@ func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.
 			if nodes > limit || imgs > 4*1024*1024 {
 				triedb.Cap(limit - ethdb.IdealBatchSize)
 			}
-			// Find the next state trie we need to commit
-			chosen := current - retain
-
+			var prevEntry *trieGcEntry
+			var prevNum uint64
+			// Garbage collect anything below our required write retention
+			for !bc.triegc.Empty() {
+				tmp, number := bc.triegc.Pop()
+				triegcEntry := tmp.(trieGcEntry)
+				if uint64(-number) > uint64(blockLimit) || triegcEntry.Timestamp > uint64(timeLimit) {
+					bc.triegc.Push(triegcEntry, number)
+					break
+				}
+				if prevEntry != nil {
+					triedb.Dereference(prevEntry.Root)
+				}
+				prevEntry = &triegcEntry
+				prevNum = uint64(-number)
+			}
 			// If we exceeded out time allowance, flush an entire trie to disk
-			if bc.gcproc > bc.cacheConfig.TrieTimeLimit {
+			if bc.gcproc > bc.cacheConfig.TrieTimeLimit && prevEntry != nil {
 				// If the header is missing (canonical chain behind), we're reorging a low
 				// diff sidechain. Suspend committing until this operation is completed.
-				header := bc.GetHeaderByNumber(chosen)
+				header := bc.GetHeaderByNumber(prevNum)
 				if header == nil {
-					log.Warn("Reorg in progress, trie commit postponed", "number", chosen)
+					log.Warn("Reorg in progress, trie commit postponed")
 				} else {
 					// If we're exceeding limits but haven't reached a large enough memory gap,
 					// warn the user that the system is becoming unstable.
-					if chosen < lastWrite+retain && bc.gcproc >= 2*bc.cacheConfig.TrieTimeLimit {
-						log.Info("State in memory for too long, committing", "time", bc.gcproc, "allowance", bc.cacheConfig.TrieTimeLimit, "optimum", float64(chosen-lastWrite)/float64(retain))
-					}
 					// Flush an entire trie and restart the counters
 					triedb.Commit(header.Root, true, nil)
-					lastWrite = chosen
 					bc.gcproc = 0
 				}
 			}
-			// Garbage collect anything below our required write retention
-			for !bc.triegc.Empty() {
-				root, number := bc.triegc.Pop()
-				if uint64(-number) > chosen {
-					bc.triegc.Push(root, number)
-					break
-				}
-				triedb.Dereference(root.(common.Hash))
+			if prevEntry != nil {
+				triedb.Dereference(prevEntry.Root)
 			}
 		}
 	}

core/blockchain_arbitrum.go

@@ -67,56 +67,3 @@ func (bc *BlockChain) ClipToPostNitroGenesis(blockNum rpc.BlockNumber) (rpc.Bloc
 	}
 	return blockNum, currentBlock
 }
-
-// finds the number of blocks that aren't prunable
-func (bc *BlockChain) FindRetentionBound() uint64 {
-	minimumSpan := bc.cacheConfig.TriesInMemory
-	minimumAge := uint64(bc.cacheConfig.TrieRetention.Seconds())
-
-	if minimumAge == 0 {
-		return minimumSpan
-	}
-
-	saturatingCast := func(value int64) uint64 {
-		if value < 0 {
-			return 0
-		}
-		return uint64(value)
-	}
-
-	// enforce that the block be sufficiently deep
-	current := bc.CurrentBlock()
-	heightBound := saturatingCast(int64(current.NumberU64()) - int64(minimumSpan) + 1)
-
-	// find the left bound to our subsequent binary search
-	timeBound := heightBound
-	leap := int64(1)
-	for timeBound > 0 {
-		age := current.Time() - bc.GetBlockByNumber(uint64(timeBound)).Time()
-		if age > minimumAge {
-			break
-		}
-		timeBound = saturatingCast(int64(timeBound) - leap)
-		leap *= 2
-	}
-	if timeBound == heightBound {
-		return current.NumberU64() - timeBound + 1
-	}
-
-	// Algo: binary search on the interval [a, b] for the first prunable block
-	//   Timebound is a prunable block, if one exists.
-	//   We want to find the first block that's not prunable.
-	//
-	a := timeBound   // a prunable block, if possible
-	b := heightBound // not prunable
-	for a+2 < b {
-		mid := a/2 + b/2 // a < mid < b
-		age := current.Time() - bc.GetBlockByNumber(mid).Time()
-		if age <= minimumAge {
-			b = mid // mid is not prunable and less than b
-		} else {
-			a = mid // mid is prunable, but might equal a
-		}
-	}
-	return current.NumberU64() - a
-}