Pivot when beam sync lag is more than 30 blocks

trinity/sync/beam/chain.py

@@ -49,8 +49,8 @@
     BEAM_PIVOT_BUFFER_FRACTION,
     BLOCK_BACKFILL_IDLE_TIME,
     BLOCK_IMPORT_MISSING_STATE_TIMEOUT,
-    ESTIMATED_BEAMABLE_SECONDS,
     FULL_BLOCKS_NEEDED_TO_START_BEAM,
+    MAX_BEAM_SYNC_LAG,
     PAUSE_BACKFILL_AT_LAG,
     RESUME_BACKFILL_AT_LAG,
     PREDICTED_BLOCK_TIME,
@@ -655,7 +655,8 @@ async def run(self) -> None:
 
     def _is_header_eligible_to_beam_sync(self, header: BlockHeaderAPI) -> bool:
         time_gap = time.time() - header.timestamp
-        return time_gap < (ESTIMATED_BEAMABLE_SECONDS * (1 - BEAM_PIVOT_BUFFER_FRACTION))
+        estimated_max_lag_seconds = MAX_BEAM_SYNC_LAG * PREDICTED_BLOCK_TIME
+        return time_gap < (estimated_max_lag_seconds * (1 - BEAM_PIVOT_BUFFER_FRACTION))
 
     async def _persist_headers_if_tip_too_old(self) -> None:
         tip = await self._db.coro_get_canonical_head()

trinity/sync/beam/constants.py

@@ -76,6 +76,11 @@
 # It's also useful to estimate the amount of time covered by those beamable blocks.
 ESTIMATED_BEAMABLE_SECONDS = ESTIMATED_BEAMABLE_BLOCKS * PREDICTED_BLOCK_TIME
 
+# Maximum number of blocks we can lag behind the current chain head before we pivot.
+# This is a relatively low value because on mainnet, as soon as we are lagging behind 20-30
+# blocks, we're very unlikely to catch up given our block import times are high.
+MAX_BEAM_SYNC_LAG = 30
+
 # To make up for clients that are configured with unusually low block times,
 # and other surprises, we pivot earlier than we think we need to.
 # For example, if the BEAM_PIVOT_BUFFER_FRACTION is ~1/4, then pivot about 25%

trinity/sync/beam/service.py

@@ -13,7 +13,7 @@
 from trinity.db.eth1.chain import BaseAsyncChainDB
 from trinity.protocol.eth.peer import ETHPeerPool
 from trinity.sync.beam.constants import (
-    ESTIMATED_BEAMABLE_BLOCKS,
+    MAX_BEAM_SYNC_LAG,
     PREDICTED_BLOCK_TIME,
 )
 from trinity.sync.common.checkpoint import Checkpoint
@@ -99,15 +99,15 @@ async def _monitor_for_pivot(self, beam_syncer: BeamSyncer) -> bool:
                 return False
             else:
                 lag = beam_syncer.get_block_count_lag()
-                if lag > ESTIMATED_BEAMABLE_BLOCKS:
+                if lag > MAX_BEAM_SYNC_LAG:
                     self.logger.warning(
                         "Beam Sync is lagging by %d blocks. Pivoting...",
                         lag,
                     )
                     beam_syncer.get_manager().cancel()
                     return True
                 else:
-                    if lag >= ESTIMATED_BEAMABLE_BLOCKS * 0.8:
+                    if lag >= MAX_BEAM_SYNC_LAG * 0.8:
                         # Start showing the lag in info, if lagging behind a lot
                         logger = self.logger.info
                     else:
@@ -118,7 +118,7 @@ async def _monitor_for_pivot(self, beam_syncer: BeamSyncer) -> bool:
                             " will pivot above %d"
                         ),
                         lag,
-                        ESTIMATED_BEAMABLE_BLOCKS,
+                        MAX_BEAM_SYNC_LAG,
                     )
 
                     # Keep monitoring