Skip to content

Commit

Permalink
Revert "AcctIdx: throttling bg flushing to spread out work over inter…
Browse files Browse the repository at this point in the history 
…val (solana-labs#20176)"

This reverts commit 4571da0.
  • Loading branch information
@frits-metalogix
frits-metalogix authored Nov 24, 2021
1 parent 303972e commit fec5908
Show file tree
Hide file tree
Showing 2 changed files with 2 additions and 85 deletions.
81 changes: 2 additions & 79 deletions runtime/src/bucket_map_holder.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -172,64 +172,21 @@ impl<T: IndexValue> BucketMapHolder<T> {
AGE_MS
}

/// return an amount of ms to sleep
fn throttling_wait_ms_internal(
&self,
interval_ms: u64,
elapsed_ms: u64,
bins_flushed: u64,
) -> Option<u64> {
let target_percent = 90; // aim to finish in 90% of the allocated time
let remaining_ms = (interval_ms * target_percent / 100).saturating_sub(elapsed_ms);
let remaining_bins = (self.bins as u64).saturating_sub(bins_flushed);
if remaining_bins == 0 || remaining_ms == 0 || elapsed_ms == 0 || bins_flushed == 0 {
// any of these conditions result in 'do not wait due to progress'
return None;
}
let ms_per_s = 1_000;
let rate_bins_per_s = bins_flushed * ms_per_s / elapsed_ms;
let expected_bins_processed_in_remaining_time = rate_bins_per_s * remaining_ms / ms_per_s;
if expected_bins_processed_in_remaining_time > remaining_bins {
// wait because we predict will finish prior to target
Some(1)
} else {
// do not wait because we predict will finish after target
None
}
}

/// Check progress this age.
/// Return ms to wait to get closer to the wait target and spread out work over the entire age interval.
/// Goal is to avoid cpu spikes at beginning of age interval.
fn throttling_wait_ms(&self) -> Option<u64> {
let interval_ms = self.age_interval_ms();
let elapsed_ms = self.age_timer.elapsed_ms();
let bins_flushed = self.count_ages_flushed() as u64;
self.throttling_wait_ms_internal(interval_ms, elapsed_ms, bins_flushed)
}

// intended to execute in a bg thread
pub fn background(&self, exit: Arc<AtomicBool>, in_mem: Vec<Arc<InMemAccountsIndex<T>>>) {
let bins = in_mem.len();
let flush = self.disk.is_some();
let mut throttling_wait_ms = None;
loop {
if !flush {
self.wait_dirty_or_aged.wait_timeout(Duration::from_millis(
self.stats.remaining_until_next_interval(),
));
} else if self.all_buckets_flushed_at_current_age() || throttling_wait_ms.is_some() {
let mut wait = std::cmp::min(
} else if self.all_buckets_flushed_at_current_age() {
let wait = std::cmp::min(
self.age_timer
.remaining_until_next_interval(self.age_interval_ms()),
self.stats.remaining_until_next_interval(),
);
if let Some(throttling_wait_ms) = throttling_wait_ms {
self.stats
.bg_throttling_wait_us
.fetch_add(throttling_wait_ms * 1000, Ordering::Relaxed);
wait = std::cmp::min(throttling_wait_ms, wait);
}

let mut m = Measure::start("wait");
self.wait_dirty_or_aged
Expand All @@ -241,7 +198,6 @@ impl<T: IndexValue> BucketMapHolder<T> {
// likely some time has elapsed. May have been waiting for age time interval to elapse.
self.maybe_advance_age();
}
throttling_wait_ms = None;

if exit.load(Ordering::Relaxed) {
break;
Expand All @@ -257,10 +213,6 @@ impl<T: IndexValue> BucketMapHolder<T> {
if self.all_buckets_flushed_at_current_age() {
break;
}
throttling_wait_ms = self.throttling_wait_ms();
if throttling_wait_ms.is_some() {
break;
}
}
self.stats.active_threads.fetch_sub(1, Ordering::Relaxed);
}
Expand Down Expand Up @@ -318,35 +270,6 @@ pub mod tests {
}
}

#[test]
fn test_throttle() {
solana_logger::setup();
let bins = 100;
let test = BucketMapHolder::<u64>::new(bins, &Some(AccountsIndexConfig::default()), 1);
let bins = test.bins as u64;
let interval_ms = test.age_interval_ms();
// 90% of time elapsed, all but 1 bins flushed, should not wait since we'll end up right on time
let elapsed_ms = interval_ms * 89 / 100;
let bins_flushed = bins - 1;
let result = test.throttling_wait_ms_internal(interval_ms, elapsed_ms, bins_flushed);
assert_eq!(result, None);
// 10% of time, all bins but 1, should wait
let elapsed_ms = interval_ms / 10;
let bins_flushed = bins - 1;
let result = test.throttling_wait_ms_internal(interval_ms, elapsed_ms, bins_flushed);
assert_eq!(result, Some(1));
// 5% of time, 8% of bins, should wait. target is 90%. These #s roughly work
let elapsed_ms = interval_ms * 5 / 100;
let bins_flushed = bins * 8 / 100;
let result = test.throttling_wait_ms_internal(interval_ms, elapsed_ms, bins_flushed);
assert_eq!(result, Some(1));
// 11% of time, 12% of bins, should NOT wait. target is 90%. These #s roughly work
let elapsed_ms = interval_ms * 11 / 100;
let bins_flushed = bins * 12 / 100;
let result = test.throttling_wait_ms_internal(interval_ms, elapsed_ms, bins_flushed);
assert_eq!(result, None);
}

#[test]
fn test_age_time() {
solana_logger::setup();
Expand Down
6 changes: 0 additions & 6 deletions runtime/src/bucket_map_holder_stats.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,7 +28,6 @@ pub struct BucketMapHolderStats {
pub inserts: AtomicU64,
pub count: AtomicU64,
pub bg_waiting_us: AtomicU64,
pub bg_throttling_wait_us: AtomicU64,
pub count_in_mem: AtomicU64,
pub per_bucket_count: Vec<AtomicU64>,
pub flush_entries_updated_on_disk: AtomicU64,
Expand Down Expand Up @@ -135,11 +134,6 @@ impl BucketMapHolderStats {
self.bg_waiting_us.swap(0, Ordering::Relaxed),
i64
),
(
"bg_throttling_wait_us",
self.bg_throttling_wait_us.swap(0, Ordering::Relaxed),
i64
),
("min_in_bin", min, i64),
("max_in_bin", max, i64),
("count_from_bins", ct, i64),
Expand Down

0 comments on commit fec5908

Please sign in to comment.