blockworks-foundation
/
solana-with-rpc-optimizations
mirror of https://github.com/blockworks-foundation/solana-with-rpc-optimizations.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

add last_id to Entry, PohEntry (#1783) 

add prev_id to Entry, PohEntry
This commit is contained in:
Rob Walker 2018-11-12 17:03:23 -08:00 committed by GitHub
parent 851e012c6c
commit fa72160c95
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 82 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/cluster_info.rs
View File

@ -1670,8 +1670,12 @@ mod tests {
let zero = Hash::default();
let one = hash(&zero.as_ref());
writer
.write_entries(&vec![Entry::new_tick(0, &zero), Entry::new_tick(0, &one)].to_vec())
.unwrap();
.write_entries(
&vec![
Entry::new_tick(&zero, 0, &zero),
Entry::new_tick(&one, 0, &one),
].to_vec(),
).unwrap();
path
}

36
src/entry.rs
View File

@ -33,6 +33,9 @@ pub type EntryReceiver = Receiver<Vec<Entry>>;
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
pub struct Entry {
/// The the previous Entry ID.
pub prev_id: Hash,
/// The number of hashes since the previous Entry ID.
pub num_hashes: u64,
@ -47,19 +50,21 @@ pub struct Entry {
impl Entry {
/// Creates the next Entry `num_hashes` after `start_hash`.
pub fn new(start_hash: &Hash, num_hashes: u64, transactions: Vec<Transaction>) -> Self {
pub fn new(prev_id: &Hash, num_hashes: u64, transactions: Vec<Transaction>) -> Self {
let entry = {
if num_hashes == 0 && transactions.is_empty() {
Entry {
prev_id: *prev_id,
num_hashes: 0,
id: *start_hash,
id: *prev_id,
transactions,
}
} else if num_hashes == 0 {
// If you passed in transactions, but passed in num_hashes == 0, then
// next_hash will generate the next hash and set num_hashes == 1
let id = next_hash(start_hash, 1, &transactions);
let id = next_hash(prev_id, 1, &transactions);
Entry {
prev_id: *prev_id,
num_hashes: 1,
id,
transactions,
@ -68,8 +73,9 @@ impl Entry {
// Otherwise, the next Entry `num_hashes` after `start_hash`.
// If you wanted a tick for instance, then pass in num_hashes = 1
// and transactions = empty
let id = next_hash(start_hash, num_hashes, &transactions);
let id = next_hash(prev_id, num_hashes, &transactions);
Entry {
prev_id: *prev_id,
num_hashes,
id,
transactions,
@ -121,7 +127,10 @@ impl Entry {
/// Estimate serialized_size of Entry without creating an Entry.
pub fn serialized_size(transactions: &[Transaction]) -> u64 {
let txs_size = serialized_size(transactions).unwrap();
size_of::<u64>() as u64 + size_of::<Hash>() as u64 + txs_size
// num_hashes + id + prev_id + txs
(size_of::<u64>() + 2 * size_of::<Hash>()) as u64 + txs_size
}
pub fn num_will_fit(transactions: &[Transaction]) -> usize {
@ -175,14 +184,19 @@ impl Entry {
/// Creates a Entry from the number of hashes `num_hashes` since the previous transaction
/// and that resulting `id`.
pub fn new_tick(num_hashes: u64, id: &Hash) -> Self {
pub fn new_tick(prev_id: &Hash, num_hashes: u64, id: &Hash) -> Self {
Entry {
prev_id: *prev_id,
num_hashes,
id: *id,
transactions: vec![],
}
}
pub fn verify_self(&self) -> bool {
self.id == next_hash(&self.prev_id, self.num_hashes, &self.transactions)
}
/// Verifies self.id is the result of hashing a `start_hash` `self.num_hashes` times.
/// If the transaction is not a Tick, then hash that as well.
pub fn verify(&self, start_hash: &Hash) -> bool {
@ -225,11 +239,12 @@ fn next_hash(start_hash: &Hash, num_hashes: u64, transactions: &[Transaction]) -
}
/// Creates the next Tick or Transaction Entry `num_hashes` after `start_hash`.
pub fn next_entry(start_hash: &Hash, num_hashes: u64, transactions: Vec<Transaction>) -> Entry {
pub fn next_entry(prev_id: &Hash, num_hashes: u64, transactions: Vec<Transaction>) -> Entry {
assert!(num_hashes > 0 || transactions.is_empty());
Entry {
prev_id: *prev_id,
num_hashes,
id: next_hash(start_hash, num_hashes, &transactions),
id: next_hash(prev_id, num_hashes, &transactions),
transactions,
}
}
@ -249,9 +264,10 @@ mod tests {
fn test_entry_verify() {
let zero = Hash::default();
let one = hash(&zero.as_ref());
assert!(Entry::new_tick(0, &zero).verify(&zero)); // base case
assert!(!Entry::new_tick(0, &zero).verify(&one)); // base case, bad
assert!(Entry::new_tick(&zero, 0, &zero).verify(&zero)); // base case, never used
assert!(!Entry::new_tick(&zero, 0, &zero).verify(&one)); // base case, bad
assert!(next_entry(&zero, 1, vec![]).verify(&zero)); // inductive step
assert!(next_entry(&zero, 1, vec![]).verify_self()); // also inductive step
assert!(!next_entry(&zero, 1, vec![]).verify(&one)); // inductive step, bad
}

7
src/ledger.rs
View File

@ -463,7 +463,7 @@ pub trait Block {
impl Block for [Entry] {
fn verify(&self, start_hash: &Hash) -> bool {
let genesis = [Entry::new_tick(0, start_hash)];
let genesis = [Entry::new_tick(start_hash, 0, start_hash)];
let entry_pairs = genesis.par_iter().chain(self).zip(self);
entry_pairs.all(|(x0, x1)| {
let r = x1.verify(&x0.id);
@ -710,8 +710,8 @@ mod tests {
let zero = Hash::default();
let one = hash(&zero.as_ref());
assert!(vec![][..].verify(&zero)); // base case
assert!(vec![Entry::new_tick(0, &zero)][..].verify(&zero)); // singleton case 1
assert!(!vec![Entry::new_tick(0, &zero)][..].verify(&one)); // singleton case 2, bad
assert!(vec![Entry::new_tick(&zero, 0, &zero)][..].verify(&zero)); // singleton case 1
assert!(!vec![Entry::new_tick(&zero, 0, &zero)][..].verify(&one)); // singleton case 2, bad
assert!(vec![next_entry(&zero, 0, vec![]); 2][..].verify(&zero)); // inductive step
let mut bad_ticks = vec![next_entry(&zero, 0, vec![]); 2];
@ -781,6 +781,7 @@ mod tests {
let tx_small_size = serialized_size(&tx_small).unwrap() as usize;
let tx_large_size = serialized_size(&tx_large).unwrap() as usize;
let entry_size = serialized_size(&Entry {
prev_id: Hash::default(),
num_hashes: 0,
id: Hash::default(),
transactions: vec![],

46
src/poh.rs
View File

@ -3,40 +3,48 @@
use hash::{hash, hashv, Hash};
pub struct Poh {
last_hash: Hash,
prev_id: Hash,
id: Hash,
num_hashes: u64,
pub tick_height: u64,
}
#[derive(Debug)]
pub struct PohEntry {
pub prev_id: Hash,
pub num_hashes: u64,
pub id: Hash,
pub mixin: Option<Hash>,
}
impl Poh {
pub fn new(last_hash: Hash, tick_height: u64) -> Self {
pub fn new(prev_id: Hash, tick_height: u64) -> Self {
Poh {
last_hash,
prev_id,
num_hashes: 0,
id: prev_id,
tick_height,
}
}
pub fn hash(&mut self) {
self.last_hash = hash(&self.last_hash.as_ref());
self.id = hash(&self.id.as_ref());
self.num_hashes += 1;
}
pub fn record(&mut self, mixin: Hash) -> PohEntry {
let num_hashes = self.num_hashes + 1;
self.last_hash = hashv(&[&self.last_hash.as_ref(), &mixin.as_ref()]);
self.id = hashv(&[&self.id.as_ref(), &mixin.as_ref()]);
let prev_id = self.prev_id;
self.prev_id = self.id;
let num_hashes = self.num_hashes + 1;
self.num_hashes = 0;
PohEntry {
prev_id,
num_hashes,
id: self.last_hash,
id: self.id,
mixin: Some(mixin),
}
}
@ -48,11 +56,16 @@ impl Poh {
let num_hashes = self.num_hashes;
self.num_hashes = 0;
let prev_id = self.prev_id;
self.prev_id = self.id;
self.tick_height += 1;
PohEntry {
prev_id,
num_hashes,
id: self.last_hash,
id: self.id,
mixin: None,
}
}
@ -60,21 +73,22 @@ impl Poh {
#[cfg(test)]
pub fn verify(initial: Hash, entries: &[PohEntry]) -> bool {
let mut last_hash = initial;
let mut prev_id = initial;
for entry in entries {
assert!(entry.num_hashes != 0);
assert!(prev_id == entry.prev_id);
for _ in 1..entry.num_hashes {
last_hash = hash(&last_hash.as_ref());
prev_id = hash(&prev_id.as_ref());
}
let id = match entry.mixin {
Some(mixin) => hashv(&[&last_hash.as_ref(), &mixin.as_ref()]),
None => hash(&last_hash.as_ref()),
prev_id = match entry.mixin {
Some(mixin) => hashv(&[&prev_id.as_ref(), &mixin.as_ref()]),
None => hash(&prev_id.as_ref()),
};
if id != entry.id {
if prev_id != entry.id {
return false;
}
last_hash = id;
}
true
@ -91,10 +105,12 @@ mod tests {
poh::verify(
Hash::default(),
&[PohEntry {
prev_id: Hash::default(),
num_hashes: 0,
id: Hash::default(),
mixin: None,
}],
);
}
}

32
src/poh_recorder.rs
View File

@ -80,15 +80,6 @@ impl PohRecorder {
}
}
fn generate_tick_entry(&self, poh: &mut Poh) -> Entry {
let tick = poh.tick();
Entry {
num_hashes: tick.num_hashes,
id: tick.id,
transactions: vec![],
}
}
fn is_max_tick_height_reached(&self, poh: &Poh) -> bool {
if let Some(max_tick_height) = self.max_tick_height {
poh.tick_height >= max_tick_height
@ -98,11 +89,12 @@ impl PohRecorder {
}
fn record_and_send_txs(&self, poh: &mut Poh, mixin: Hash, txs: Vec<Transaction>) -> Result<()> {
let tick = poh.record(mixin);
let entry = poh.record(mixin);
assert!(!txs.is_empty(), "Entries without transactions are used to track real-time passing in the ledger and can only be generated with PohRecorder::tick function");
let entry = Entry {
num_hashes: tick.num_hashes,
id: tick.id,
prev_id: entry.prev_id,
num_hashes: entry.num_hashes,
id: entry.id,
transactions: txs,
};
self.sender.send(vec![entry])?;
@ -110,9 +102,15 @@ impl PohRecorder {
}
fn register_and_send_tick(&self, poh: &mut Poh) -> Result<()> {
let tick_entry = self.generate_tick_entry(poh);
self.bank.register_tick(&tick_entry.id);
self.sender.send(vec![tick_entry])?;
let tick = poh.tick();
let tick = Entry {
prev_id: tick.prev_id,
num_hashes: tick.num_hashes,
id: tick.id,
transactions: vec![],
};
self.bank.register_tick(&tick.id);
self.sender.send(vec![tick])?;
Ok(())
}
}
@ -130,9 +128,9 @@ mod tests {
fn test_poh() {
let mint = Mint::new(1);
let bank = Arc::new(Bank::new(&mint));
let last_id = bank.last_id();
let prev_id = bank.last_id();
let (entry_sender, entry_receiver) = channel();
let mut poh_recorder = PohRecorder::new(bank, entry_sender, last_id, None);
let mut poh_recorder = PohRecorder::new(bank, entry_sender, prev_id, None);
//send some data
let h1 = hash(b"hello world!");