core: improved chainDb using sequential keys

1 files changed, 69 insertions, 28 deletions

diff --git a/core/headerchain.go b/core/headerchain.go
index 5e0fbfb08..f856333a0 100644
--- a/core/headerchain.go
+++ b/core/headerchain.go
@@ -35,6 +35,12 @@ import (
 	"github.com/hashicorp/golang-lru"
 )
 
+const (
+	headerCacheLimit = 512
+	tdCacheLimit     = 1024
+	numberCacheLimit = 2048
+)
+
 // HeaderChain implements the basic block header chain logic that is shared by
 // core.BlockChain and light.LightChain. It is not usable in itself, only as
 // a part of either structure.
@@ -51,6 +57,7 @@ type HeaderChain struct {
 
 	headerCache *lru.Cache // Cache for the most recent block headers
 	tdCache     *lru.Cache // Cache for the most recent block total difficulties
+	numberCache *lru.Cache // Cache for the most recent block numbers
 
 	procInterrupt func() bool
 
@@ -68,6 +75,7 @@ type getHeaderValidatorFn func() HeaderValidator
 func NewHeaderChain(chainDb ethdb.Database, config *ChainConfig, getValidator getHeaderValidatorFn, procInterrupt func() bool) (*HeaderChain, error) {
 	headerCache, _ := lru.New(headerCacheLimit)
 	tdCache, _ := lru.New(tdCacheLimit)
+	numberCache, _ := lru.New(numberCacheLimit)
 
 	// Seed a fast but crypto originating random generator
 	seed, err := crand.Int(crand.Reader, big.NewInt(math.MaxInt64))
@@ -80,6 +88,7 @@ func NewHeaderChain(chainDb ethdb.Database, config *ChainConfig, getValidator ge
 		chainDb:       chainDb,
 		headerCache:   headerCache,
 		tdCache:       tdCache,
+		numberCache:   numberCache,
 		procInterrupt: procInterrupt,
 		rand:          mrand.New(mrand.NewSource(seed.Int64())),
 		getValidator:  getValidator,
@@ -97,7 +106,7 @@ func NewHeaderChain(chainDb ethdb.Database, config *ChainConfig, getValidator ge
 
 	hc.currentHeader = hc.genesisHeader
 	if head := GetHeadBlockHash(chainDb); head != (common.Hash{}) {
-		if chead := hc.GetHeader(head); chead != nil {
+		if chead := hc.GetHeaderByHash(head); chead != nil {
 			hc.currentHeader = chead
 		}
 	}
@@ -106,6 +115,19 @@ func NewHeaderChain(chainDb ethdb.Database, config *ChainConfig, getValidator ge
 	return hc, nil
 }
 
+// GetBlockNumber retrieves the block number belonging to the given hash
+// from the cache or database
+func (hc *HeaderChain) GetBlockNumber(hash common.Hash) uint64 {
+	if cached, ok := hc.numberCache.Get(hash); ok {
+		return cached.(uint64)
+	}
+	number := GetBlockNumber(hc.chainDb, hash)
+	if number != missingNumber {
+		hc.numberCache.Add(hash, number)
+	}
+	return number
+}
+
 // WriteHeader writes a header into the local chain, given that its parent is
 // already known. If the total difficulty of the newly inserted header becomes
 // greater than the current known TD, the canonical chain is re-routed.
@@ -122,11 +144,11 @@ func (hc *HeaderChain) WriteHeader(header *types.Header) (status WriteStatus, er
 		number = header.Number.Uint64()
 	)
 	// Calculate the total difficulty of the header
-	ptd := hc.GetTd(header.ParentHash)
+	ptd := hc.GetTd(header.ParentHash, number-1)
 	if ptd == nil {
 		return NonStatTy, ParentError(header.ParentHash)
 	}
-	localTd := hc.GetTd(hc.currentHeaderHash)
+	localTd := hc.GetTd(hc.currentHeaderHash, hc.currentHeader.Number.Uint64())
 	externTd := new(big.Int).Add(header.Difficulty, ptd)
 
 	// If the total difficulty is higher than our known, add it to the canonical chain
@@ -134,21 +156,25 @@ func (hc *HeaderChain) WriteHeader(header *types.Header) (status WriteStatus, er
 	// Please refer to http://www.cs.cornell.edu/~ie53/publications/btcProcFC.pdf
 	if externTd.Cmp(localTd) > 0 || (externTd.Cmp(localTd) == 0 && mrand.Float64() < 0.5) {
 		// Delete any canonical number assignments above the new head
-		for i := number + 1; GetCanonicalHash(hc.chainDb, i) != (common.Hash{}); i++ {
+		for i := number + 1; ; i++ {
+			hash := GetCanonicalHash(hc.chainDb, i)
+			if hash == (common.Hash{}) {
+				break
+			}
 			DeleteCanonicalHash(hc.chainDb, i)
 		}
 		// Overwrite any stale canonical number assignments
 		var (
 			headHash   = header.ParentHash
-			headHeader = hc.GetHeader(headHash)
-			headNumber = headHeader.Number.Uint64()
+			headNumber = header.Number.Uint64() - 1
+			headHeader = hc.GetHeader(headHash, headNumber)
 		)
 		for GetCanonicalHash(hc.chainDb, headNumber) != headHash {
 			WriteCanonicalHash(hc.chainDb, headHash, headNumber)
 
 			headHash = headHeader.ParentHash
-			headHeader = hc.GetHeader(headHash)
-			headNumber = headHeader.Number.Uint64()
+			headNumber = headHeader.Number.Uint64() - 1
+			headHeader = hc.GetHeader(headHash, headNumber)
 		}
 		// Extend the canonical chain with the new header
 		if err := WriteCanonicalHash(hc.chainDb, hash, number); err != nil {
@@ -164,13 +190,14 @@ func (hc *HeaderChain) WriteHeader(header *types.Header) (status WriteStatus, er
 		status = SideStatTy
 	}
 	// Irrelevant of the canonical status, write the header itself to the database
-	if err := hc.WriteTd(hash, externTd); err != nil {
+	if err := hc.WriteTd(hash, number, externTd); err != nil {
 		glog.Fatalf("failed to write header total difficulty: %v", err)
 	}
 	if err := WriteHeader(hc.chainDb, header); err != nil {
 		glog.Fatalf("failed to write header contents: %v", err)
 	}
 	hc.headerCache.Add(hash, header)
+	hc.numberCache.Add(hash, number)
 
 	return
 }
@@ -239,7 +266,7 @@ func (hc *HeaderChain) InsertHeaderChain(chain []*types.Header, checkFreq int, w
 
 			var err error
 			if index == 0 {
-				err = hc.getValidator().ValidateHeader(header, hc.GetHeader(header.ParentHash), checkPow)
+				err = hc.getValidator().ValidateHeader(header, hc.GetHeader(header.ParentHash, header.Number.Uint64()-1), checkPow)
 			} else {
 				err = hc.getValidator().ValidateHeader(header, chain[index-1], checkPow)
 			}
@@ -300,7 +327,7 @@ func (hc *HeaderChain) InsertHeaderChain(chain []*types.Header, checkFreq int, w
 // hash, fetching towards the genesis block.
 func (hc *HeaderChain) GetBlockHashesFromHash(hash common.Hash, max uint64) []common.Hash {
 	// Get the origin header from which to fetch
-	header := hc.GetHeader(hash)
+	header := hc.GetHeaderByHash(hash)
 	if header == nil {
 		return nil
 	}
@@ -308,7 +335,7 @@ func (hc *HeaderChain) GetBlockHashesFromHash(hash common.Hash, max uint64) []co
 	chain := make([]common.Hash, 0, max)
 	for i := uint64(0); i < max; i++ {
 		next := header.ParentHash
-		if header = hc.GetHeader(next); header == nil {
+		if header = hc.GetHeader(next, header.Number.Uint64()-1); header == nil {
 			break
 		}
 		chain = append(chain, next)
@@ -320,13 +347,13 @@ func (hc *HeaderChain) GetBlockHashesFromHash(hash common.Hash, max uint64) []co
 }
 
 // GetTd retrieves a block's total difficulty in the canonical chain from the
-// database by hash, caching it if found.
-func (hc *HeaderChain) GetTd(hash common.Hash) *big.Int {
+// database by hash and number, caching it if found.
+func (hc *HeaderChain) GetTd(hash common.Hash, number uint64) *big.Int {
 	// Short circuit if the td's already in the cache, retrieve otherwise
 	if cached, ok := hc.tdCache.Get(hash); ok {
 		return cached.(*big.Int)
 	}
-	td := GetTd(hc.chainDb, hash)
+	td := GetTd(hc.chainDb, hash, number)
 	if td == nil {
 		return nil
 	}
@@ -335,24 +362,30 @@ func (hc *HeaderChain) GetTd(hash common.Hash) *big.Int {
 	return td
 }
 
+// GetTdByHash retrieves a block's total difficulty in the canonical chain from the
+// database by hash, caching it if found.
+func (hc *HeaderChain) GetTdByHash(hash common.Hash) *big.Int {
+	return hc.GetTd(hash, hc.GetBlockNumber(hash))
+}
+
 // WriteTd stores a block's total difficulty into the database, also caching it
 // along the way.
-func (hc *HeaderChain) WriteTd(hash common.Hash, td *big.Int) error {
-	if err := WriteTd(hc.chainDb, hash, td); err != nil {
+func (hc *HeaderChain) WriteTd(hash common.Hash, number uint64, td *big.Int) error {
+	if err := WriteTd(hc.chainDb, hash, number, td); err != nil {
 		return err
 	}
 	hc.tdCache.Add(hash, new(big.Int).Set(td))
 	return nil
 }
 
-// GetHeader retrieves a block header from the database by hash, caching it if
-// found.
-func (hc *HeaderChain) GetHeader(hash common.Hash) *types.Header {
+// GetHeader retrieves a block header from the database by hash and number,
+// caching it if found.
+func (hc *HeaderChain) GetHeader(hash common.Hash, number uint64) *types.Header {
 	// Short circuit if the header's already in the cache, retrieve otherwise
 	if header, ok := hc.headerCache.Get(hash); ok {
 		return header.(*types.Header)
 	}
-	header := GetHeader(hc.chainDb, hash)
+	header := GetHeader(hc.chainDb, hash, number)
 	if header == nil {
 		return nil
 	}
@@ -361,10 +394,16 @@ func (hc *HeaderChain) GetHeader(hash common.Hash) *types.Header {
 	return header
 }
 
+// GetHeaderByHash retrieves a block header from the database by hash, caching it if
+// found.
+func (hc *HeaderChain) GetHeaderByHash(hash common.Hash) *types.Header {
+	return hc.GetHeader(hash, hc.GetBlockNumber(hash))
+}
+
 // HasHeader checks if a block header is present in the database or not, caching
 // it if present.
 func (hc *HeaderChain) HasHeader(hash common.Hash) bool {
-	return hc.GetHeader(hash) != nil
+	return hc.GetHeaderByHash(hash) != nil
 }
 
 // GetHeaderByNumber retrieves a block header from the database by number,
@@ -374,7 +413,7 @@ func (hc *HeaderChain) GetHeaderByNumber(number uint64) *types.Header {
 	if hash == (common.Hash{}) {
 		return nil
 	}
-	return hc.GetHeader(hash)
+	return hc.GetHeader(hash, number)
 }
 
 // CurrentHeader retrieves the current head header of the canonical chain. The
@@ -394,7 +433,7 @@ func (hc *HeaderChain) SetCurrentHeader(head *types.Header) {
 
 // DeleteCallback is a callback function that is called by SetHead before
 // each header is deleted.
-type DeleteCallback func(common.Hash)
+type DeleteCallback func(common.Hash, uint64)
 
 // SetHead rewinds the local chain to a new head. Everything above the new head
 // will be deleted and the new one set.
@@ -406,12 +445,13 @@ func (hc *HeaderChain) SetHead(head uint64, delFn DeleteCallback) {
 
 	for hc.currentHeader != nil && hc.currentHeader.Number.Uint64() > head {
 		hash := hc.currentHeader.Hash()
+		num := hc.currentHeader.Number.Uint64()
 		if delFn != nil {
-			delFn(hash)
+			delFn(hash, num)
 		}
-		DeleteHeader(hc.chainDb, hash)
-		DeleteTd(hc.chainDb, hash)
-		hc.currentHeader = hc.GetHeader(hc.currentHeader.ParentHash)
+		DeleteHeader(hc.chainDb, hash, num)
+		DeleteTd(hc.chainDb, hash, num)
+		hc.currentHeader = hc.GetHeader(hc.currentHeader.ParentHash, hc.currentHeader.Number.Uint64()-1)
 	}
 	// Roll back the canonical chain numbering
 	for i := height; i > head; i-- {
@@ -420,6 +460,7 @@ func (hc *HeaderChain) SetHead(head uint64, delFn DeleteCallback) {
 	// Clear out any stale content from the caches
 	hc.headerCache.Purge()
 	hc.tdCache.Purge()
+	hc.numberCache.Purge()
 
 	if hc.currentHeader == nil {
 		hc.currentHeader = hc.genesisHeader