core/rawdb, ethdb: introduce batched/atomic reads from ancients

core/rawdb/accessors_chain.go

@@ -393,30 +393,18 @@ func ReadBodyRLP(db ethdb.Reader, hash common.Hash, number uint64) rlp.RawValue
 	// First try to look up the data in ancient database. Extra hash
 	// comparison is necessary since ancient database only maintains
 	// the canonical data.
-	data, _ := db.Ancient(freezerBodiesTable, number)
-	if len(data) > 0 {
-		h, _ := db.Ancient(freezerHashTable, number)
-		if common.BytesToHash(h) == hash {
-			return data
-		}
-	}
-	// Then try to look up the data in leveldb.
-	data, _ = db.Get(blockBodyKey(number, hash))
-	if len(data) > 0 {
-		return data
-	}
-	// In the background freezer is moving data from leveldb to flatten files.
-	// So during the first check for ancient db, the data is not yet in there,
-	// but when we reach into leveldb, the data was already moved. That would
-	// result in a not found error.
-	data, _ = db.Ancient(freezerBodiesTable, number)
-	if len(data) > 0 {
-		h, _ := db.Ancient(freezerHashTable, number)
-		if common.BytesToHash(h) == hash {
-			return data
+	var data []byte
+	db.AtomicReadAncients(func (reader ethdb.AncientReader) error{
+		// Check if the data is in ancients
+		if h, _ := db.Ancient(freezerHashTable, number); common.BytesToHash(h) == hash {
+			data, _ = db.Ancient(freezerBodiesTable, number)
+			return nil
 		}
-	}
-	return nil // Can't find the data anywhere.
+		// If not, try reading from leveldb
+		data, _ = db.Get(blockBodyKey(number, hash))
+		return nil
+	})
+	return data
 }
 
 // ReadCanonicalBodyRLP retrieves the block body (transactions and uncles) for the canonical

core/rawdb/database.go

@@ -119,6 +119,10 @@ func (db *nofreezedb) Sync() error {
 	return errNotSupported
 }
 
+func (db *nofreezedb) AtomicReadAncients(fn func(reader ethdb.AncientReader) error) (err error){
+	return errNotSupported
+}
+
 // NewDatabase creates a high level database on top of a given key-value data
 // store without a freezer moving immutable chain segments into cold storage.
 func NewDatabase(db ethdb.KeyValueStore) ethdb.Database {

core/rawdb/freezer.go

@@ -80,8 +80,9 @@ type freezer struct {
 	frozen    uint64 // Number of blocks already frozen
 	threshold uint64 // Number of recent blocks not to freeze (params.FullImmutabilityThreshold apart from tests)
 
-	// This lock synchronizes writers and the truncate operation.
-	writeLock  sync.Mutex
+	// This lock synchronizes writers and the truncate operation, as well as
+	// the "atomic" (batched) read operations.
+	writeLock  sync.RWMutex
 	writeBatch *freezerBatch
 
 	readonly     bool
@@ -222,15 +223,23 @@ func (f *freezer) Ancients() (uint64, error) {
 func (f *freezer) AncientSize(kind string) (uint64, error) {
 	// This needs the write lock to avoid data races on table fields.
 	// Speed doesn't matter here, AncientSize is for debugging.
-	f.writeLock.Lock()
-	defer f.writeLock.Unlock()
+	f.writeLock.RLock()
+	defer f.writeLock.RUnlock()
 
 	if table := f.tables[kind]; table != nil {
 		return table.size()
 	}
 	return 0, errUnknownTable
 }
 
+// AtomicReadAncients runs the given read operation while ensuring that no writes take place
+// on the underlying freezer.
+func (f *freezer) AtomicReadAncients(fn func(ethdb.AncientReader) error) (err error) {
+	f.writeLock.RLock()
+	defer f.writeLock.RUnlock()
+	return fn(f)
+}
+
 // ModifyAncients runs the given write operation.
 func (f *freezer) ModifyAncients(fn func(ethdb.AncientWriteOp) error) (writeSize int64, err error) {
 	if f.readonly {

core/rawdb/table.go

@@ -85,6 +85,10 @@ func (t *table) ModifyAncients(fn func(ethdb.AncientWriteOp) error) (int64, erro
 	return t.db.ModifyAncients(fn)
 }
 
+func (t *table) AtomicReadAncients(fn func(reader ethdb.AncientReader) error) (err error){
+	return errNotSupported
+}
+
 // TruncateAncients is a noop passthrough that just forwards the request to the underlying
 // database.
 func (t *table) TruncateAncients(items uint64) error {

ethdb/database.go

@@ -88,6 +88,11 @@ type AncientReader interface {
 
 	// AncientSize returns the ancient size of the specified category.
 	AncientSize(kind string) (uint64, error)
+
+	// AtomicReadAncients runs the given read operation while ensuring that no writes take place
+	// on the underlying freezer.
+	AtomicReadAncients(fn func(AncientReader) error) (err error)
+
 }
 
 // AncientWriter contains the methods required to write to immutable ancient data.