Create solana-poh and move remaining rpc modules to solana-rpc (#17698)

* Create solana-poh crate

* Move BigTableUploadService to solana-ledger

* Add solana-rpc to workspace

* Move dependencies to solana-rpc

* Move remaining rpc modules to solana-rpc

* Single use statement solana-poh

* Single use statement solana-rpc

poh/benches/poh.rs

@@ -0,0 +1,67 @@
+// This bench attempts to justify the value of `solana_core::poh_service::NUM_HASHES_PER_BATCH`
+
+#![feature(test)]
+extern crate test;
+
+use {
+    solana_ledger::poh::Poh,
+    solana_poh::poh_service::DEFAULT_HASHES_PER_BATCH,
+    solana_sdk::hash::Hash,
+    std::sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc, Mutex,
+    },
+    test::Bencher,
+};
+
+const NUM_HASHES: u64 = 30_000; // Should require ~10ms on a 2017 MacBook Pro
+
+#[bench]
+// No locking.  Fastest.
+fn bench_poh_hash(bencher: &mut Bencher) {
+    let mut poh = Poh::new(Hash::default(), None);
+    bencher.iter(|| {
+        poh.hash(NUM_HASHES);
+    })
+}
+
+#[bench]
+// Lock on each iteration.  Slowest.
+fn bench_arc_mutex_poh_hash(bencher: &mut Bencher) {
+    let poh = Arc::new(Mutex::new(Poh::new(Hash::default(), None)));
+    bencher.iter(|| {
+        for _ in 0..NUM_HASHES {
+            poh.lock().unwrap().hash(1);
+        }
+    })
+}
+
+#[bench]
+// Acquire lock every NUM_HASHES_PER_BATCH iterations.
+// Speed should be close to bench_poh_hash() if NUM_HASHES_PER_BATCH is set well.
+fn bench_arc_mutex_poh_batched_hash(bencher: &mut Bencher) {
+    let poh = Arc::new(Mutex::new(Poh::new(Hash::default(), Some(NUM_HASHES))));
+    //let exit = Arc::new(AtomicBool::new(false));
+    let exit = Arc::new(AtomicBool::new(true));
+
+    bencher.iter(|| {
+        // NOTE: This block attempts to look as close as possible to `PohService::tick_producer()`
+        loop {
+            if poh.lock().unwrap().hash(DEFAULT_HASHES_PER_BATCH) {
+                poh.lock().unwrap().tick().unwrap();
+                if exit.load(Ordering::Relaxed) {
+                    break;
+                }
+            }
+        }
+    })
+}
+
+#[bench]
+// Worst case transaction record delay due to batch hashing at NUM_HASHES_PER_BATCH
+fn bench_poh_lock_time_per_batch(bencher: &mut Bencher) {
+    let mut poh = Poh::new(Hash::default(), None);
+    bencher.iter(|| {
+        poh.hash(DEFAULT_HASHES_PER_BATCH);
+    })
+}

poh/benches/poh_verify.rs

@@ -0,0 +1,52 @@
+#![feature(test)]
+extern crate test;
+
+use {
+    solana_ledger::entry::{next_entry_mut, Entry, EntrySlice},
+    solana_sdk::{
+        hash::{hash, Hash},
+        signature::{Keypair, Signer},
+        system_transaction,
+    },
+    test::Bencher,
+};
+
+const NUM_HASHES: u64 = 400;
+const NUM_ENTRIES: usize = 800;
+
+#[bench]
+fn bench_poh_verify_ticks(bencher: &mut Bencher) {
+    solana_logger::setup();
+    let zero = Hash::default();
+    let start_hash = hash(&zero.as_ref());
+    let mut cur_hash = start_hash;
+
+    let mut ticks: Vec<Entry> = Vec::with_capacity(NUM_ENTRIES);
+    for _ in 0..NUM_ENTRIES {
+        ticks.push(next_entry_mut(&mut cur_hash, NUM_HASHES, vec![]));
+    }
+
+    bencher.iter(|| {
+        assert!(ticks.verify(&start_hash));
+    })
+}
+
+#[bench]
+fn bench_poh_verify_transaction_entries(bencher: &mut Bencher) {
+    let zero = Hash::default();
+    let start_hash = hash(&zero.as_ref());
+    let mut cur_hash = start_hash;
+
+    let keypair1 = Keypair::new();
+    let pubkey1 = keypair1.pubkey();
+
+    let mut ticks: Vec<Entry> = Vec::with_capacity(NUM_ENTRIES);
+    for _ in 0..NUM_ENTRIES {
+        let tx = system_transaction::transfer(&keypair1, &pubkey1, 42, cur_hash);
+        ticks.push(next_entry_mut(&mut cur_hash, NUM_HASHES, vec![tx]));
+    }
+
+    bencher.iter(|| {
+        assert!(ticks.verify(&start_hash));
+    })
+}