From ab71553ec3c1194e808ffd8f4c63a18271f22ee0 Mon Sep 17 00:00:00 2001 From: GalaIO Date: Tue, 9 Apr 2024 21:34:11 +0800 Subject: [PATCH 1/4] freezer: fix some env missing issues; --- core/rawdb/chain_freezer.go | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/core/rawdb/chain_freezer.go b/core/rawdb/chain_freezer.go index 5f6cd15ad6..987a06c459 100644 --- a/core/rawdb/chain_freezer.go +++ b/core/rawdb/chain_freezer.go @@ -17,6 +17,7 @@ package rawdb import ( + "errors" "fmt" "math/big" "sync" @@ -42,6 +43,10 @@ const ( freezerBatchLimit = 30000 ) +var ( + missFreezerEnvErr = errors.New("missing freezer env error") +) + // chainFreezer is a wrapper of freezer with additional chain freezing feature. // The background thread will keep moving ancient chain segments from key-value // database to flat files for saving space on live database. @@ -119,6 +124,20 @@ func (f *chainFreezer) freeze(db ethdb.KeyValueStore) { return } } + + // check freezer env first, it must wait a while when the env is necessary + err := f.checkFreezerEnv() + if err == missFreezerEnvErr { + log.Warn("Freezer need related env, may wait for a while", "err", err) + backoff = true + continue + } + if err != nil { + log.Error("Freezer check FreezerEnv err", "err", err) + backoff = true + continue + } + // Retrieve the freezing threshold. hash := ReadHeadBlockHash(nfdb) if hash == (common.Hash{}) { @@ -413,6 +432,21 @@ func (f *chainFreezer) SetupFreezerEnv(env *ethdb.FreezerEnv) error { return nil } +func (f *chainFreezer) checkFreezerEnv() error { + _, exist := f.freezeEnv.Load().(*ethdb.FreezerEnv) + if exist { + return nil + } + blobFrozen, err := f.TableAncients(ChainFreezerBlobSidecarTable) + if err != nil { + return err + } + if blobFrozen > 0 { + return missFreezerEnvErr + } + return nil +} + func isCancun(env *ethdb.FreezerEnv, num *big.Int, time uint64) bool { if env == nil || env.ChainCfg == nil { return false From 07d5568e7304c12615ef4201fbb57fe3f779dabc Mon Sep 17 00:00:00 2001 From: GalaIO Date: Tue, 9 Apr 2024 21:44:43 +0800 Subject: [PATCH 2/4] logs: downgrade some info level logs; --- core/rawdb/accessors_chain.go | 2 +- core/rawdb/chain_freezer.go | 5 +---- core/rawdb/freezer.go | 2 +- 3 files changed, 3 insertions(+), 6 deletions(-) diff --git a/core/rawdb/accessors_chain.go b/core/rawdb/accessors_chain.go index baa3df7ef6..fcbf2ff4a6 100644 --- a/core/rawdb/accessors_chain.go +++ b/core/rawdb/accessors_chain.go @@ -808,7 +808,7 @@ func WriteAncientBlocksWithBlobs(db ethdb.AncientWriter, blocks []*types.Block, break } } - log.Info("WriteAncientBlocks", "startAt", blocks[0].Number(), "cancunIndex", cancunIndex, "len", len(blocks)) + log.Debug("WriteAncientBlocks", "startAt", blocks[0].Number(), "cancunIndex", cancunIndex, "len", len(blocks)) var ( tdSum = new(big.Int).Set(td) diff --git a/core/rawdb/chain_freezer.go b/core/rawdb/chain_freezer.go index 987a06c459..45a6f38671 100644 --- a/core/rawdb/chain_freezer.go +++ b/core/rawdb/chain_freezer.go @@ -297,7 +297,7 @@ func (f *chainFreezer) tryPruneBlobAncientTable(env *ethdb.FreezerEnv, num uint6 log.Error("Cannot prune blob ancient", "block", num, "expectTail", expectTail, "err", err) return } - log.Info("Chain freezer prune useless blobs, now ancient data is", "from", expectTail, "to", num, "cost", common.PrettyDuration(time.Since(start))) + log.Debug("Chain freezer prune useless blobs, now ancient data is", "from", expectTail, "to", num, "cost", common.PrettyDuration(time.Since(start))) } func getBlobExtraReserveFromEnv(env *ethdb.FreezerEnv) uint64 { @@ -308,9 +308,6 @@ func getBlobExtraReserveFromEnv(env *ethdb.FreezerEnv) uint64 { } func (f *chainFreezer) freezeRangeWithBlobs(nfdb *nofreezedb, number, limit uint64) (hashes []common.Hash, err error) { - defer func() { - log.Info("freezeRangeWithBlobs", "from", number, "to", limit, "err", err) - }() lastHash := ReadCanonicalHash(nfdb, limit) if lastHash == (common.Hash{}) { return nil, fmt.Errorf("canonical hash missing, can't freeze block %d", limit) diff --git a/core/rawdb/freezer.go b/core/rawdb/freezer.go index ca237dd3aa..ba1542294d 100644 --- a/core/rawdb/freezer.go +++ b/core/rawdb/freezer.go @@ -765,7 +765,7 @@ func (f *Freezer) ResetTable(kind string, startAt uint64, onlyEmpty bool) error f.frozen.Add(f.offset) f.tail.Add(f.offset) f.writeBatch = newFreezerBatch(f) - log.Info("Reset Table", "kind", kind, "tail", f.tables[kind].itemHidden.Load(), "frozen", f.tables[kind].items.Load()) + log.Debug("Reset Table", "kind", kind, "tail", f.tables[kind].itemHidden.Load(), "frozen", f.tables[kind].items.Load()) return nil } From 2ea3f6edd6ce3822194cbf6cea6ee740bb3e8717 Mon Sep 17 00:00:00 2001 From: GalaIO Date: Tue, 9 Apr 2024 22:22:38 +0800 Subject: [PATCH 3/4] da: add some DA benchmark; --- core/data_availability_test.go | 86 ++++++++++++++++++++++++++++++++++ 1 file changed, 86 insertions(+) diff --git a/core/data_availability_test.go b/core/data_availability_test.go index e6963a2615..f89fd859d6 100644 --- a/core/data_availability_test.go +++ b/core/data_availability_test.go @@ -1,9 +1,12 @@ package core import ( + "crypto/rand" + gokzg4844 "github.com/crate-crypto/go-kzg-4844" "math/big" "testing" + "github.com/consensys/gnark-crypto/ecc/bls12-381/fr" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto/kzg4844" @@ -247,6 +250,49 @@ func TestCheckDataAvailableInBatch(t *testing.T) { } } +func BenchmarkEmptySidecarDAChecking(b *testing.B) { + hr := NewMockDAHeaderReader(params.ParliaTestChainConfig) + block := types.NewBlockWithHeader(&types.Header{ + Number: big.NewInt(1), + }).WithBody(types.Transactions{ + createMockDATx(hr.Config(), emptySidecar()), + createMockDATx(hr.Config(), emptySidecar()), + createMockDATx(hr.Config(), emptySidecar()), + createMockDATx(hr.Config(), emptySidecar()), + createMockDATx(hr.Config(), emptySidecar()), + createMockDATx(hr.Config(), emptySidecar()), + }, nil) + block = block.WithSidecars(collectBlobsFromTxs(block.Header(), block.Transactions())) + b.ResetTimer() + for i := 0; i < b.N; i++ { + IsDataAvailable(hr, block) + } +} + +func BenchmarkRandomSidecarDAChecking(b *testing.B) { + hr := NewMockDAHeaderReader(params.ParliaTestChainConfig) + const count = 10 + blocks := make([]*types.Block, count) + for i := 0; i < len(blocks); i++ { + block := types.NewBlockWithHeader(&types.Header{ + Number: big.NewInt(1), + }).WithBody(types.Transactions{ + createMockDATx(hr.Config(), randomSidecar()), + createMockDATx(hr.Config(), randomSidecar()), + createMockDATx(hr.Config(), randomSidecar()), + createMockDATx(hr.Config(), randomSidecar()), + createMockDATx(hr.Config(), randomSidecar()), + createMockDATx(hr.Config(), randomSidecar()), + }, nil) + block = block.WithSidecars(collectBlobsFromTxs(block.Header(), block.Transactions())) + blocks[i] = block + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + IsDataAvailable(hr, blocks[i%count]) + } +} + func collectBlobsFromTxs(header *types.Header, txs types.Transactions) types.BlobSidecars { sidecars := make(types.BlobSidecars, 0, len(txs)) for i, tx := range txs { @@ -348,3 +394,43 @@ func createMockDATx(config *params.ChainConfig, sidecar *types.BlobTxSidecar) *t } return types.NewTx(tx) } + +func randFieldElement() [32]byte { + bytes := make([]byte, 32) + _, err := rand.Read(bytes) + if err != nil { + panic("failed to get random field element") + } + var r fr.Element + r.SetBytes(bytes) + + return gokzg4844.SerializeScalar(r) +} + +func randBlob() kzg4844.Blob { + var blob kzg4844.Blob + for i := 0; i < len(blob); i += gokzg4844.SerializedScalarSize { + fieldElementBytes := randFieldElement() + copy(blob[i:i+gokzg4844.SerializedScalarSize], fieldElementBytes[:]) + } + return blob +} + +func randomSidecar() *types.BlobTxSidecar { + blob := randBlob() + commitment, _ := kzg4844.BlobToCommitment(blob) + proof, _ := kzg4844.ComputeBlobProof(blob, commitment) + return &types.BlobTxSidecar{ + Blobs: []kzg4844.Blob{blob}, + Commitments: []kzg4844.Commitment{commitment}, + Proofs: []kzg4844.Proof{proof}, + } +} + +func emptySidecar() *types.BlobTxSidecar { + return &types.BlobTxSidecar{ + Blobs: []kzg4844.Blob{emptyBlob}, + Commitments: []kzg4844.Commitment{emptyBlobCommit}, + Proofs: []kzg4844.Proof{emptyBlobProof}, + } +} From b1a96d06bfef3b5033de1fc5a32c656c3a36c980 Mon Sep 17 00:00:00 2001 From: buddh0 Date: Wed, 10 Apr 2024 09:40:28 +0800 Subject: [PATCH 4/4] freezer: add debug info --- core/data_availability_test.go | 2 +- core/rawdb/chain_freezer.go | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/core/data_availability_test.go b/core/data_availability_test.go index f89fd859d6..2269aee232 100644 --- a/core/data_availability_test.go +++ b/core/data_availability_test.go @@ -2,11 +2,11 @@ package core import ( "crypto/rand" - gokzg4844 "github.com/crate-crypto/go-kzg-4844" "math/big" "testing" "github.com/consensys/gnark-crypto/ecc/bls12-381/fr" + gokzg4844 "github.com/crate-crypto/go-kzg-4844" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto/kzg4844" diff --git a/core/rawdb/chain_freezer.go b/core/rawdb/chain_freezer.go index 45a6f38671..323a7eb54c 100644 --- a/core/rawdb/chain_freezer.go +++ b/core/rawdb/chain_freezer.go @@ -308,6 +308,9 @@ func getBlobExtraReserveFromEnv(env *ethdb.FreezerEnv) uint64 { } func (f *chainFreezer) freezeRangeWithBlobs(nfdb *nofreezedb, number, limit uint64) (hashes []common.Hash, err error) { + defer func() { + log.Debug("freezeRangeWithBlobs", "from", number, "to", limit, "err", err) + }() lastHash := ReadCanonicalHash(nfdb, limit) if lastHash == (common.Hash{}) { return nil, fmt.Errorf("canonical hash missing, can't freeze block %d", limit)