gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Credit transaction fees to the slot leader

Browse Source
This commit is contained in:
Pankaj Garg
2019-02-19 15:41:40 -08:00
committed by Greg Fitzgerald
parent 3d00992c95
commit a27cdf55e7
4 changed files with 73 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
src/blocktree_processor.rs
View File

@@ -56,22 +56,27 @@ fn ignore_program_errors(results: Vec<Result<()>>) -> Vec<Result<()>> {
.collect()
}
fn par_execute_entries(bank: &Bank, entries: &[(&Entry, Vec<Result<()>>)]) -> Result<()> {
fn par_execute_entries(bank: &Bank, entries: &[(&Entry, Vec<Result<()>>)]) -> (Result<()>, u64) {
inc_new_counter_info!("bank-par_execute_entries-count", entries.len());
let results: Vec<Result<()>> = entries
let results_fees: Vec<(Result<()>, u64)> = entries
.into_par_iter()
.map(|(e, lock_results)| {
let old_results = bank.load_execute_and_commit_transactions(
let (old_results, fee) = bank.load_execute_and_commit_transactions(
&e.transactions,
lock_results.to_vec(),
MAX_ENTRY_IDS,
);
let results = ignore_program_errors(old_results);
bank.unlock_accounts(&e.transactions, &results);
first_err(&results)
(first_err(&results), fee)
})
.collect();
first_err(&results)
let fee = results_fees.iter().map(|(_, fee)| fee).sum();
let mut results = Vec::new();
results.reserve_exact(results_fees.len());
results = results_fees.into_iter().map(|(res, _)| res).collect();
(first_err(&results[..]), fee)
}
/// process entries in parallel
@@ -83,13 +88,18 @@ fn par_process_entries_with_scheduler(
bank: &Bank,
entries: &[Entry],
leader_scheduler: &Arc<RwLock<LeaderScheduler>>,
) -> Result<()> {
) -> (Result<()>, u64) {
// accumulator for entries that can be processed in parallel
let mut mt_group = vec![];
let mut fees = 0;
for entry in entries {
if entry.is_tick() {
// if its a tick, execute the group and register the tick
par_execute_entries(bank, &mt_group)?;
let (res, fee) = par_execute_entries(bank, &mt_group);
fees += fee;
if res.is_err() {
return (res, fees);
}
bank.register_tick(&entry.id);
leader_scheduler
.write()
@@ -103,7 +113,11 @@ fn par_process_entries_with_scheduler(
// if any of the locks error out
// execute the current group
if first_err(&lock_results).is_err() {
par_execute_entries(bank, &mt_group)?;
let (res, fee) = par_execute_entries(bank, &mt_group);
fees += fee;
if res.is_err() {
return (res, fees);
}
mt_group = vec![];
//reset the lock and push the entry
bank.unlock_accounts(&entry.transactions, &lock_results);
@@ -114,8 +128,9 @@ fn par_process_entries_with_scheduler(
mt_group.push((entry, lock_results));
}
}
par_execute_entries(bank, &mt_group)?;
Ok(())
let (res, fee) = par_execute_entries(bank, &mt_group);
fees += fee;
(res, fees)
}
/// Process an ordered list of entries.
@@ -123,7 +138,7 @@ pub fn process_entries(
bank: &Bank,
entries: &[Entry],
leader_scheduler: &Arc<RwLock<LeaderScheduler>>,
) -> Result<()> {
) -> (Result<()>, u64) {
par_process_entries_with_scheduler(bank, entries, leader_scheduler)
}
@@ -389,7 +404,7 @@ mod tests {
fn par_process_entries(bank: &Bank, entries: &[Entry]) -> Result<()> {
let leader_scheduler = Arc::new(RwLock::new(LeaderScheduler::default()));
par_process_entries_with_scheduler(bank, entries, &leader_scheduler)
par_process_entries_with_scheduler(bank, entries, &leader_scheduler).0
}
fn create_sample_block_with_next_entries_using_keypairs(

25
src/replay_stage.rs
View File

@@ -65,6 +65,7 @@ impl ReplayStage {
last_entry_id: &Arc<RwLock<Hash>>,
leader_scheduler: &Arc<RwLock<LeaderScheduler>>,
subscriptions: &Arc<RpcSubscriptions>,
fees: &mut u64,
) -> Result<()> {
// Coalesce all the available entries into a single vote
submit(
@@ -108,7 +109,10 @@ impl ReplayStage {
// If we don't process the entry now, the for loop will exit and the entry
// will be dropped.
if 0 == num_ticks_to_next_vote || (i + 1) == entries.len() {
res = blocktree_processor::process_entries(bank, &entries[0..=i], leader_scheduler);
let (res_int, fee) =
blocktree_processor::process_entries(bank, &entries[0..=i], leader_scheduler);
res = res_int;
*fees += fee;
if res.is_err() {
// TODO: This will return early from the first entry that has an erroneous
@@ -123,6 +127,19 @@ impl ReplayStage {
if 0 == num_ticks_to_next_vote {
subscriptions.notify_subscribers(&bank);
let slot_num = leader_scheduler
.read()
.unwrap()
.tick_height_to_slot(num_ticks);
if let Some(leader) = leader_scheduler
.read()
.unwrap()
.get_leader_for_slot(slot_num)
{
// Credit the accumulated fees to the current leader and reset the fee to 0
bank.collect_tx_fee(&leader, *fees);
*fees = 0;
}
if let Some(voting_keypair) = voting_keypair {
let keypair = voting_keypair.as_ref();
let vote = VoteTransaction::new_vote(
@@ -207,6 +224,8 @@ impl ReplayStage {
)
};
let mut fees = 0;
// Loop through blocktree MAX_ENTRY_RECV_PER_ITER entries at a time for each
// relevant slot to see if there are any available updates
loop {
@@ -268,6 +287,7 @@ impl ReplayStage {
&last_entry_id,
&leader_scheduler_,
&subscriptions_,
&mut fees,
) {
error!("process_entries failed: {:?}", e);
}
@@ -756,6 +776,7 @@ mod test {
let leader_scheduler_config = LeaderSchedulerConfig::default();
let leader_scheduler = LeaderScheduler::new_with_bank(&leader_scheduler_config, &bank);
let leader_scheduler = Arc::new(RwLock::new(leader_scheduler));
let mut fee = 0;
let res = ReplayStage::process_entries(
entries.clone(),
&bank,
@@ -766,6 +787,7 @@ mod test {
&Arc::new(RwLock::new(last_entry_id)),
&leader_scheduler,
&Arc::new(RpcSubscriptions::default()),
&mut fee,
);
match res {
@@ -792,6 +814,7 @@ mod test {
&Arc::new(RwLock::new(last_entry_id)),
&leader_scheduler,
&Arc::new(RpcSubscriptions::default()),
&mut fee,
);
match res {