refactor(host-listener): clarify slow-lane naming

Author: Eikix

coprocessor/fhevm-engine/host-listener/src/database/ingest.rs

@@ -28,7 +28,7 @@ pub struct IngestOptions {
     pub dependent_ops_max_per_chain: u32,
 }
 
-fn compute_schedule_priorities(
+fn classify_slow_lane_priorities(
     chains: &[Chain],
     dependent_ops_by_chain: &HashMap<ChainHash, u64>,
     dependent_ops_max_per_chain: u32,
@@ -182,7 +182,7 @@ pub async fn ingest_block_logs(
     .await;
 
     let slow_lane_enabled = options.dependent_ops_max_per_chain > 0;
-    let seen_chain_ids = if slow_lane_enabled {
+    let seen_dep_chain_ids = if slow_lane_enabled {
         Vec::new()
     } else {
         chains.iter().map(|chain| chain.hash.to_vec()).collect()
@@ -212,7 +212,7 @@ pub async fn ingest_block_logs(
     let mut schedule_priority_by_chain = HashMap::new();
     if slow_lane_enabled {
         let (schedule_priorities, allowed, throttled) =
-            compute_schedule_priorities(
+            classify_slow_lane_priorities(
                 &chains,
                 &dependent_ops_by_chain,
                 options.dependent_ops_max_per_chain,
@@ -245,7 +245,10 @@ pub async fn ingest_block_logs(
     }
     if !slow_lane_enabled {
         let promoted = db
-            .promote_seen_schedule_priorities_fast(&mut tx, &seen_chain_ids)
+            .promote_seen_dep_chains_to_fast_priority(
+                &mut tx,
+                &seen_dep_chain_ids,
+            )
             .await?;
         if promoted > 0 {
             info!(
@@ -261,10 +264,10 @@ pub async fn ingest_block_logs(
 mod tests {
     use fhevm_engine_common::types::SchedulePriority;
 
-    use super::compute_schedule_priorities;
+    use super::classify_slow_lane_priorities;
     use crate::database::tfhe_event_propagate::{Chain, ChainHash};
 
-    fn mk_chain(last_byte: u8) -> Chain {
+    fn fixture_dep_chain(last_byte: u8) -> Chain {
         Chain {
             hash: ChainHash::with_last_byte(last_byte),
             dependencies: vec![],
@@ -277,32 +280,32 @@ mod tests {
     }
 
     #[test]
-    fn compute_schedule_priorities_cap_zero_disables() {
-        let chains = vec![mk_chain(1)];
+    fn classify_slow_lane_priorities_cap_zero_disables() {
+        let chains = vec![fixture_dep_chain(1)];
         let mut by_chain = std::collections::HashMap::new();
         by_chain.insert(chains[0].hash, 10_u64);
 
         let (priorities, allowed, throttled) =
-            compute_schedule_priorities(&chains, &by_chain, 0);
+            classify_slow_lane_priorities(&chains, &by_chain, 0);
 
         assert!(priorities.is_empty());
         assert_eq!(allowed, 0);
         assert_eq!(throttled, 0);
     }
 
     #[test]
-    fn compute_schedule_priorities_marks_only_over_limit() {
-        let chain_fast = mk_chain(1);
-        let chain_slow = mk_chain(2);
-        let chain_missing = mk_chain(3);
+    fn classify_slow_lane_priorities_marks_only_over_limit() {
+        let chain_fast = fixture_dep_chain(1);
+        let chain_slow = fixture_dep_chain(2);
+        let chain_missing = fixture_dep_chain(3);
         let chains =
             vec![chain_fast.clone(), chain_slow.clone(), chain_missing];
         let mut by_chain = std::collections::HashMap::new();
         by_chain.insert(chain_fast.hash, 3_u64);
         by_chain.insert(chain_slow.hash, 5_u64);
 
         let (priorities, allowed, throttled) =
-            compute_schedule_priorities(&chains, &by_chain, 4);
+            classify_slow_lane_priorities(&chains, &by_chain, 4);
 
         assert_eq!(allowed, 3);
         assert_eq!(throttled, 5);

coprocessor/fhevm-engine/host-listener/src/database/tfhe_event_propagate.rs

@@ -175,12 +175,12 @@ impl Database {
         }
     }
 
-    pub async fn promote_seen_schedule_priorities_fast(
+    pub async fn promote_seen_dep_chains_to_fast_priority(
         &self,
         tx: &mut Transaction<'_>,
-        seen_chain_ids: &[Vec<u8>],
+        seen_dep_chain_ids: &[Vec<u8>],
     ) -> Result<u64, SqlxError> {
-        if seen_chain_ids.is_empty() {
+        if seen_dep_chain_ids.is_empty() {
             return Ok(0);
         }
 
@@ -192,7 +192,7 @@ impl Database {
               AND dc.dependence_chain_id = ANY($1::bytea[])
             "#,
         )
-        .bind(seen_chain_ids)
+        .bind(seen_dep_chain_ids)
         .execute(tx.deref_mut())
         .await?;
         Ok(rows.rows_affected())
@@ -842,7 +842,7 @@ impl Database {
         schedule_priority_by_chain: &HashMap<ChainHash, SchedulePriority>,
     ) -> Result<(), SqlxError> {
         for chain in chains {
-            let chain_id = chain.hash.to_vec();
+            let dep_chain_id = chain.hash.to_vec();
             let schedule_priority = *schedule_priority_by_chain
                 .get(&chain.hash)
                 .unwrap_or(&SchedulePriority::FAST);
@@ -886,7 +886,7 @@ impl Database {
                         EXCLUDED.schedule_priority
                     )
                 "#,
-                chain_id,
+                dep_chain_id,
                 last_updated_at,
                 chain.dependencies.len() as i64,
                 &dependents,