Optimize snapshot traversal for EVM transactions

Author: m-Peter

fvm/evm/emulator/state/delta.go

@@ -67,6 +67,16 @@ var _ types.HotView = &DeltaView{}
 
 // NewDeltaView constructs a new delta view
 func NewDeltaView(parent types.ReadOnlyView) *DeltaView {
+	// The root node will be of type `BaseView`, so we should
+	// check if we are dealing with `DeltaView`, for parent
+	// skipping
+	dt, ok := parent.(*DeltaView)
+	if ok && !dt.hasData() {
+		// If my parent doesn't have any writes, I can just
+		// delegate "upstream" queries to its parent
+		parent = dt.parent
+	}
+
 	return &DeltaView{
 		parent: parent,
 
@@ -478,21 +488,14 @@ func (d *DeltaView) SubRefund(amount uint64) error {
 
 // AddressInAccessList checks if the address is in the access list of
 // the current view.
-// NOTE: Due to resource constraints (such as CPU & memory), and the
-// high-frequency usage of this function from EVM, we do not look up
-// the parents until the root view or until we find a view that has
-// the address in its local access list.
-// As an optimization, the `StateDB.AddressInAccessList` is responsible
-// for optimally traversing the views, to check if the address is in
-// the access list.
 func (d *DeltaView) AddressInAccessList(addr gethCommon.Address) bool {
 	if d.accessListAddresses != nil {
 		_, addressFound := d.accessListAddresses[addr]
 		if addressFound {
 			return true
 		}
 	}
-	return false
+	return d.parent.AddressInAccessList(addr)
 }
 
 // AddAddressToAccessList adds an address to the access list
@@ -508,13 +511,6 @@ func (d *DeltaView) AddAddressToAccessList(addr gethCommon.Address) bool {
 
 // SlotInAccessList checks if the slot is in the access list of the
 // current view.
-// NOTE: Due to resource constraints (such as CPU & memory), and the
-// high-frequency usage of this function from EVM, we do not look up
-// the parents until the root view or until we find a view that has
-// the slot in its local access list.
-// As an optimization, the `StateDB.SlotInAccessList` is responsible
-// for optimally traversing the views, to check if the slot is in
-// the access list.
 func (d *DeltaView) SlotInAccessList(sk types.SlotAddress) (addressOk bool, slotOk bool) {
 	addressFound := d.AddressInAccessList(sk.Address)
 	if d.accessListSlots != nil {
@@ -523,7 +519,7 @@ func (d *DeltaView) SlotInAccessList(sk types.SlotAddress) (addressOk bool, slot
 			return addressFound, true
 		}
 	}
-	return addressFound, false
+	return d.parent.SlotInAccessList(sk)
 }
 
 // AddSlotToAccessList adds a slot to the access list
@@ -584,3 +580,64 @@ func (d *DeltaView) DirtySlots() map[types.SlotAddress]struct{} {
 	}
 	return dirtySlots
 }
+
+// hasData returns whether any state modifications are recorded in this view
+func (d *DeltaView) hasData() bool {
+	if len(d.dirtyAddresses) > 0 {
+		return true
+	}
+
+	if len(d.created) > 0 {
+		return true
+	}
+
+	if len(d.newContract) > 0 {
+		return true
+	}
+
+	if len(d.toBeDestructed) > 0 {
+		return true
+	}
+
+	if len(d.recreated) > 0 {
+		return true
+	}
+
+	if len(d.balances) > 0 {
+		return true
+	}
+
+	if len(d.nonces) > 0 {
+		return true
+	}
+
+	if len(d.codes) > 0 {
+		return true
+	}
+
+	if len(d.codeHashes) > 0 {
+		return true
+	}
+
+	if len(d.slots) > 0 {
+		return true
+	}
+
+	if len(d.transient) > 0 {
+		return true
+	}
+
+	if len(d.accessListAddresses) > 0 {
+		return true
+	}
+
+	if len(d.accessListSlots) > 0 {
+		return true
+	}
+
+	if d.refund > 0 {
+		return true
+	}
+
+	return false
+}

fvm/evm/emulator/state/stateDB.go

@@ -324,50 +324,13 @@ func (db *StateDB) SetTransientState(addr gethCommon.Address, key, value gethCom
 
 // AddressInAccessList checks if an address is in the access list
 func (db *StateDB) AddressInAccessList(addr gethCommon.Address) bool {
-	// For each static call / call / delegate call, the EVM will create
-	// a snapshot, so that it can revert to it in case of execution errors,
-	// such as out of gas etc, using `Snapshot` & `RevertToSnapshot`.
-	// This can create a long list of views, in the order of 4K for certain
-	// large transactions. To avoid performance issues with DeltaView checking parents,
-	// which causes deep stacks and function call overhead, we use a plain for-loop instead.
-	// We iterate through the views in ascending order (from lowest to highest) as an optimization.
-	// Since addresses are typically added to the AccessList early during transaction execution,
-	// this allows us to return early when the needed addresses are found in the initial views.
-	end := len(db.views)
-	for i := range end {
-		view := db.views[i]
-		if view.AddressInAccessList(addr) {
-			return true
-		}
-	}
-
-	return false
+	return db.latestView().AddressInAccessList(addr)
 }
 
 // SlotInAccessList checks if the given (address,slot) is in the access list
 func (db *StateDB) SlotInAccessList(addr gethCommon.Address, key gethCommon.Hash) (addressOk bool, slotOk bool) {
 	slotKey := types.SlotAddress{Address: addr, Key: key}
-
-	// For each static call / call / delegate call, the EVM will create
-	// a snapshot, so that it can revert to it in case of execution errors,
-	// such as out of gas etc, using `Snapshot` & `RevertToSnapshot`.
-	// This can create a long list of views, in the order of 4K for certain
-	// large transactions. To avoid performance issues with DeltaView checking parents,
-	// which causes deep stacks and function call overhead, we use a plain for-loop instead.
-	// We iterate through the views in ascending order (from lowest to highest) as an optimization.
-	// Since slots are typically added to the AccessList early during transaction execution,
-	// this allows us to return early when the needed slots are found in the initial views.
-	addressFound := false
-	end := len(db.views)
-	for i := range end {
-		view := db.views[i]
-		addressFound, slotFound := view.SlotInAccessList(slotKey)
-		if slotFound {
-			return addressFound, true
-		}
-	}
-
-	return addressFound, false
+	return db.latestView().SlotInAccessList(slotKey)
 }
 
 // AddAddressToAccessList adds the given address to the access list.