ledger: Remove redundant block header cache

ledger/acctupdates.go

@@ -1172,7 +1172,7 @@ func (au *accountUpdates) lookupLatest(addr basics.Address) (data basics.Account
 
 		if resourceDbRound < currentDbRound {
 			au.log.Errorf("accountUpdates.lookupLatest: resource database round %d is behind in-memory round %d", resourceDbRound, currentDbRound)
-			return basics.AccountData{}, basics.Round(0), basics.MicroAlgos{}, &StaleDatabaseRoundError{databaseRound: resourceDbRound, memoryRound: currentDbRound}
+			/*xxxxx*/ return basics.AccountData{}, basics.Round(0), basics.MicroAlgos{}, &StaleDatabaseRoundError{databaseRound: resourceDbRound, memoryRound: currentDbRound}
 		}
 
 	tryAgain:

ledger/acctupdates_test.go

@@ -242,6 +242,10 @@ func (ml *mockLedgerForTracker) Block(rnd basics.Round) (bookkeeping.Block, erro
 }
 
 func (ml *mockLedgerForTracker) BlockHdr(rnd basics.Round) (bookkeeping.BlockHeader, error) {
+	return ml.blockHdr(rnd)
+}
+
+func (ml *mockLedgerForTracker) blockHdr(rnd basics.Round) (bookkeeping.BlockHeader, error) {
 	if rnd > ml.Latest() {
 		return bookkeeping.BlockHeader{}, fmt.Errorf("rnd %d out of bounds", rnd)
 	}
@@ -2439,7 +2443,7 @@ func TestAcctUpdatesLookupLatestCacheRetry(t *testing.T) {
 	wg.Add(1)
 	done := make(chan struct{})
 	go func() {
-		ad, _, _, err = au.lookupLatest(addr1)
+		/*xxxxx*/ ad, _, _, err = au.lookupLatest(addr1)
 		close(done)
 		wg.Done()
 	}()

ledger/archival_test.go

@@ -64,6 +64,10 @@ func (wl *wrappedLedger) Block(rnd basics.Round) (bookkeeping.Block, error) {
 }
 
 func (wl *wrappedLedger) BlockHdr(rnd basics.Round) (bookkeeping.BlockHeader, error) {
+	return wl.blockHdr(rnd)
+}
+
+func (wl *wrappedLedger) blockHdr(rnd basics.Round) (bookkeeping.BlockHeader, error) {
 	wl.recordBlockQuery(rnd)
 	return wl.l.BlockHdr(rnd)
 }

ledger/ledger.go

@@ -91,7 +91,7 @@ type Ledger struct {
 	trackers  trackerRegistry
 	trackerMu deadlock.RWMutex
 
-	headerCache blockHeaderCache
+	//	headerCache blockHeaderCache
 
 	// verifiedTxnCache holds all the verified transactions state
 	verifiedTxnCache verify.VerifiedTransactionCache
@@ -136,7 +136,7 @@ func OpenLedger(
 		tracer:                         tracer,
 	}
 
-	l.headerCache.initialize()
+	//	l.headerCache.initialize()
 
 	defer func() {
 		if err != nil {
@@ -628,8 +628,6 @@ func (l *Ledger) OnlineCirculation(rnd basics.Round, voteRnd basics.Round) (basi
 
 // CheckDup return whether a transaction is a duplicate one.
 func (l *Ledger) CheckDup(currentProto config.ConsensusParams, current basics.Round, firstValid basics.Round, lastValid basics.Round, txid transactions.Txid, txl ledgercore.Txlease) error {
-	l.trackerMu.RLock()
-	defer l.trackerMu.RUnlock()
 	return l.txTail.checkDup(currentProto, current, firstValid, lastValid, txid, txl)
 }
 
@@ -654,16 +652,11 @@ func (l *Ledger) Block(rnd basics.Round) (blk bookkeeping.Block, err error) {
 
 // BlockHdr returns the BlockHeader of the block for round rnd.
 func (l *Ledger) BlockHdr(rnd basics.Round) (blk bookkeeping.BlockHeader, err error) {
-	blk, exists := l.headerCache.get(rnd)
-	if exists {
-		return
-	}
-
-	blk, err = l.blockQ.getBlockHdr(rnd)
-	if err == nil {
-		l.headerCache.put(blk)
+	hdr, ok := l.txTail.blockHeader(rnd)
+	if !ok {
+		hdr, err = l.blockQ.getBlockHdr(rnd)
 	}
-	return
+	return hdr, err
 }
 
 // EncodedBlockCert returns the encoded block and the corresponding encoded certificate of the block for round rnd.
@@ -712,7 +705,7 @@ func (l *Ledger) AddValidatedBlock(vb ledgercore.ValidatedBlock, cert agreement.
 	if err != nil {
 		return err
 	}
-	l.headerCache.put(blk.BlockHeader)
+	//	l.headerCache.put(blk.BlockHeader)
 	l.trackers.newBlock(blk, vb.Delta())
 	l.log.Debugf("ledger.AddValidatedBlock: added blk %d", blk.Round())
 	return nil
@@ -767,8 +760,6 @@ func (l *Ledger) GenesisAccounts() map[basics.Address]basics.AccountData {
 // the deepest lookup happens when txn.LastValid == current => txn.LastValid == Latest + 1
 // that gives Latest + 1 - (MaxTxnLife + 1) = Latest - MaxTxnLife as the first round to be accessible.
 func (l *Ledger) BlockHdrCached(rnd basics.Round) (hdr bookkeeping.BlockHeader, err error) {
-	l.trackerMu.RLock()
-	defer l.trackerMu.RUnlock()
 	hdr, ok := l.txTail.blockHeader(rnd)
 	if !ok {
 		err = fmt.Errorf("no cached header data for round %d", rnd)

ledger/ledger_test.go

@@ -1385,46 +1385,6 @@ func testLedgerRegressionFaultyLeaseFirstValidCheck2f3880f7(t *testing.T, versio
 	}
 }
 
-func TestLedgerBlockHdrCaching(t *testing.T) {
-	partitiontest.PartitionTest(t)
-	a := require.New(t)
-
-	dbName := fmt.Sprintf("%s.%d", t.Name(), crypto.RandUint64())
-	genesisInitState := getInitState()
-	const inMem = true
-	cfg := config.GetDefaultLocal()
-	cfg.Archival = true
-	log := logging.TestingLog(t)
-	log.SetLevel(logging.Info)
-	l, err := OpenLedger(log, dbName, inMem, genesisInitState, cfg)
-	a.NoError(err)
-	defer l.Close()
-
-	blk := genesisInitState.Block
-
-	for i := 0; i < 1024; i++ {
-		blk.BlockHeader.Round++
-		blk.BlockHeader.TimeStamp += int64(crypto.RandUint64() % 100 * 1000)
-		err := l.AddBlock(blk, agreement.Certificate{})
-		a.NoError(err)
-
-		hdr, err := l.BlockHdr(blk.BlockHeader.Round)
-		a.NoError(err)
-		a.Equal(blk.BlockHeader, hdr)
-	}
-
-	rnd := basics.Round(128)
-	hdr, err := l.BlockHdr(rnd) // should update LRU cache but not latestBlockHeaderCache
-	a.NoError(err)
-	a.Equal(rnd, hdr.Round)
-
-	_, exists := l.headerCache.lruCache.Get(rnd)
-	a.True(exists)
-
-	_, exists = l.headerCache.latestHeaderCache.get(rnd)
-	a.False(exists)
-}
-
 func BenchmarkLedgerBlockHdrCaching(b *testing.B) {
 	benchLedgerCache(b, 1024-256+1)
 }

ledger/tracker.go

@@ -282,6 +282,8 @@ func (dcc deferredCommitContext) newBase() basics.Round {
 var errMissingAccountUpdateTracker = errors.New("initializeTrackerCaches : called without a valid accounts update tracker")
 
 func (tr *trackerRegistry) initialize(l ledgerForTracker, trackers []ledgerTracker, cfg config.Local) (err error) {
+	tr.mu.Lock()
+	defer tr.mu.Unlock()
 	tr.dbs = l.trackerDB()
 	tr.log = l.trackerLog()
 

ledger/txtail.go

@@ -90,6 +90,9 @@ type txTail struct {
 }
 
 func (t *txTail) loadFromDisk(l ledgerForTracker, dbRound basics.Round) error {
+	t.tailMu.Lock()
+	defer t.tailMu.Unlock()
+
 	t.log = l.trackerLog()
 
 	var roundData []*trackerdb.TxTailRound
@@ -196,6 +199,9 @@ func (t *txTail) newBlock(blk bookkeeping.Block, delta ledgercore.StateDelta) {
 		return
 	}
 
+	t.tailMu.Lock()
+	defer t.tailMu.Unlock()
+
 	var tail trackerdb.TxTailRound
 	tail.TxnIDs = make([]transactions.Txid, len(delta.Txids))
 	tail.LastValid = make([]basics.Round, len(delta.Txids))
@@ -215,8 +221,6 @@ func (t *txTail) newBlock(blk bookkeeping.Block, delta ledgercore.StateDelta) {
 	}
 	encodedTail, tailHash := tail.Encode()
 
-	t.tailMu.Lock()
-	defer t.tailMu.Unlock()
 	t.recent[rnd] = roundLeases{
 		txleases: delta.Txleases,
 		proto:    config.Consensus[blk.CurrentProtocol],
@@ -229,6 +233,9 @@ func (t *txTail) newBlock(blk bookkeeping.Block, delta ledgercore.StateDelta) {
 }
 
 func (t *txTail) committedUpTo(rnd basics.Round) (retRound, lookback basics.Round) {
+	t.tailMu.Lock()
+	defer t.tailMu.Unlock()
+
 	proto := t.recent[rnd].proto
 	maxlife := basics.Round(proto.MaxTxnLife)
 
@@ -246,8 +253,8 @@ func (t *txTail) committedUpTo(rnd basics.Round) (retRound, lookback basics.Roun
 }
 
 func (t *txTail) prepareCommit(dcc *deferredCommitContext) (err error) {
-	dcc.txTailDeltas = make([][]byte, 0, dcc.offset)
 	t.tailMu.RLock()
+	dcc.txTailDeltas = make([][]byte, 0, dcc.offset)
 	for i := uint64(0); i < dcc.offset; i++ {
 		dcc.txTailDeltas = append(dcc.txTailDeltas, t.roundTailSerializedDeltas[i])
 	}
@@ -273,6 +280,9 @@ func (t *txTail) prepareCommit(dcc *deferredCommitContext) (err error) {
 }
 
 func (t *txTail) commitRound(ctx context.Context, tx trackerdb.TransactionScope, dcc *deferredCommitContext) error {
+	t.tailMu.Lock()
+	defer t.tailMu.Unlock()
+
 	aw, err := tx.MakeAccountsWriter()
 	if err != nil {
 		return err
@@ -333,6 +343,9 @@ func (t errTxTailMissingRound) Error() string {
 // checkDup test to see if the given transaction id/lease already exists. It returns nil if neither exists, or
 // TransactionInLedgerError / LeaseInLedgerError respectively.
 func (t *txTail) checkDup(proto config.ConsensusParams, current basics.Round, firstValid basics.Round, lastValid basics.Round, txid transactions.Txid, txl ledgercore.Txlease) error {
+	t.tailMu.RLock()
+	defer t.tailMu.RUnlock()
+
 	if lastValid < t.lowWaterMark {
 		return &errTxTailMissingRound{round: lastValid}
 	}
@@ -387,8 +400,5 @@ func (t *txTail) blockHeader(rnd basics.Round) (bookkeeping.BlockHeader, bool) {
 	t.tailMu.RLock()
 	defer t.tailMu.RUnlock()
 	hdr, ok := t.blockHeaderData[rnd]
-	if !ok {
-		t.log.Warnf("txtail failed to fetch blockHeader from rnd: %d", rnd)
-	}
 	return hdr, ok
 }

stateproof/abstractions.go

@@ -18,6 +18,7 @@ package stateproof
 
 import (
 	"context"
+
 	"github.com/algorand/go-algorand/crypto"
 	"github.com/algorand/go-algorand/data/account"
 	"github.com/algorand/go-algorand/data/basics"