365 lines
11 KiB
Rust
365 lines
11 KiB
Rust
// Copyright 2015-2020 Parity Technologies (UK) Ltd.
|
|
// This file is part of OpenEthereum.
|
|
|
|
// OpenEthereum is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// OpenEthereum is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with OpenEthereum. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
use compute::Light;
|
|
use either::Either;
|
|
use keccak::{keccak_512, H256};
|
|
use memmap::MmapMut;
|
|
use parking_lot::Mutex;
|
|
use seed_compute::SeedHashCompute;
|
|
|
|
use shared::{epoch, get_cache_size, to_hex, Node, ETHASH_CACHE_ROUNDS, NODE_BYTES, NODE_DWORDS};
|
|
|
|
use std::{
|
|
borrow::Cow,
|
|
fs,
|
|
io::{self, Read, Write},
|
|
path::{Path, PathBuf},
|
|
slice,
|
|
sync::Arc,
|
|
};
|
|
|
|
type Cache = Either<Vec<Node>, MmapMut>;
|
|
|
|
#[derive(PartialEq, Eq, Debug, Clone, Copy)]
|
|
pub enum OptimizeFor {
|
|
Cpu,
|
|
Memory,
|
|
}
|
|
|
|
impl Default for OptimizeFor {
|
|
fn default() -> Self {
|
|
OptimizeFor::Cpu
|
|
}
|
|
}
|
|
|
|
fn byte_size(cache: &Cache) -> usize {
|
|
use self::Either::{Left, Right};
|
|
|
|
match *cache {
|
|
Left(ref vec) => vec.len() * NODE_BYTES,
|
|
Right(ref mmap) => mmap.len(),
|
|
}
|
|
}
|
|
|
|
fn new_buffer(path: &Path, num_nodes: usize, ident: &H256, optimize_for: OptimizeFor) -> Cache {
|
|
let memmap = match optimize_for {
|
|
OptimizeFor::Cpu => None,
|
|
OptimizeFor::Memory => make_memmapped_cache(path, num_nodes, ident).ok(),
|
|
};
|
|
|
|
memmap
|
|
.map(Either::Right)
|
|
.unwrap_or_else(|| Either::Left(make_memory_cache(num_nodes, ident)))
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct NodeCacheBuilder {
|
|
// TODO: Remove this locking and just use an `Rc`?
|
|
seedhash: Arc<Mutex<SeedHashCompute>>,
|
|
optimize_for: OptimizeFor,
|
|
progpow_transition: u64,
|
|
}
|
|
|
|
// TODO: Abstract the "optimize for" logic
|
|
pub struct NodeCache {
|
|
builder: NodeCacheBuilder,
|
|
cache_dir: Cow<'static, Path>,
|
|
cache_path: PathBuf,
|
|
epoch: u64,
|
|
cache: Cache,
|
|
}
|
|
|
|
impl NodeCacheBuilder {
|
|
pub fn light(&self, cache_dir: &Path, block_number: u64) -> Light {
|
|
Light::new_with_builder(self, cache_dir, block_number, self.progpow_transition)
|
|
}
|
|
|
|
pub fn light_from_file(&self, cache_dir: &Path, block_number: u64) -> io::Result<Light> {
|
|
Light::from_file_with_builder(self, cache_dir, block_number, self.progpow_transition)
|
|
}
|
|
|
|
pub fn new<T: Into<Option<OptimizeFor>>>(optimize_for: T, progpow_transition: u64) -> Self {
|
|
NodeCacheBuilder {
|
|
seedhash: Arc::new(Mutex::new(SeedHashCompute::default())),
|
|
optimize_for: optimize_for.into().unwrap_or_default(),
|
|
progpow_transition,
|
|
}
|
|
}
|
|
|
|
fn block_number_to_ident(&self, block_number: u64) -> H256 {
|
|
self.seedhash.lock().hash_block_number(block_number)
|
|
}
|
|
|
|
fn epoch_to_ident(&self, epoch: u64) -> H256 {
|
|
self.seedhash.lock().hash_epoch(epoch)
|
|
}
|
|
|
|
pub fn from_file<P: Into<Cow<'static, Path>>>(
|
|
&self,
|
|
cache_dir: P,
|
|
block_number: u64,
|
|
) -> io::Result<NodeCache> {
|
|
let cache_dir = cache_dir.into();
|
|
let ident = self.block_number_to_ident(block_number);
|
|
|
|
let path = cache_path(cache_dir.as_ref(), &ident);
|
|
|
|
let cache = cache_from_path(&path, self.optimize_for)?;
|
|
let expected_cache_size = get_cache_size(block_number);
|
|
|
|
if byte_size(&cache) == expected_cache_size {
|
|
Ok(NodeCache {
|
|
builder: self.clone(),
|
|
epoch: epoch(block_number),
|
|
cache_dir: cache_dir,
|
|
cache_path: path,
|
|
cache: cache,
|
|
})
|
|
} else {
|
|
Err(io::Error::new(
|
|
io::ErrorKind::InvalidData,
|
|
"Node cache is of incorrect size",
|
|
))
|
|
}
|
|
}
|
|
|
|
pub fn new_cache<P: Into<Cow<'static, Path>>>(
|
|
&self,
|
|
cache_dir: P,
|
|
block_number: u64,
|
|
) -> NodeCache {
|
|
let cache_dir = cache_dir.into();
|
|
let ident = self.block_number_to_ident(block_number);
|
|
|
|
let cache_size = get_cache_size(block_number);
|
|
|
|
// We use `debug_assert` since it is impossible for `get_cache_size` to return an unaligned
|
|
// value with the current implementation. If the implementation changes, CI will catch it.
|
|
debug_assert!(cache_size % NODE_BYTES == 0, "Unaligned cache size");
|
|
let num_nodes = cache_size / NODE_BYTES;
|
|
|
|
let path = cache_path(cache_dir.as_ref(), &ident);
|
|
let nodes = new_buffer(&path, num_nodes, &ident, self.optimize_for);
|
|
|
|
NodeCache {
|
|
builder: self.clone(),
|
|
epoch: epoch(block_number),
|
|
cache_dir: cache_dir.into(),
|
|
cache_path: path,
|
|
cache: nodes,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl NodeCache {
|
|
pub fn cache_path(&self) -> &Path {
|
|
&self.cache_path
|
|
}
|
|
|
|
pub fn flush(&mut self) -> io::Result<()> {
|
|
if let Some(last) = self
|
|
.epoch
|
|
.checked_sub(2)
|
|
.map(|ep| cache_path(self.cache_dir.as_ref(), &self.builder.epoch_to_ident(ep)))
|
|
{
|
|
fs::remove_file(last).unwrap_or_else(|error| match error.kind() {
|
|
io::ErrorKind::NotFound => (),
|
|
_ => warn!("Error removing stale DAG cache: {:?}", error),
|
|
});
|
|
}
|
|
|
|
consume_cache(&mut self.cache, &self.cache_path)
|
|
}
|
|
}
|
|
|
|
fn make_memmapped_cache(path: &Path, num_nodes: usize, ident: &H256) -> io::Result<MmapMut> {
|
|
use std::fs::OpenOptions;
|
|
|
|
let file = OpenOptions::new()
|
|
.read(true)
|
|
.write(true)
|
|
.create(true)
|
|
.open(&path)?;
|
|
file.set_len((num_nodes * NODE_BYTES) as _)?;
|
|
|
|
let mut memmap = unsafe { MmapMut::map_mut(&file)? };
|
|
|
|
unsafe { initialize_memory(memmap.as_mut_ptr() as *mut Node, num_nodes, ident) };
|
|
|
|
Ok(memmap)
|
|
}
|
|
|
|
fn make_memory_cache(num_nodes: usize, ident: &H256) -> Vec<Node> {
|
|
let mut nodes: Vec<Node> = Vec::with_capacity(num_nodes);
|
|
// Use uninit instead of unnecessarily writing `size_of::<Node>() * num_nodes` 0s
|
|
unsafe {
|
|
initialize_memory(nodes.as_mut_ptr(), num_nodes, ident);
|
|
nodes.set_len(num_nodes);
|
|
}
|
|
|
|
nodes
|
|
}
|
|
|
|
fn cache_path<'a, P: Into<Cow<'a, Path>>>(path: P, ident: &H256) -> PathBuf {
|
|
let mut buf = path.into().into_owned();
|
|
buf.push(to_hex(ident));
|
|
buf
|
|
}
|
|
|
|
fn consume_cache(cache: &mut Cache, path: &Path) -> io::Result<()> {
|
|
use std::fs::OpenOptions;
|
|
|
|
match *cache {
|
|
Either::Left(ref mut vec) => {
|
|
let mut file = OpenOptions::new()
|
|
.read(true)
|
|
.write(true)
|
|
.create(true)
|
|
.open(&path)?;
|
|
|
|
let buf = unsafe {
|
|
slice::from_raw_parts_mut(vec.as_mut_ptr() as *mut u8, vec.len() * NODE_BYTES)
|
|
};
|
|
|
|
file.write_all(buf).map(|_| ())
|
|
}
|
|
Either::Right(ref mmap) => mmap.flush(),
|
|
}
|
|
}
|
|
|
|
fn cache_from_path(path: &Path, optimize_for: OptimizeFor) -> io::Result<Cache> {
|
|
let memmap = match optimize_for {
|
|
OptimizeFor::Cpu => None,
|
|
OptimizeFor::Memory => {
|
|
let file = fs::OpenOptions::new()
|
|
.read(true)
|
|
.write(true)
|
|
.create(true)
|
|
.open(path)?;
|
|
unsafe { MmapMut::map_mut(&file).ok() }
|
|
}
|
|
};
|
|
|
|
memmap
|
|
.map(Either::Right)
|
|
.ok_or(())
|
|
.or_else(|_| read_from_path(path).map(Either::Left))
|
|
}
|
|
|
|
fn read_from_path(path: &Path) -> io::Result<Vec<Node>> {
|
|
use std::{fs::File, mem};
|
|
|
|
let mut file = File::open(path)?;
|
|
|
|
let mut nodes: Vec<u8> = Vec::with_capacity(
|
|
file.metadata()
|
|
.map(|m| m.len() as _)
|
|
.unwrap_or(NODE_BYTES * 1_000_000),
|
|
);
|
|
file.read_to_end(&mut nodes)?;
|
|
|
|
nodes.shrink_to_fit();
|
|
|
|
if nodes.len() % NODE_BYTES != 0 || nodes.capacity() % NODE_BYTES != 0 {
|
|
return Err(io::Error::new(
|
|
io::ErrorKind::Other,
|
|
"Node cache is not a multiple of node size",
|
|
));
|
|
}
|
|
|
|
let out: Vec<Node> = unsafe {
|
|
Vec::from_raw_parts(
|
|
nodes.as_mut_ptr() as *mut _,
|
|
nodes.len() / NODE_BYTES,
|
|
nodes.capacity() / NODE_BYTES,
|
|
)
|
|
};
|
|
|
|
mem::forget(nodes);
|
|
|
|
Ok(out)
|
|
}
|
|
|
|
impl AsRef<[Node]> for NodeCache {
|
|
fn as_ref(&self) -> &[Node] {
|
|
match self.cache {
|
|
Either::Left(ref vec) => vec,
|
|
Either::Right(ref mmap) => unsafe {
|
|
let bytes = mmap.as_ptr();
|
|
// This isn't a safety issue, so we can keep this a debug lint. We don't care about
|
|
// people manually messing with the files unless it can cause unsafety, but if we're
|
|
// generating incorrect files then we want to catch that in CI.
|
|
debug_assert_eq!(mmap.len() % NODE_BYTES, 0);
|
|
slice::from_raw_parts(bytes as _, mmap.len() / NODE_BYTES)
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
// This takes a raw pointer and a counter because `memory` may be uninitialized. `memory` _must_ be
|
|
// a pointer to the beginning of an allocated but possibly-uninitialized block of
|
|
// `num_nodes * NODE_BYTES` bytes
|
|
//
|
|
// We have to use raw pointers to read/write uninit, using "normal" indexing causes LLVM to freak
|
|
// out. It counts as a read and causes all writes afterwards to be elided. Yes, really. I know, I
|
|
// want to refactor this to use less `unsafe` as much as the next rustacean.
|
|
unsafe fn initialize_memory(memory: *mut Node, num_nodes: usize, ident: &H256) {
|
|
let dst = memory as *mut u8;
|
|
|
|
debug_assert_eq!(ident.len(), 32);
|
|
keccak_512::unchecked(dst, NODE_BYTES, ident.as_ptr(), ident.len());
|
|
|
|
for i in 1..num_nodes {
|
|
// We use raw pointers here, see above
|
|
let dst = memory.offset(i as _) as *mut u8;
|
|
let src = memory.offset(i as isize - 1) as *mut u8;
|
|
|
|
keccak_512::unchecked(dst, NODE_BYTES, src, NODE_BYTES);
|
|
}
|
|
|
|
// Now this is initialized, we can treat it as a slice.
|
|
let nodes: &mut [Node] = slice::from_raw_parts_mut(memory, num_nodes);
|
|
|
|
// For `unroll!`, see below. If the literal in `unroll!` is not the same as the RHS here then
|
|
// these have got out of sync! Don't let this happen!
|
|
debug_assert_eq!(NODE_DWORDS, 8);
|
|
|
|
// This _should_ get unrolled by the compiler, since it's not using the loop variable.
|
|
for _ in 0..ETHASH_CACHE_ROUNDS {
|
|
for i in 0..num_nodes {
|
|
let data_idx = (num_nodes - 1 + i) % num_nodes;
|
|
let idx = nodes.get_unchecked_mut(i).as_words()[0] as usize % num_nodes;
|
|
|
|
let data = {
|
|
let mut data: Node = nodes.get_unchecked(data_idx).clone();
|
|
let rhs: &Node = nodes.get_unchecked(idx);
|
|
|
|
unroll! {
|
|
for w in 0..8 {
|
|
*data.as_dwords_mut().get_unchecked_mut(w) ^=
|
|
*rhs.as_dwords().get_unchecked(w);
|
|
}
|
|
}
|
|
|
|
data
|
|
};
|
|
|
|
keccak_512::write(&data.bytes, &mut nodes.get_unchecked_mut(i).bytes);
|
|
}
|
|
}
|
|
}
|