trie: remove node ordering slice in sync batch (#19929)

When we flush a batch of trie nodes into database during the state
sync, we should guarantee that all children should be flushed before
parent.

Actually the trie nodes commit order is strict by: children -> parent.
But when we flush all ready nodes into db, we don't need the order
anymore since

    (1) they are all ready nodes (no more dependency)
    (2) underlying database provides write atomicity

trie/sync.go

@@ -57,14 +57,12 @@ type SyncResult struct {
 // persisted data items.
 type syncMemBatch struct {
 	batch map[common.Hash][]byte // In-memory membatch of recently completed items
-	order []common.Hash          // Order of completion to prevent out-of-order data loss
 }
 
 // newSyncMemBatch allocates a new memory-buffer for not-yet persisted trie nodes.
 func newSyncMemBatch() *syncMemBatch {
 	return &syncMemBatch{
 		batch: make(map[common.Hash][]byte),
-		order: make([]common.Hash, 0, 256),
 	}
 }
 
@@ -223,20 +221,18 @@ func (s *Sync) Process(results []SyncResult) (bool, int, error) {
 }
 
 // Commit flushes the data stored in the internal membatch out to persistent
-// storage, returning the number of items written and any occurred error.
-func (s *Sync) Commit(dbw ethdb.KeyValueWriter) (int, error) {
+// storage, returning any occurred error.
+func (s *Sync) Commit(dbw ethdb.Batch) error {
 	// Dump the membatch into a database dbw
-	for i, key := range s.membatch.order {
-		if err := dbw.Put(key[:], s.membatch.batch[key]); err != nil {
-			return i, err
+	for key, value := range s.membatch.batch {
+		if err := dbw.Put(key[:], value); err != nil {
+			return err
 		}
 		s.bloom.Add(key[:])
 	}
-	written := len(s.membatch.order) // TODO(karalabe): could an order change improve write performance?
-
 	// Drop the membatch data and return
 	s.membatch = newSyncMemBatch()
-	return written, nil
+	return nil
 }
 
 // Pending returns the number of state entries currently pending for download.
@@ -330,7 +326,6 @@ func (s *Sync) children(req *request, object node) ([]*request, error) {
 func (s *Sync) commit(req *request) (err error) {
 	// Write the node content to the membatch
 	s.membatch.batch[req.hash] = req.data
-	s.membatch.order = append(s.membatch.order, req.hash)
 
 	delete(s.requests, req.hash)