ledger: Build the grouped slot leaders manually (#8451)

* ledger: Build the grouped slot leaders manually

Building them with `itertools::into_group_map` takes 20.9ms.

Building them manually with a pre-allocated hash map, using pubkey
hasher, takes 5.2ms.

* leader-schedule: Use `HashMap::default()`

It works even with a custom hasher.

* leader-schedule: Change `&mut Vec<usize>` to `&mut Vec<_>`

* leader-schedule: Rename `slot` to `index` where appropriate

In the context of enumeration in leader schedule, `index` is a more
appropriate name.

Author: vadorovsky

leader-schedule/Cargo.toml

@@ -24,14 +24,13 @@ agave-random = { workspace = true }
 itertools = { workspace = true }
 rand_chacha = { workspace = true }
 solana-clock = { workspace = true }
-solana-pubkey = { workspace = true }
+solana-pubkey = { workspace = true, features = ["rand"] }
 solana-vote = { workspace = true }
 
 [dev-dependencies]
 bs58 = { workspace = true, features = ["alloc"] }
 rand = { workspace = true }
 sha2 = { workspace = true }
-solana-pubkey = { workspace = true, features = ["rand"] }
 solana-vote = { path = "../vote", features = ["agave-unstable-api", "dev-context-only-utils"] }
 test-case = { workspace = true }
 

leader-schedule/src/vote_keyed.rs

@@ -1,8 +1,7 @@
 use {
     super::{SlotLeader, stake_weighted_slot_leaders},
-    itertools::Itertools,
     solana_clock::Epoch,
-    solana_pubkey::Pubkey,
+    solana_pubkey::{Pubkey, PubkeyHasherBuilder},
     solana_vote::vote_account::VoteAccountsHashMap,
     std::{collections::HashMap, iter, num::NonZeroUsize, ops::Index},
 };
@@ -11,7 +10,7 @@ use {
 pub struct LeaderSchedule {
     slot_leaders: Vec<SlotLeader>,
     // Inverted index from leader id to indices where they are the leader.
-    leader_slots_map: HashMap<Pubkey, Vec<usize>>,
+    leader_slots_map: HashMap<Pubkey, Vec<usize>, PubkeyHasherBuilder>,
     repeat: NonZeroUsize,
 }
 
@@ -47,24 +46,42 @@ impl LeaderSchedule {
             })
             .collect();
         let slot_leaders = stake_weighted_slot_leaders(slot_leader_stakes, epoch, len, repeat);
-        Self::new_from_schedule(slot_leaders, repeat)
+        Self {
+            leader_slots_map: Self::invert_slot_leaders(
+                &slot_leaders,
+                Some(vote_accounts_map.len()),
+            ),
+            slot_leaders,
+            repeat,
+        }
     }
 
     pub fn new_from_schedule(slot_leaders: Vec<SlotLeader>, repeat: NonZeroUsize) -> Self {
-        let leader_slots_map = Self::invert_slot_leaders(&slot_leaders);
+        let leader_slots_map = Self::invert_slot_leaders(&slot_leaders, None);
         Self {
             slot_leaders,
             leader_slots_map,
             repeat,
         }
     }
 
-    fn invert_slot_leaders(slot_leaders: &[SlotLeader]) -> HashMap<Pubkey, Vec<usize>> {
-        slot_leaders
-            .iter()
-            .enumerate()
-            .map(|(i, leader)| (leader.id, i))
-            .into_group_map()
+    fn invert_slot_leaders(
+        slot_leaders: &[SlotLeader],
+        nodes_len: Option<usize>,
+    ) -> HashMap<Pubkey, Vec<usize>, PubkeyHasherBuilder> {
+        let mut grouped_slot_leaders = match nodes_len {
+            Some(nodes_len) => {
+                HashMap::with_capacity_and_hasher(nodes_len, PubkeyHasherBuilder::default())
+            }
+            None => HashMap::default(),
+        };
+        for (index, leader) in slot_leaders.iter().enumerate() {
+            grouped_slot_leaders
+                .entry(leader.id)
+                .and_modify(|indices: &mut Vec<_>| indices.push(index))
+                .or_insert(vec![index]);
+        }
+        grouped_slot_leaders
     }
 
     pub fn get_slot_leaders(&self) -> impl Iterator<Item = &SlotLeader> {