mirror of
https://github.com/mimblewimble/grin.git
synced 2025-01-21 11:31:08 +03:00
110 lines
3.1 KiB
Rust
110 lines
3.1 KiB
Rust
// Copyright 2019 The Grin Developers
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
/// Utility to track the rate of data transfers
|
|
use std::time::{Duration, SystemTime};
|
|
|
|
struct Entry {
|
|
bytes: u64,
|
|
timestamp: u64,
|
|
}
|
|
|
|
impl Entry {
|
|
fn new(bytes: u64) -> Entry {
|
|
Entry {
|
|
bytes,
|
|
timestamp: millis_since_epoch(),
|
|
}
|
|
}
|
|
|
|
// Create new "quiet" entry with zero timestamp.
|
|
// This will count toward total bytes but will not affect the "msg rate".
|
|
fn new_quiet(bytes: u64) -> Entry {
|
|
Entry {
|
|
bytes,
|
|
timestamp: 0,
|
|
}
|
|
}
|
|
|
|
// We want to filter out "quiet" entries when calculating the "msg rate".
|
|
fn is_quiet(&self) -> bool {
|
|
self.timestamp == 0
|
|
}
|
|
}
|
|
|
|
/// A rate counter tracks the number of transfers, the amount of data
|
|
/// exchanged and the rate of transfer (via a few timers) over the last
|
|
/// minute. The counter does not try to be accurate and update times
|
|
/// proactively, instead it only does so lazily. As a result, produced
|
|
/// rates are worst-case estimates.
|
|
pub struct RateCounter {
|
|
last_min_entries: Vec<Entry>,
|
|
}
|
|
|
|
impl RateCounter {
|
|
/// Instantiate a new rate counter
|
|
pub fn new() -> RateCounter {
|
|
RateCounter {
|
|
last_min_entries: vec![],
|
|
}
|
|
}
|
|
|
|
/// Increments number of bytes transferred, updating counts and rates.
|
|
pub fn inc(&mut self, bytes: u64) {
|
|
self.last_min_entries.push(Entry::new(bytes));
|
|
self.truncate();
|
|
}
|
|
|
|
/// Increments number of bytes without updating the count or rate.
|
|
/// We filter out 0 last_min_times when calculating rate.
|
|
/// Used during txhashset.zip download to track bytes downloaded
|
|
/// without treating a peer as abusive (too high a rate of download).
|
|
pub fn inc_quiet(&mut self, bytes: u64) {
|
|
self.last_min_entries.push(Entry::new_quiet(bytes));
|
|
self.truncate();
|
|
}
|
|
|
|
fn truncate(&mut self) {
|
|
let now_millis = millis_since_epoch();
|
|
while !self.last_min_entries.is_empty()
|
|
&& self.last_min_entries[0].timestamp + 60000 < now_millis
|
|
{
|
|
self.last_min_entries.remove(0);
|
|
}
|
|
}
|
|
|
|
/// Number of bytes counted in the last minute.
|
|
/// Includes "quiet" byte increments.
|
|
pub fn bytes_per_min(&self) -> u64 {
|
|
self.last_min_entries.iter().map(|x| x.bytes).sum()
|
|
}
|
|
|
|
/// Count of increases in the last minute.
|
|
/// Excludes "quiet" byte increments.
|
|
pub fn count_per_min(&self) -> u64 {
|
|
self.last_min_entries
|
|
.iter()
|
|
.filter(|x| !x.is_quiet())
|
|
.count() as u64
|
|
}
|
|
}
|
|
|
|
// turns out getting the millisecs since epoch in Rust isn't as easy as it
|
|
// could be
|
|
fn millis_since_epoch() -> u64 {
|
|
let since_epoch = SystemTime::now()
|
|
.duration_since(SystemTime::UNIX_EPOCH)
|
|
.unwrap_or(Duration::new(0, 0));
|
|
since_epoch.as_secs() * 1000 + u64::from(since_epoch.subsec_millis())
|
|
}
|