grassrootseconomics/openethereum
5
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove the time dependency where possible (#8100)

Browse Source
This commit is contained in:
Pierre Krieger 2018-03-14 12:29:52 +01:00 committed by Marek Kotewicz
parent 5c47116889
commit 113c35af0a
41 changed files with 169 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Cargo.lock generated
View File

@ -509,7 +509,6 @@ dependencies = [
"stop-guard 0.1.0",
"table 0.1.0",
"tempdir 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.38 (registry+https://github.com/rust-lang/crates.io-index)",
"trace-time 0.1.0",
"trie-standardmap 0.1.0",
"triehash 0.1.0",
@ -578,7 +577,6 @@ dependencies = [
"smallvec 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
"stats 0.1.0",
"tempdir 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.38 (registry+https://github.com/rust-lang/crates.io-index)",
"triehash 0.1.0",
"vm 0.1.0",
]
@ -675,7 +673,6 @@ dependencies = [
"slab 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"snappy 0.1.0 (git+https://github.com/paritytech/rust-snappy)",
"tempdir 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.38 (registry+https://github.com/rust-lang/crates.io-index)",
"tiny-keccak 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
@ -906,7 +903,6 @@ dependencies = [
"rlp 0.2.1",
"semver 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
"smallvec 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.38 (registry+https://github.com/rust-lang/crates.io-index)",
"triehash 0.1.0",
]
@ -2015,7 +2011,6 @@ dependencies = [
"tempdir 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"term_size 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"textwrap 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.38 (registry+https://github.com/rust-lang/crates.io-index)",
"toml 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
"ws2_32-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2210,7 +2205,6 @@ dependencies = [
"serde_json 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
"stats 0.1.0",
"tempdir 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.38 (registry+https://github.com/rust-lang/crates.io-index)",
"tiny-keccak 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-timer 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"transient-hashmap 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2361,7 +2355,6 @@ dependencies = [
"serde_json 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
"slab 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"smallvec 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.38 (registry+https://github.com/rust-lang/crates.io-index)",
"tiny-keccak 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
@ -3312,7 +3305,6 @@ name = "trace-time"
version = "0.1.0"
dependencies = [
"log 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.38 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]

1
Cargo.toml
View File

@ -14,7 +14,6 @@ docopt = "0.8"
clap = "2"
term_size = "0.3"
textwrap = "0.9"
time = "0.1"
num_cpus = "1.2"
number_prefix = "0.2"
rpassword = "1.0"

1
ethcore/Cargo.toml
View File

@ -60,7 +60,6 @@ macros = { path = "../util/macros" }
rust-crypto = "0.2.34"
rustc-hex = "1.0"
stats = { path = "../util/stats" }
time = "0.1"
trace-time = { path = "../util/trace-time" }
using_queue = { path = "../util/using_queue" }
table = { path = "../util/table" }

1
ethcore/light/Cargo.toml
View File

@ -22,7 +22,6 @@ vm = { path = "../vm" }
plain_hasher = { path = "../../util/plain_hasher" }
rlp = { path = "../../util/rlp" }
rlp_derive = { path = "../../util/rlp_derive" }
time = "0.1"
smallvec = "0.4"
futures = "0.1"
rand = "0.4"

14
ethcore/light/src/cache.rs
View File

@ -25,7 +25,7 @@ use ethcore::header::BlockNumber;
use ethcore::receipt::Receipt;
use stats::Corpus;
use time::{SteadyTime, Duration};
use std::time::{Instant, Duration};
use heapsize::HeapSizeOf;
use ethereum_types::{H256, U256};
use memory_cache::MemoryLruCache;
@ -69,7 +69,7 @@ pub struct Cache {
bodies: MemoryLruCache<H256, encoded::Body>,
receipts: MemoryLruCache<H256, Vec<Receipt>>,
chain_score: MemoryLruCache<H256, U256>,
corpus: Option<(Corpus<U256>, SteadyTime)>,
corpus: Option<(Corpus<U256>, Instant)>,
corpus_expiration: Duration,
}
@ -139,7 +139,7 @@ impl Cache {
/// Get gas price corpus, if recent enough.
pub fn gas_price_corpus(&self) -> Option<Corpus<U256>> {
let now = SteadyTime::now();
let now = Instant::now();
self.corpus.as_ref().and_then(|&(ref corpus, ref tm)| {
if *tm + self.corpus_expiration >= now {
@ -152,7 +152,7 @@ impl Cache {
/// Set the cached gas price corpus.
pub fn set_gas_price_corpus(&mut self, corpus: Corpus<U256>) {
self.corpus = Some((corpus, SteadyTime::now()))
self.corpus = Some((corpus, Instant::now()))
}
/// Get the memory used.
@ -175,18 +175,18 @@ impl HeapSizeOf for Cache {
#[cfg(test)]
mod tests {
use super::Cache;
use time::Duration;
use std::time::Duration;
#[test]
fn corpus_inaccessible() {
let mut cache = Cache::new(Default::default(), Duration::hours(5));
let mut cache = Cache::new(Default::default(), Duration::from_secs(5 * 3600));
cache.set_gas_price_corpus(vec![].into());
assert_eq!(cache.gas_price_corpus(), Some(vec![].into()));
{
let corpus_time = &mut cache.corpus.as_mut().unwrap().1;
*corpus_time = *corpus_time - Duration::hours(6);
*corpus_time = *corpus_time - Duration::from_secs(6 * 3600);
}
assert!(cache.gas_price_corpus().is_none());
}

16
ethcore/light/src/client/header_chain.rs
View File

@ -732,7 +732,7 @@ mod tests {
use kvdb::KeyValueDB;
use kvdb_memorydb;
use time::Duration;
use std::time::Duration;
use parking_lot::Mutex;
fn make_db() -> Arc<KeyValueDB> {
@ -745,7 +745,7 @@ mod tests {
let genesis_header = spec.genesis_header();
let db = make_db();
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::from_secs(6 * 3600))));
let chain = HeaderChain::new(db.clone(), None, &spec, cache).unwrap();
@ -778,7 +778,7 @@ mod tests {
let spec = Spec::new_test();
let genesis_header = spec.genesis_header();
let db = make_db();
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::from_secs(6 * 3600))));
let chain = HeaderChain::new(db.clone(), None, &spec, cache).unwrap();
@ -860,7 +860,7 @@ mod tests {
fn earliest_is_latest() {
let spec = Spec::new_test();
let db = make_db();
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::from_secs(6 * 3600))));
let chain = HeaderChain::new(db.clone(), None, &spec, cache).unwrap();
@ -873,7 +873,7 @@ mod tests {
let spec = Spec::new_test();
let genesis_header = spec.genesis_header();
let db = make_db();
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::from_secs(6 * 3600))));
{
let chain = HeaderChain::new(db.clone(), None, &spec, cache.clone()).unwrap();
@ -909,7 +909,7 @@ mod tests {
let spec = Spec::new_test();
let genesis_header = spec.genesis_header();
let db = make_db();
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::from_secs(6 * 3600))));
{
let chain = HeaderChain::new(db.clone(), None, &spec, cache.clone()).unwrap();
@ -964,7 +964,7 @@ mod tests {
let spec = Spec::new_test();
let genesis_header = spec.genesis_header();
let db = make_db();
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::from_secs(6 * 3600))));
let chain = HeaderChain::new(db.clone(), None, &spec, cache.clone()).unwrap();
@ -978,7 +978,7 @@ mod tests {
let spec = Spec::new_test();
let genesis_header = spec.genesis_header();
let db = make_db();
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::from_secs(6 * 3600))));
let chain = HeaderChain::new(db.clone(), None, &spec, cache).unwrap();

4
ethcore/light/src/client/service.rs
View File

@ -107,7 +107,7 @@ mod tests {
use std::sync::Arc;
use cache::Cache;
use client::fetch;
use time::Duration;
use std::time::Duration;
use parking_lot::Mutex;
use kvdb_memorydb;
use ethcore::db::NUM_COLUMNS;
@ -116,7 +116,7 @@ mod tests {
fn it_works() {
let db = Arc::new(kvdb_memorydb::create(NUM_COLUMNS.unwrap_or(0)));
let spec = Spec::new_test();
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::from_secs(6 * 3600))));
Service::start(Default::default(), &spec, fetch::unavailable(), db, cache).unwrap();
}

1
ethcore/light/src/lib.rs
View File

@ -75,7 +75,6 @@ extern crate rlp_derive;
extern crate serde;
extern crate smallvec;
extern crate stats;
extern crate time;
extern crate vm;
extern crate keccak_hash as hash;
extern crate triehash;

18
ethcore/light/src/net/load_timer.rs
View File

@ -27,11 +27,11 @@
use std::collections::{HashMap, VecDeque};
use std::fs::File;
use std::path::PathBuf;
use std::time::{Duration, Instant};
use request::{CompleteRequest, Kind};
use bincode;
use time;
use parking_lot::{RwLock, Mutex};
/// Number of time periods samples should be kept for.
@ -107,7 +107,7 @@ impl LoadDistribution {
};
LoadTimer {
start: time::precise_time_ns(),
start: Instant::now(),
n: n,
dist: self,
kind: kind,
@ -151,10 +151,10 @@ impl LoadDistribution {
store.store(&*samples);
}
fn update(&self, kind: Kind, elapsed: u64, n: u64) {
fn update(&self, kind: Kind, elapsed: Duration, n: u64) {
macro_rules! update_counters {
($counters: expr) => {
$counters.0 = $counters.0.saturating_add(elapsed);
$counters.0 = $counters.0.saturating_add({ elapsed.as_secs() * 1_000_000_000 + elapsed.subsec_nanos() as u64 });
$counters.1 = $counters.1.saturating_add(n);
}
};
@ -180,7 +180,7 @@ impl LoadDistribution {
/// A timer for a single request.
/// On drop, this will update the distribution.
pub struct LoadTimer<'a> {
start: u64,
start: Instant,
n: u64,
dist: &'a LoadDistribution,
kind: Kind,
@ -188,7 +188,7 @@ pub struct LoadTimer<'a> {
impl<'a> Drop for LoadTimer<'a> {
fn drop(&mut self) {
let elapsed = time::precise_time_ns() - self.start;
let elapsed = self.start.elapsed();
self.dist.update(self.kind, elapsed, self.n);
}
}
@ -225,7 +225,7 @@ mod tests {
let dist = LoadDistribution::load(&NullStore);
assert_eq!(dist.expected_time_ns(Kind::Headers), hardcoded_serve_time(Kind::Headers));
dist.update(Kind::Headers, 100_000, 100);
dist.update(Kind::Headers, Duration::new(0, 100_000), 100);
dist.end_period(&NullStore);
assert_eq!(dist.expected_time_ns(Kind::Headers), 1000);
@ -238,7 +238,7 @@ mod tests {
let mut sum = 0;
for (i, x) in (0..10).map(|x| x * 10_000).enumerate() {
dist.update(Kind::Headers, x, 1);
dist.update(Kind::Headers, Duration::new(0, x), 1);
dist.end_period(&NullStore);
sum += x;
@ -248,7 +248,7 @@ mod tests {
// should be weighted below the maximum entry.
let arith_average = (sum as f64 / (i + 1) as f64) as u64;
assert!(moving_average < x);
assert!(moving_average < x as u64);
// when there are only 2 entries, they should be equal due to choice of
// ALPHA = 1/N.

52
ethcore/light/src/net/mod.rs
View File

@ -26,7 +26,7 @@ use rlp::{RlpStream, UntrustedRlp};
use ethereum_types::{H256, U256};
use kvdb::DBValue;
use parking_lot::{Mutex, RwLock};
use time::{Duration, SteadyTime};
use std::time::{Duration, Instant};
use std::collections::{HashMap, HashSet};
use std::fmt;
@ -73,7 +73,7 @@ const RECALCULATE_COSTS_TIMEOUT: TimerToken = 3;
const RECALCULATE_COSTS_INTERVAL_MS: u64 = 60 * 60 * 1000;
// minimum interval between updates.
const UPDATE_INTERVAL_MS: i64 = 5000;
const UPDATE_INTERVAL_MS: u64 = 5000;
/// Supported protocol versions.
pub const PROTOCOL_VERSIONS: &'static [u8] = &[1];
@ -109,20 +109,20 @@ mod packet {
// timeouts for different kinds of requests. all values are in milliseconds.
mod timeout {
pub const HANDSHAKE: i64 = 2500;
pub const ACKNOWLEDGE_UPDATE: i64 = 5000;
pub const BASE: i64 = 1500; // base timeout for packet.
pub const HANDSHAKE: u64 = 2500;
pub const ACKNOWLEDGE_UPDATE: u64 = 5000;
pub const BASE: u64 = 1500; // base timeout for packet.
// timeouts per request within packet.
pub const HEADERS: i64 = 250; // per header?
pub const TRANSACTION_INDEX: i64 = 100;
pub const BODY: i64 = 50;
pub const RECEIPT: i64 = 50;
pub const PROOF: i64 = 100; // state proof
pub const CONTRACT_CODE: i64 = 100;
pub const HEADER_PROOF: i64 = 100;
pub const TRANSACTION_PROOF: i64 = 1000; // per gas?
pub const EPOCH_SIGNAL: i64 = 200;
pub const HEADERS: u64 = 250; // per header?
pub const TRANSACTION_INDEX: u64 = 100;
pub const BODY: u64 = 50;
pub const RECEIPT: u64 = 50;
pub const PROOF: u64 = 100; // state proof
pub const CONTRACT_CODE: u64 = 100;
pub const HEADER_PROOF: u64 = 100;
pub const TRANSACTION_PROOF: u64 = 1000; // per gas?
pub const EPOCH_SIGNAL: u64 = 200;
}
/// A request id.
@ -144,7 +144,7 @@ impl fmt::Display for ReqId {
// may not have received one for.
struct PendingPeer {
sent_head: H256,
last_update: SteadyTime,
last_update: Instant,
}
/// Relevant data to each peer. Not accessible publicly, only `pub` due to
@ -155,13 +155,13 @@ pub struct Peer {
capabilities: Capabilities,
remote_flow: Option<(Credits, FlowParams)>,
sent_head: H256, // last chain head we've given them.
last_update: SteadyTime,
last_update: Instant,
pending_requests: RequestSet,
failed_requests: Vec<ReqId>,
propagated_transactions: HashSet<H256>,
skip_update: bool,
local_flow: Arc<FlowParams>,
awaiting_acknowledge: Option<(SteadyTime, Arc<FlowParams>)>,
awaiting_acknowledge: Option<(Instant, Arc<FlowParams>)>,
}
/// Whether or not a peer was kept by a handler
@ -447,7 +447,7 @@ impl LightProtocol {
});
// begin timeout.
peer.pending_requests.insert(req_id, requests, cost, SteadyTime::now());
peer.pending_requests.insert(req_id, requests, cost, Instant::now());
Ok(req_id)
}
}
@ -457,7 +457,7 @@ impl LightProtocol {
/// The announcement is expected to be valid.
pub fn make_announcement(&self, io: &IoContext, mut announcement: Announcement) {
let mut reorgs_map = HashMap::new();
let now = SteadyTime::now();
let now = Instant::now();
// update stored capabilities
self.capabilities.write().update_from(&announcement);
@ -470,7 +470,7 @@ impl LightProtocol {
// the timer approach will skip 1 (possibly 2) in rare occasions.
if peer_info.sent_head == announcement.head_hash ||
peer_info.status.head_num >= announcement.head_num ||
now - peer_info.last_update < Duration::milliseconds(UPDATE_INTERVAL_MS) {
now - peer_info.last_update < Duration::from_millis(UPDATE_INTERVAL_MS) {
continue
}
@ -537,7 +537,7 @@ impl LightProtocol {
Some(peer_info) => {
let mut peer_info = peer_info.lock();
let peer_info: &mut Peer = &mut *peer_info;
let req_info = peer_info.pending_requests.remove(&req_id, SteadyTime::now());
let req_info = peer_info.pending_requests.remove(&req_id, Instant::now());
let last_batched = peer_info.pending_requests.is_empty();
let flow_info = peer_info.remote_flow.as_mut();
@ -599,14 +599,14 @@ impl LightProtocol {
// check timeouts and punish peers.
fn timeout_check(&self, io: &IoContext) {
let now = SteadyTime::now();
let now = Instant::now();
// handshake timeout
{
let mut pending = self.pending_peers.write();
let slowpokes: Vec<_> = pending.iter()
.filter(|&(_, ref peer)| {
peer.last_update + Duration::milliseconds(timeout::HANDSHAKE) <= now
peer.last_update + Duration::from_millis(timeout::HANDSHAKE) <= now
})
.map(|(&p, _)| p)
.collect();
@ -619,7 +619,7 @@ impl LightProtocol {
}
// request and update ack timeouts
let ack_duration = Duration::milliseconds(timeout::ACKNOWLEDGE_UPDATE);
let ack_duration = Duration::from_millis(timeout::ACKNOWLEDGE_UPDATE);
{
for (peer_id, peer) in self.peers.read().iter() {
let peer = peer.lock();
@ -709,7 +709,7 @@ impl LightProtocol {
self.pending_peers.write().insert(*peer, PendingPeer {
sent_head: chain_info.best_block_hash,
last_update: SteadyTime::now(),
last_update: Instant::now(),
});
trace!(target: "pip", "Sending status to peer {}", peer);
@ -771,7 +771,7 @@ impl LightProtocol {
*self.flow_params.write() = new_params.clone();
let peers = self.peers.read();
let now = SteadyTime::now();
let now = Instant::now();
let packet_body = {
let mut stream = RlpStream::new_list(3);

14
ethcore/light/src/net/request_credits.rs
View File

@ -31,7 +31,7 @@ use super::error::Error;
use rlp::*;
use ethereum_types::U256;
use time::{Duration, SteadyTime};
use std::time::{Duration, Instant};
/// Credits value.
///
@ -41,7 +41,7 @@ use time::{Duration, SteadyTime};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Credits {
estimate: U256,
recharge_point: SteadyTime,
recharge_point: Instant,
}
impl Credits {
@ -53,7 +53,7 @@ impl Credits {
/// a response to a request.
pub fn update_to(&mut self, value: U256) {
self.estimate = value;
self.recharge_point = SteadyTime::now();
self.recharge_point = Instant::now();
}
/// Maintain ratio to current limit against an old limit.
@ -351,19 +351,19 @@ impl FlowParams {
pub fn create_credits(&self) -> Credits {
Credits {
estimate: self.limit,
recharge_point: SteadyTime::now(),
recharge_point: Instant::now(),
}
}
/// Recharge the given credits based on time passed since last
/// update.
pub fn recharge(&self, credits: &mut Credits) {
let now = SteadyTime::now();
let now = Instant::now();
// recompute and update only in terms of full seconds elapsed
// in order to keep the estimate as an underestimate.
let elapsed = (now - credits.recharge_point).num_seconds();
credits.recharge_point = credits.recharge_point + Duration::seconds(elapsed);
let elapsed = (now - credits.recharge_point).as_secs();
credits.recharge_point = credits.recharge_point + Duration::from_secs(elapsed);
let elapsed: U256 = elapsed.into();

27
ethcore/light/src/net/request_set.rs
View File

@ -23,14 +23,13 @@
use std::collections::{BTreeMap, HashMap};
use std::iter::FromIterator;
use std::time::{Duration, Instant};
use request::Request;
use request::NetworkRequests as Requests;
use net::{timeout, ReqId};
use ethereum_types::U256;
use time::{Duration, SteadyTime};
// Request set entry: requests + cost.
#[derive(Debug)]
struct Entry(Requests, U256);
@ -40,7 +39,7 @@ struct Entry(Requests, U256);
pub struct RequestSet {
counter: u64,
cumulative_cost: U256,
base: Option<SteadyTime>,
base: Option<Instant>,
ids: HashMap<ReqId, u64>,
reqs: BTreeMap<u64, Entry>,
}
@ -59,7 +58,7 @@ impl Default for RequestSet {
impl RequestSet {
/// Push requests onto the stack.
pub fn insert(&mut self, req_id: ReqId, req: Requests, cost: U256, now: SteadyTime) {
pub fn insert(&mut self, req_id: ReqId, req: Requests, cost: U256, now: Instant) {
let counter = self.counter;
self.cumulative_cost = self.cumulative_cost + cost;
@ -74,7 +73,7 @@ impl RequestSet {
}
/// Remove a set of requests from the stack.
pub fn remove(&mut self, req_id: &ReqId, now: SteadyTime) -> Option<Requests> {
pub fn remove(&mut self, req_id: &ReqId, now: Instant) -> Option<Requests> {
let id = match self.ids.remove(&req_id) {
Some(id) => id,
None => return None,
@ -94,7 +93,7 @@ impl RequestSet {
/// Check for timeout against the given time. Returns true if
/// has timed out, false otherwise.
pub fn check_timeout(&self, now: SteadyTime) -> bool {
pub fn check_timeout(&self, now: Instant) -> bool {
let base = match self.base.as_ref().cloned() {
Some(base) => base,
None => return false,
@ -128,7 +127,7 @@ impl RequestSet {
// helper to calculate timeout for a specific set of requests.
// it's a base amount + some amount per request.
fn compute_timeout(reqs: &Requests) -> Duration {
Duration::milliseconds(reqs.requests().iter().fold(timeout::BASE, |tm, req| {
Duration::from_millis(reqs.requests().iter().fold(timeout::BASE, |tm, req| {
tm + match *req {
Request::Headers(_) => timeout::HEADERS,
Request::HeaderProof(_) => timeout::HEADER_PROOF,
@ -148,34 +147,34 @@ fn compute_timeout(reqs: &Requests) -> Duration {
mod tests {
use net::ReqId;
use request::Builder;
use time::{SteadyTime, Duration};
use std::time::{Instant, Duration};
use super::{RequestSet, compute_timeout};
#[test]
fn multi_timeout() {
let test_begin = SteadyTime::now();
let test_begin = Instant::now();
let mut req_set = RequestSet::default();
let the_req = Builder::default().build();
let req_time = compute_timeout(&the_req);
req_set.insert(ReqId(0), the_req.clone(), 0.into(), test_begin);
req_set.insert(ReqId(1), the_req, 0.into(), test_begin + Duration::seconds(1));
req_set.insert(ReqId(1), the_req, 0.into(), test_begin + Duration::from_secs(1));
assert_eq!(req_set.base, Some(test_begin));
let test_end = test_begin + req_time;
assert!(req_set.check_timeout(test_end));
req_set.remove(&ReqId(0), test_begin + Duration::seconds(1)).unwrap();
req_set.remove(&ReqId(0), test_begin + Duration::from_secs(1)).unwrap();
assert!(!req_set.check_timeout(test_end));
assert!(req_set.check_timeout(test_end + Duration::seconds(1)));
assert!(req_set.check_timeout(test_end + Duration::from_secs(1)));
}
#[test]
fn cumulative_cost() {
let the_req = Builder::default().build();
let test_begin = SteadyTime::now();
let test_end = test_begin + Duration::seconds(1);
let test_begin = Instant::now();
let test_end = test_begin + Duration::from_secs(1);
let mut req_set = RequestSet::default();
for i in 0..5 {

7
ethcore/light/src/net/tests/mod.rs
View File

@ -35,6 +35,7 @@ use rlp::*;
use ethereum_types::{H256, U256, Address};
use std::sync::Arc;
use std::time::Instant;
// helper for encoding a single request into a packet.
// panics on bad backreference.
@ -661,8 +662,8 @@ fn id_guard() {
let mut pending_requests = RequestSet::default();
pending_requests.insert(req_id_1, req.clone(), 0.into(), ::time::SteadyTime::now());
pending_requests.insert(req_id_2, req, 1.into(), ::time::SteadyTime::now());
pending_requests.insert(req_id_1, req.clone(), 0.into(), Instant::now());
pending_requests.insert(req_id_2, req, 1.into(), Instant::now());
proto.peers.write().insert(peer_id, ::parking_lot::Mutex::new(Peer {
local_credits: flow_params.create_credits(),
@ -670,7 +671,7 @@ fn id_guard() {
capabilities: capabilities.clone(),
remote_flow: Some((flow_params.create_credits(), (&*flow_params).clone())),
sent_head: provider.client.chain_info().best_block_hash,
last_update: ::time::SteadyTime::now(),
last_update: Instant::now(),
pending_requests: pending_requests,
failed_requests: Vec::new(),
propagated_transactions: Default::default(),

3
ethcore/light/src/on_demand/request.rs
View File

@ -941,6 +941,7 @@ impl Signal {
#[cfg(test)]
mod tests {
use super::*;
use std::time::Duration;
use ethereum_types::{H256, Address};
use memorydb::MemoryDB;
use parking_lot::Mutex;
@ -954,7 +955,7 @@ mod tests {
use ethcore::receipt::{Receipt, TransactionOutcome};
fn make_cache() -> ::cache::Cache {
::cache::Cache::new(Default::default(), ::time::Duration::seconds(1))
::cache::Cache::new(Default::default(), Duration::from_secs(1))
}
#[test]

4
ethcore/light/src/on_demand/tests.rs
View File

@ -24,7 +24,7 @@ use network::{PeerId, NodeId};
use net::*;
use ethereum_types::H256;
use parking_lot::Mutex;
use time::Duration;
use std::time::Duration;
use ::request::{self as basic_request, Response};
use std::sync::Arc;
@ -88,7 +88,7 @@ struct Harness {
impl Harness {
fn create() -> Self {
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::minutes(1))));
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::from_secs(60))));
Harness {
service: OnDemand::new_test(cache),
}

15
ethcore/src/client/client.rs
View File

@ -19,7 +19,6 @@ use std::str::FromStr;
use std::sync::{Arc, Weak};
use std::sync::atomic::{AtomicUsize, AtomicBool, Ordering as AtomicOrdering};
use std::time::{Instant};
use time::precise_time_ns;
use itertools::Itertools;
// util
@ -293,7 +292,7 @@ impl Importer {
return 0;
}
trace_time!("import_verified_blocks");
let start = precise_time_ns();
let start = Instant::now();
for block in blocks {
let header = &block.header;
@ -326,7 +325,10 @@ impl Importer {
self.block_queue.mark_as_bad(&invalid_blocks);
}
let is_empty = self.block_queue.mark_as_good(&imported_blocks);
let duration_ns = precise_time_ns() - start;
let duration_ns = {
let elapsed = start.elapsed();
elapsed.as_secs() * 1_000_000_000 + elapsed.subsec_nanos() as u64
};
(imported_blocks, import_results, invalid_blocks, imported, proposed_blocks, duration_ns, is_empty)
};
@ -2036,7 +2038,7 @@ impl ScheduleInfo for Client {
impl ImportSealedBlock for Client {
fn import_sealed_block(&self, block: SealedBlock) -> ImportResult {
let h = block.header().hash();
let start = precise_time_ns();
let start = Instant::now();
let route = {
// scope for self.import_lock
let _import_lock = self.importer.import_lock.lock();
@ -2061,7 +2063,10 @@ impl ImportSealedBlock for Client {
retracted.clone(),
vec![h.clone()],
vec![],
precise_time_ns() - start,
{
let elapsed = start.elapsed();
elapsed.as_secs() * 1_000_000_000 + elapsed.subsec_nanos() as u64
},
);
});
self.db.read().flush().expect("DB flush failed.");

12
ethcore/src/engines/tendermint/params.rs
View File

@ -17,7 +17,7 @@
//! Tendermint specific parameters.
use ethjson;
use time::Duration;
use std::time::Duration;
use ethereum_types::U256;
use super::super::validator_set::{ValidatorSet, new_validator_set};
use super::super::transition::Timeouts;
@ -45,10 +45,10 @@ pub struct TendermintTimeouts {
impl Default for TendermintTimeouts {
fn default() -> Self {
TendermintTimeouts {
propose: Duration::milliseconds(1000),
prevote: Duration::milliseconds(1000),
precommit: Duration::milliseconds(1000),
commit: Duration::milliseconds(1000),
propose: Duration::from_millis(1000),
prevote: Duration::from_millis(1000),
precommit: Duration::from_millis(1000),
commit: Duration::from_millis(1000),
}
}
}
@ -70,7 +70,7 @@ impl Timeouts<Step> for TendermintTimeouts {
fn to_duration(ms: ethjson::uint::Uint) -> Duration {
let ms: usize = ms.into();
Duration::milliseconds(ms as i64)
Duration::from_millis(ms as u64)
}
impl From<ethjson::spec::TendermintParams> for TendermintParams {

7
ethcore/src/engines/transition.rs
View File

@ -17,7 +17,7 @@
//! Engine timeout transitioning calls `Engine.step()` on timeout.
use std::sync::Weak;
use time::Duration;
use std::time::Duration;
use io::{IoContext, IoHandler, TimerToken};
use engines::Engine;
use parity_machine::Machine;
@ -51,7 +51,8 @@ impl<S, M: Machine> TransitionHandler<S, M> where S: Sync + Send + Clone {
pub const ENGINE_TIMEOUT_TOKEN: TimerToken = 23;
fn set_timeout<S: Sync + Send + Clone>(io: &IoContext<S>, timeout: Duration) {
io.register_timer_once(ENGINE_TIMEOUT_TOKEN, timeout.num_milliseconds() as u64)
let ms = timeout.as_secs() * 1_000 + timeout.subsec_nanos() as u64 / 1_000_000;
io.register_timer_once(ENGINE_TIMEOUT_TOKEN, ms)
.unwrap_or_else(|e| warn!(target: "engine", "Failed to set consensus step timeout: {}.", e))
}
@ -60,7 +61,7 @@ impl<S, M> IoHandler<S> for TransitionHandler<S, M>
{
fn initialize(&self, io: &IoContext<S>) {
let initial = self.timeouts.initial();
trace!(target: "engine", "Setting the initial timeout to {}.", initial);
trace!(target: "engine", "Setting the initial timeout to {:?}.", initial);
set_timeout(io, initial);
}

4
ethcore/src/header.rs
View File

@ -18,11 +18,11 @@
use std::cmp;
use std::cell::RefCell;
use std::time::{SystemTime, UNIX_EPOCH};
use hash::{KECCAK_NULL_RLP, KECCAK_EMPTY_LIST_RLP, keccak};
use heapsize::HeapSizeOf;
use ethereum_types::{H256, U256, Address, Bloom};
use bytes::Bytes;
use time::get_time;
use rlp::*;
pub use types::BlockNumber;
@ -189,7 +189,7 @@ impl Header {
/// Set the timestamp field of the header.
pub fn set_timestamp(&mut self, a: u64) { self.timestamp = a; self.note_dirty(); }
/// Set the timestamp field of the header to the current time.
pub fn set_timestamp_now(&mut self, but_later_than: u64) { self.timestamp = cmp::max(get_time().sec as u64, but_later_than + 1); self.note_dirty(); }
pub fn set_timestamp_now(&mut self, but_later_than: u64) { let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default(); self.timestamp = cmp::max(now.as_secs() as u64, but_later_than + 1); self.note_dirty(); }
/// Set the number field of the header.
pub fn set_number(&mut self, a: BlockNumber) { self.number = a; self.note_dirty(); }
/// Set the author field of the header.

1
ethcore/src/lib.rs
View File

@ -109,7 +109,6 @@ extern crate rlp_derive;
extern crate rustc_hex;
extern crate stats;
extern crate stop_guard;
extern crate time;
extern crate using_queue;
extern crate table;
extern crate vm;

11
ethcore/src/verification/verification.rs
View File

@ -22,13 +22,13 @@
//! 3. Final verification against the blockchain done before enactment.
use std::collections::HashSet;
use std::time::{SystemTime, UNIX_EPOCH};
use bytes::Bytes;
use ethereum_types::{H256, U256};
use hash::keccak;
use heapsize::HeapSizeOf;
use rlp::UntrustedRlp;
use time::get_time;
use triehash::ordered_trie_root;
use unexpected::{Mismatch, OutOfBounds};
@ -284,7 +284,8 @@ pub fn verify_header_params(header: &Header, engine: &EthEngine, is_full: bool)
if is_full {
const ACCEPTABLE_DRIFT_SECS: u64 = 15;
let max_time = get_time().sec as u64 + ACCEPTABLE_DRIFT_SECS;
let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default();
let max_time = now.as_secs() + ACCEPTABLE_DRIFT_SECS;
let invalid_threshold = max_time + ACCEPTABLE_DRIFT_SECS * 9;
let timestamp = header.timestamp();
@ -346,6 +347,7 @@ mod tests {
use super::*;
use std::collections::{BTreeMap, HashMap};
use std::time::{SystemTime, UNIX_EPOCH};
use ethereum_types::{H256, Bloom, U256};
use blockchain::{BlockDetails, TransactionAddress, BlockReceipts};
use encoded;
@ -355,7 +357,6 @@ mod tests {
use ethkey::{Random, Generator};
use spec::{CommonParams, Spec};
use tests::helpers::{create_test_block_with_data, create_test_block};
use time::get_time;
use transaction::{SignedTransaction, Transaction, UnverifiedTransaction, Action};
use types::log_entry::{LogEntry, LocalizedLogEntry};
use rlp;
@ -682,11 +683,11 @@ mod tests {
check_fail_timestamp(basic_test(&create_test_block_with_data(&header, &good_transactions, &good_uncles), engine), false);
header = good.clone();
header.set_timestamp(get_time().sec as u64 + 20);
header.set_timestamp(SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs() + 20);
check_fail_timestamp(basic_test(&create_test_block_with_data(&header, &good_transactions, &good_uncles), engine), true);
header = good.clone();
header.set_timestamp(get_time().sec as u64 + 10);
header.set_timestamp(SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs() + 10);
header.set_uncles_hash(good_uncles_hash.clone());
header.set_transactions_root(good_transactions_root.clone());
check_ok(basic_test(&create_test_block_with_data(&header, &good_transactions, &good_uncles), engine));

2
parity/blockchain.rs
View File

@ -193,7 +193,7 @@ fn execute_import_light(cmd: ImportBlockchain) -> Result<(), String> {
cmd.dirs.create_dirs(false, false, false)?;
let cache = Arc::new(Mutex::new(
LightDataCache::new(Default::default(), ::time::Duration::seconds(0))
LightDataCache::new(Default::default(), Duration::new(0, 0))
));
let mut config = LightClientConfig {

1
parity/main.rs
View File

@ -43,7 +43,6 @@ extern crate serde;
extern crate serde_json;
#[macro_use]
extern crate serde_derive;
extern crate time;
extern crate toml;
extern crate ethcore;

4
parity/run.rs
View File

@ -76,7 +76,7 @@ const SNAPSHOT_HISTORY: u64 = 100;
// Number of minutes before a given gas price corpus should expire.
// Light client only.
const GAS_CORPUS_EXPIRATION_MINUTES: i64 = 60 * 6;
const GAS_CORPUS_EXPIRATION_MINUTES: u64 = 60 * 6;
// Pops along with error messages when a password is missing or invalid.
const VERIFY_PASSWORD_HINT: &'static str = "Make sure valid password is present in files passed using `--password` or in the configuration file.";
@ -217,7 +217,7 @@ fn execute_light_impl(cmd: RunCmd, can_restart: bool, logger: Arc<RotatingLogger
info!("Running in experimental {} mode.", Colour::Blue.bold().paint("Light Client"));
// TODO: configurable cache size.
let cache = LightDataCache::new(Default::default(), ::time::Duration::minutes(GAS_CORPUS_EXPIRATION_MINUTES));
let cache = LightDataCache::new(Default::default(), Duration::from_secs(60 * GAS_CORPUS_EXPIRATION_MINUTES));
let cache = Arc::new(Mutex::new(cache));
// start client and create transaction queue.

1
rpc/Cargo.toml
View File

@ -24,7 +24,6 @@ serde = "1.0"
serde_derive = "1.0"
serde_json = "1.0"
tempdir = "0.3"
time = "0.1"
tiny-keccak = "1.3"
tokio-timer = "0.1"
transient-hashmap = "0.4"

1
rpc/src/lib.rs
View File

@ -34,7 +34,6 @@ extern crate rustc_hex;
extern crate semver;
extern crate serde;
extern crate serde_json;
extern crate time;
extern crate tiny_keccak;
extern crate tokio_timer;
extern crate transient_hashmap;

6
rpc/src/v1/impls/eth.rs
View File

@ -17,11 +17,10 @@
//! Eth rpc implementation.
use std::thread;
use std::time::{Instant, Duration};
use std::time::{Instant, Duration, SystemTime, UNIX_EPOCH};
use std::sync::Arc;
use rlp::{self, UntrustedRlp};
use time::get_time;
use ethereum_types::{U256, H64, H160, H256, Address};
use parking_lot::Mutex;
@ -769,7 +768,8 @@ impl<C, SN: ?Sized, S: ?Sized, M, EM, T: StateInfo + 'static> Eth for EthClient<
let target = Ethash::difficulty_to_boundary(b.block().header().difficulty());
let seed_hash = self.seed_compute.lock().hash_block_number(b.block().header().number());
if no_new_work_timeout > 0 && b.block().header().timestamp() + no_new_work_timeout < get_time().sec as u64 {
let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs();
if no_new_work_timeout > 0 && b.block().header().timestamp() + no_new_work_timeout < now {
Err(errors::no_new_work())
} else if self.options.send_block_number_in_get_work {
let block_number = b.block().header().number();

6
rpc/src/v1/tests/mocked/eth.rs
View File

@ -17,7 +17,7 @@
use std::str::FromStr;
use std::collections::HashMap;
use std::sync::Arc;
use std::time::{Instant, Duration};
use std::time::{Instant, Duration, SystemTime, UNIX_EPOCH};
use ethereum_types::{H256, U256, Address};
use parking_lot::Mutex;
@ -31,7 +31,6 @@ use ethsync::SyncState;
use miner::external::ExternalMiner;
use rlp;
use rustc_hex::{FromHex, ToHex};
use time::get_time;
use transaction::{Transaction, Action};
use jsonrpc_core::IoHandler;
@ -1144,7 +1143,8 @@ fn rpc_get_work_should_not_return_block_number() {
fn rpc_get_work_should_timeout() {
let eth_tester = EthTester::default();
eth_tester.miner.set_author(Address::from_str("d46e8dd67c5d32be8058bb8eb970870f07244567").unwrap());
eth_tester.client.set_latest_block_timestamp(get_time().sec as u64 - 1000); // Set latest block to 1000 seconds ago
let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs() - 1000; // Set latest block to 1000 seconds ago
eth_tester.client.set_latest_block_timestamp(timestamp);
let hash = eth_tester.miner.map_sealing_work(&*eth_tester.client, |b| b.hash()).unwrap();
// Request without providing timeout. This should work since we're disabling timeout.

1
sync/Cargo.toml
View File

@ -24,7 +24,6 @@ kvdb = { path = "../util/kvdb" }
macros = { path = "../util/macros" }
log = "0.3"
env_logger = "0.4"
time = "0.1.34"
rand = "0.4"
heapsize = "0.4"
semver = "0.6"

30
sync/src/chain.rs
View File

@ -90,6 +90,7 @@
use std::collections::{HashSet, HashMap};
use std::cmp;
use std::time::Instant;
use hash::keccak;
use heapsize::HeapSizeOf;
use ethereum_types::{H256, U256};
@ -104,7 +105,6 @@ use ethcore::error::*;
use ethcore::snapshot::{ManifestData, RestorationStatus};
use transaction::PendingTransaction;
use sync_io::SyncIo;
use time;
use super::SyncConfig;
use block_sync::{BlockDownloader, BlockRequest, BlockDownloaderImportError as DownloaderImportError, DownloadAction};
use rand::Rng;
@ -305,7 +305,7 @@ struct PeerInfo {
/// Holds requested snapshot chunk hash if any.
asking_snapshot_data: Option<H256>,
/// Request timestamp
ask_time: u64,
ask_time: Instant,
/// Holds a set of transactions recently sent to this peer to avoid spamming.
last_sent_transactions: HashSet<H256>,
/// Pending request is expired and result should be ignored
@ -377,9 +377,9 @@ pub struct ChainSync {
snapshot: Snapshot,
/// Connected peers pending Status message.
/// Value is request timestamp.
handshaking_peers: HashMap<PeerId, u64>,
handshaking_peers: HashMap<PeerId, Instant>,
/// Sync start timestamp. Measured when first peer is connected
sync_start_time: Option<u64>,
sync_start_time: Option<Instant>,
/// Transactions propagation statistics
transactions_stats: TransactionsStats,
/// Enable ancient block downloading
@ -544,7 +544,7 @@ impl ChainSync {
(best_hash, max_peers, snapshot_peers)
};
let timeout = (self.state == SyncState::WaitingPeers) && self.sync_start_time.map_or(false, |t| ((time::precise_time_ns() - t) / 1_000_000_000) > WAIT_PEERS_TIMEOUT_SEC);
let timeout = (self.state == SyncState::WaitingPeers) && self.sync_start_time.map_or(false, |t| t.elapsed().as_secs() > WAIT_PEERS_TIMEOUT_SEC);
if let (Some(hash), Some(peers)) = (best_hash, best_hash.map_or(None, |h| snapshot_peers.get(&h))) {
if max_peers >= SNAPSHOT_MIN_PEERS {
@ -616,7 +616,7 @@ impl ChainSync {
asking: PeerAsking::Nothing,
asking_blocks: Vec::new(),
asking_hash: None,
ask_time: 0,
ask_time: Instant::now(),
last_sent_transactions: HashSet::new(),
expired: false,
confirmation: if self.fork_block.is_none() { ForkConfirmation::Confirmed } else { ForkConfirmation::Unconfirmed },
@ -627,7 +627,7 @@ impl ChainSync {
};
if self.sync_start_time.is_none() {
self.sync_start_time = Some(time::precise_time_ns());
self.sync_start_time = Some(Instant::now());
}
trace!(target: "sync", "New peer {} (protocol: {}, network: {:?}, difficulty: {:?}, latest:{}, genesis:{}, snapshot:{:?})",
@ -1150,7 +1150,7 @@ impl ChainSync {
debug!(target:"sync", "Error sending status request: {:?}", e);
io.disconnect_peer(peer);
} else {
self.handshaking_peers.insert(peer, time::precise_time_ns());
self.handshaking_peers.insert(peer, Instant::now());
}
}
@ -1438,7 +1438,7 @@ impl ChainSync {
warn!(target:"sync", "Asking {:?} while requesting {:?}", peer.asking, asking);
}
peer.asking = asking;
peer.ask_time = time::precise_time_ns();
peer.ask_time = Instant::now();
let result = if packet_id >= ETH_PACKET_COUNT {
sync.send_protocol(WARP_SYNC_PROTOCOL_ID, peer_id, packet_id, packet)
} else {
@ -1778,10 +1778,10 @@ impl ChainSync {
}
pub fn maintain_peers(&mut self, io: &mut SyncIo) {
let tick = time::precise_time_ns();
let tick = Instant::now();
let mut aborting = Vec::new();
for (peer_id, peer) in &self.peers {
let elapsed = (tick - peer.ask_time) / 1_000_000_000;
let elapsed = (tick - peer.ask_time).as_secs();
let timeout = match peer.asking {
PeerAsking::BlockHeaders => elapsed > HEADERS_TIMEOUT_SEC,
PeerAsking::BlockBodies => elapsed > BODIES_TIMEOUT_SEC,
@ -1802,9 +1802,9 @@ impl ChainSync {
}
// Check for handshake timeouts
for (peer, ask_time) in &self.handshaking_peers {
for (peer, &ask_time) in &self.handshaking_peers {
let elapsed = (tick - ask_time) / 1_000_000_000;
if elapsed > STATUS_TIMEOUT_SEC {
if elapsed.as_secs() > STATUS_TIMEOUT_SEC {
trace!(target:"sync", "Status timeout {}", peer);
io.disconnect_peer(*peer);
}
@ -2474,7 +2474,7 @@ mod tests {
asking: PeerAsking::Nothing,
asking_blocks: Vec::new(),
asking_hash: None,
ask_time: 0,
ask_time: Instant::now(),
last_sent_transactions: HashSet::new(),
expired: false,
confirmation: super::ForkConfirmation::Confirmed,
@ -2595,7 +2595,7 @@ mod tests {
asking: PeerAsking::Nothing,
asking_blocks: Vec::new(),
asking_hash: None,
ask_time: 0,
ask_time: Instant::now(),
last_sent_transactions: HashSet::new(),
expired: false,
confirmation: super::ForkConfirmation::Confirmed,

1
sync/src/lib.rs
View File

@ -29,7 +29,6 @@ extern crate ethcore_transaction as transaction;
extern crate ethcore;
extern crate ethereum_types;
extern crate env_logger;
extern crate time;
extern crate plain_hasher;
extern crate rand;
extern crate semver;

4
sync/src/light_sync/tests/test_net.rs
View File

@ -32,7 +32,7 @@ use light::provider::LightProvider;
use network::{NodeId, PeerId};
use parking_lot::RwLock;
use time::Duration;
use std::time::Duration;
use light::cache::Cache;
const NETWORK_ID: u64 = 0xcafebabe;
@ -218,7 +218,7 @@ impl TestNet<Peer> {
// skip full verification because the blocks are bad.
config.verify_full = false;
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::from_secs(6 * 3600))));
let db = kvdb_memorydb::create(0);
let client = LightClient::new(
config,

1
util/network-devp2p/Cargo.toml
View File

@ -11,7 +11,6 @@ log = "0.3"
mio = "0.6.8"
bytes = "0.4"
rand = "0.4"
time = "0.1.34"
tiny-keccak = "1.3"
rust-crypto = "0.2.34"
slab = "0.2"

15
util/network-devp2p/src/discovery.rs
View File

@ -19,11 +19,11 @@ use std::net::SocketAddr;
use std::collections::{HashSet, HashMap, BTreeMap, VecDeque};
use std::mem;
use std::default::Default;
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
use mio::*;
use mio::deprecated::{Handler, EventLoop};
use mio::udp::*;
use hash::keccak;
use time;
use ethereum_types::{H256, H520};
use rlp::*;
use node_table::*;
@ -59,7 +59,7 @@ pub struct NodeEntry {
pub struct BucketEntry {
pub address: NodeEntry,
pub id_hash: H256,
pub timeout: Option<u64>,
pub timeout: Option<Instant>,
}
pub struct NodeBucket {
@ -170,7 +170,7 @@ impl Discovery {
if bucket.nodes.len() > BUCKET_SIZE {
//ping least active node
let last = bucket.nodes.back_mut().expect("Last item is always present when len() > 0");
last.timeout = Some(time::precise_time_ns());
last.timeout = Some(Instant::now());
Some(last.address.endpoint.clone())
} else { None }
};
@ -262,7 +262,7 @@ impl Discovery {
for i in 0 .. source.item_count() {
rlp.append_raw(source.at(i).as_raw(), 1);
}
let timestamp = time::get_time().sec as u32 + 60;
let timestamp = 60 + SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs() as u32;
rlp.append(&timestamp);
let bytes = rlp.drain();
@ -394,7 +394,8 @@ impl Discovery {
/// Validate that given timestamp is in within one second of now or in the future
fn check_timestamp(&self, timestamp: u64) -> Result<(), Error> {
if self.check_timestamps && timestamp < time::get_time().sec as u64{
let secs_since_epoch = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs();
if self.check_timestamps && timestamp < secs_since_epoch {
debug!(target: "discovery", "Expired packet");
return Err(ErrorKind::Expired.into());
}
@ -504,12 +505,12 @@ impl Discovery {
}
fn check_expired(&mut self, force: bool) -> HashSet<NodeId> {
let now = time::precise_time_ns();
let now = Instant::now();
let mut removed: HashSet<NodeId> = HashSet::new();
for bucket in &mut self.node_buckets {
bucket.nodes.retain(|node| {
if let Some(timeout) = node.timeout {
if !force && now - timeout < PING_TIMEOUT_MS * 1000_0000 {
if !force && now.duration_since(timeout) < Duration::from_millis(PING_TIMEOUT_MS) {
true
}
else {

1
util/network-devp2p/src/lib.rs
View File

@ -67,7 +67,6 @@ extern crate mio;
extern crate tiny_keccak;
extern crate crypto as rcrypto;
extern crate rand;
extern crate time;
extern crate ansi_term; //TODO: remove this
extern crate rustc_hex;
extern crate igd;

32
util/network-devp2p/src/session.rs
View File

@ -18,6 +18,7 @@ use std::{str, io};
use std::net::SocketAddr;
use std::sync::*;
use std::collections::HashMap;
use std::time::{Duration, Instant};
use mio::*;
use mio::deprecated::{Handler, EventLoop};
@ -32,7 +33,6 @@ use network::{SessionCapabilityInfo, HostInfo as HostInfoTrait};
use host::*;
use node_table::NodeId;
use stats::NetworkStats;
use time;
use snappy;
// Timeout must be less than (interval - 1).
@ -59,8 +59,8 @@ pub struct Session {
had_hello: bool,
/// Session is no longer active flag.
expired: bool,
ping_time_ns: u64,
pong_time_ns: Option<u64>,
ping_time: Instant,
pong_time: Option<Instant>,
state: State,
// Protocol states -- accumulates pending packets until signaled as ready.
protocol_states: HashMap<ProtocolId, ProtocolState>,
@ -123,8 +123,8 @@ impl Session {
remote_address: "Handshake".to_owned(),
local_address: local_addr,
},
ping_time_ns: 0,
pong_time_ns: None,
ping_time: Instant::now(),
pong_time: None,
expired: false,
protocol_states: HashMap::new(),
compression: false,
@ -299,13 +299,13 @@ impl Session {
if let State::Handshake(_) = self.state {
return true;
}
let timed_out = if let Some(pong) = self.pong_time_ns {
pong - self.ping_time_ns > PING_TIMEOUT_SEC * 1000_000_000
let timed_out = if let Some(pong) = self.pong_time {
pong.duration_since(self.ping_time) > Duration::from_secs(PING_TIMEOUT_SEC)
} else {
time::precise_time_ns() - self.ping_time_ns > PING_TIMEOUT_SEC * 1000_000_000
self.ping_time.elapsed() > Duration::from_secs(PING_TIMEOUT_SEC)
};
if !timed_out && time::precise_time_ns() - self.ping_time_ns > PING_INTERVAL_SEC * 1000_000_000 {
if !timed_out && self.ping_time.elapsed() > Duration::from_secs(PING_INTERVAL_SEC) {
if let Err(e) = self.send_ping(io) {
debug!("Error sending ping message: {:?}", e);
}
@ -368,9 +368,11 @@ impl Session {
Ok(SessionData::Continue)
},
PACKET_PONG => {
let time = time::precise_time_ns();
self.pong_time_ns = Some(time);
self.info.ping_ms = Some((time - self.ping_time_ns) / 1000_000);
let time = Instant::now();
self.pong_time = Some(time);
let ping_elapsed = time.duration_since(self.ping_time);
self.info.ping_ms = Some(ping_elapsed.as_secs() * 1_000 +
ping_elapsed.subsec_nanos() as u64 / 1_000_000);
Ok(SessionData::Continue)
},
PACKET_GET_PEERS => Ok(SessionData::None), //TODO;
@ -482,11 +484,11 @@ impl Session {
Ok(())
}
/// Senf ping packet
/// Send ping packet
pub fn send_ping<Message>(&mut self, io: &IoContext<Message>) -> Result<(), Error> where Message: Send + Sync + Clone {
self.send_packet(io, None, PACKET_PING, &EMPTY_LIST_RLP)?;
self.ping_time_ns = time::precise_time_ns();
self.pong_time_ns = None;
self.ping_time = Instant::now();
self.pong_time = None;
Ok(())
}

1
util/trace-time/Cargo.toml
View File

@ -4,5 +4,4 @@ version = "0.1.0"
authors = ["Parity Technologies <admin@parity.io>"]
[dependencies]
time = "0.1.34"
log = "0.3"

12
util/trace-time/src/lib.rs
View File

@ -16,11 +16,10 @@
//! Performance timer with logging
extern crate time;
#[macro_use]
extern crate log;
use time::precise_time_ns;
use std::time::Instant;
#[macro_export]
macro_rules! trace_time {
@ -33,7 +32,7 @@ macro_rules! trace_time {
/// elapsed time in the destructor or when `stop` is called.
pub struct PerfTimer {
name: &'static str,
start: u64,
start: Instant,
}
impl PerfTimer {
@ -41,13 +40,16 @@ impl PerfTimer {
pub fn new(name: &'static str) -> PerfTimer {
PerfTimer {
name,
start: precise_time_ns(),
start: Instant::now(),
}
}
}
impl Drop for PerfTimer {
fn drop(&mut self) {
trace!(target: "perf", "{}: {:.2}ms", self.name, (precise_time_ns() - self.start) as f32 / 1000_000.0);
let elapsed = self.start.elapsed();
let ms = elapsed.subsec_nanos() as f32 / 1_000_000.0 +
elapsed.as_secs() as f32 * 1_000.0;
trace!(target: "perf", "{}: {:.2}ms", self.name, ms);
}
}

1
whisper/Cargo.toml
View File

@ -23,7 +23,6 @@ serde_derive = "1.0"
serde_json = "1.0"
slab = "0.3"
smallvec = "0.4"
time = "0.1"
tiny-keccak = "1.3"
jsonrpc-core = { git = "https://github.com/paritytech/jsonrpc.git", branch = "parity-1.10" }

1
whisper/src/lib.rs
View File

@ -31,7 +31,6 @@ extern crate ring;
extern crate serde;
extern crate slab;
extern crate smallvec;
extern crate time;
extern crate tiny_keccak;
extern crate jsonrpc_core;

6
whisper/src/message.rs
View File

@ -17,7 +17,7 @@
//! Whisper message parsing, handlers, and construction.
use std::fmt;
use std::time::{self, SystemTime, Duration};
use std::time::{self, SystemTime, Duration, Instant};
use ethereum_types::{H256, H512};
use rlp::{self, DecoderError, RlpStream, UntrustedRlp};
@ -299,9 +299,9 @@ impl Message {
let mut nonce: [u8; 8] = rng.gen();
let mut best_found = try_nonce(&nonce);
let start = ::time::precise_time_ns();
let start = Instant::now();
while ::time::precise_time_ns() <= start + params.work * 1_000_000 {
while start.elapsed() <= Duration::from_millis(params.work) {
let temp_nonce = rng.gen();
let hash = try_nonce(&temp_nonce);