Use Vec::with_capacity where applicable, and pass owned PendingLogEntry to avoid clone

Author: lukevalenta

crates/ct_worker/src/ctlog.rs

@@ -105,12 +105,12 @@ impl PoolState {
         }
     }
     // Add a new entry to the pool.
-    fn add(&mut self, key: LookupKey, entry: &PendingLogEntry) -> AddLeafResult {
+    fn add(&mut self, key: LookupKey, entry: PendingLogEntry) -> AddLeafResult {
         if self.pending_entries.len() >= MAX_POOL_SIZE {
             return AddLeafResult::RateLimited;
         }
         let (tx, rx) = channel((0, 0));
-        self.pending_entries.push((entry.clone(), tx));
+        self.pending_entries.push((entry, tx));
         self.pending.insert(key, rx.clone());
 
         AddLeafResult::Pending {
@@ -388,7 +388,7 @@ pub(crate) enum PendingSource {
 pub(crate) fn add_leaf_to_pool(
     state: &mut PoolState,
     cache: &impl CacheRead,
-    entry: &PendingLogEntry,
+    entry: PendingLogEntry,
 ) -> AddLeafResult {
     let hash = entry.lookup_key();
 
@@ -546,8 +546,8 @@ async fn sequence_entries(
     }
     let mut overlay = HashMap::new();
     let mut n = old_size;
-    let mut sequenced_entries: Vec<LogEntry> = Vec::new();
-    let mut sequenced_metadata = Vec::new();
+    let mut sequenced_entries: Vec<LogEntry> = Vec::with_capacity(entries.len());
+    let mut sequenced_metadata = Vec::with_capacity(entries.len());
 
     for (entry, sender) in entries {
         let sequenced_entry = LogEntry {
@@ -917,7 +917,7 @@ async fn read_and_verify_tiles(
     }
 
     // Fetch all the tile data.
-    let mut data = Vec::new();
+    let mut data = Vec::with_capacity(tiles.len());
     for tile in &tiles {
         let result = object
             .fetch(&tile.path())
@@ -1124,7 +1124,7 @@ mod tests {
                     certificate,
                     ..Default::default()
                 };
-                add_leaf_to_pool(&mut log.pool_state, &log.cache, &leaf);
+                add_leaf_to_pool(&mut log.pool_state, &log.cache, leaf);
             }
             log.sequence().unwrap();
         }
@@ -1914,7 +1914,7 @@ mod tests {
 
             block_on(upload_issuers(&self.object, issuers, &self.config.name)).unwrap();
 
-            add_leaf_to_pool(&mut self.pool_state, &self.cache, &leaf)
+            add_leaf_to_pool(&mut self.pool_state, &self.cache, leaf)
         }
 
         fn check(&self, size: u64) -> u64 {
@@ -2034,7 +2034,7 @@ mod tests {
         let (tiles_with_bytes, index_tile_order) =
             block_on(read_and_verify_tiles(object, tree_size, tree_hash, indexes))?;
 
-        let mut hashes = Vec::new();
+        let mut hashes = Vec::with_capacity(indexes.len());
         for (i, &x) in indexes.iter().enumerate() {
             let j = index_tile_order[i];
             let h = tiles_with_bytes[j]

crates/ct_worker/src/sequencer_do.rs

@@ -82,7 +82,7 @@ impl DurableObject for Sequencer {
             "/add_batch" => {
                 endpoint = "add_batch";
                 let pending_entries: Vec<PendingLogEntry> = req.json().await?;
-                self.add_batch(&pending_entries).await
+                self.add_batch(pending_entries).await
             }
             _ => {
                 endpoint = "unknown";
@@ -220,15 +220,17 @@ impl Sequencer {
     // Add a batch of entries, returning a Response with metadata for
     // successfully sequenced entries. Entries that fail to be added (e.g., due to rate limiting)
     // are omitted.
-    async fn add_batch(&mut self, pending_entries: &[PendingLogEntry]) -> Result<Response> {
+    async fn add_batch(&mut self, pending_entries: Vec<PendingLogEntry>) -> Result<Response> {
         // Safe to unwrap config here as the log must be initialized.
         let mut futures = Vec::with_capacity(pending_entries.len());
+        let mut lookup_keys = Vec::with_capacity(pending_entries.len());
         for pending_entry in pending_entries {
             let typ = if pending_entry.is_precert {
                 "add-pre-chain"
             } else {
                 "add-chain"
             };
+            lookup_keys.push(pending_entry.lookup_key());
 
             let add_leaf_result = ctlog::add_leaf_to_pool(
                 &mut self.pool_state,
@@ -243,14 +245,14 @@ impl Sequencer {
 
             futures.push(add_leaf_result.resolve());
         }
-        let cache_values = join_all(futures).await;
+        let entries_metadata = join_all(futures).await;
 
         // Zip the cache keys with the cache values, filtering out entries that
         // were not sequenced (e.g., due to rate limiting).
-        let result = pending_entries
+        let result = lookup_keys
             .iter()
-            .zip(cache_values.iter())
-            .filter_map(|(entry, value)| value.as_ref().map(|v| (entry.lookup_key(), v)))
+            .zip(entries_metadata.iter())
+            .filter_map(|(key, value_opt)| value_opt.as_ref().map(|metadata| (key, metadata)))
             .collect::<Vec<_>>();
 
         Response::from_json(&result)