Move util into here

.gitignore

@@ -20,3 +20,7 @@ Cargo.lock
 
 # gdb files
 .gdb_history
+
+/json-tests/target/
+
+

Cargo.toml

@@ -9,7 +9,7 @@ authors = ["Ethcore <[email protected]>"]
 [dependencies]
 log = "0.3"
 env_logger = "0.3"
-ethcore-util = { path = "../ethcore-util" }
+ethcore-util = { path = "util" }
 rustc-serialize = "0.3"
 flate2 = "0.2"
 rocksdb = "0.3"

util/.travis.yml

@@ -0,0 +1,33 @@
+language: rust
+
+rust:
+    - beta
+
+os:
+    #- linux
+    - osx
+
+before_script:
+    # g++4.8 for C++11 which is required by rocksdb
+    #- if [ $TRAVIS_OS_NAME == "linux" ]; then 
+        #sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+        #sudo apt-get update -y -qq
+        #sudo apt-get install -qq --yes --force-yes g++-4.8
+        #sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 50
+
+        #wget https://github.com/facebook/rocksdb/archive/rocksdb-3.13.tar.gz
+        #tar xvf rocksdb-3.13.tar.gz && cd rocksdb-rocksdb-3.13 && make shared_lib
+        #sudo make install
+        #cd ..
+      #else
+    - brew update
+    - brew install rocksdb
+      #fi
+
+after_success:
+    #- if [ $TRAVIS_OS_NAME == "linux" ]; then 
+        #sudo apt-get install libcurl4-openssl-dev libelf-dev libdw-dev
+        #wget https://github.com/SimonKagstrom/kcov/archive/master.tar.gz
+        #tar xzf master.tar.gz && mkdir kcov-master/build && cd kcov-master/build && cmake .. && make && sudo make install && cd ../.. &&
+        #kcov --coveralls-id=$TRAVIS_JOB_ID --exclude-pattern=/.cargo target/kcov target/debug/ethcore_util-*
+      #fi

util/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+description = "Ethcore utility library"
+homepage = "http://ethcore.io"
+license = "GPL-3.0"
+name = "ethcore-util"
+version = "0.1.0"
+authors = ["Ethcore <[email protected]>"]
+build = "build.rs"
+
+[build-dependencies]
+gcc = "0.3"
+
+[dependencies]
+log = "0.3"
+env_logger = "0.3"
+rustc-serialize = "0.3"
+arrayvec = "0.3"
+mio = "0.5.0"
+rand = "0.3.12"
+time = "0.1.34"
+tiny-keccak = "1.0"
+rocksdb = "0.3"
+lazy_static = "0.1"
+eth-secp256k1 = { git = "https://github.com/arkpar/rust-secp256k1.git" }
+rust-crypto = "0.2.34"
+elastic-array = "0.4"
+heapsize = "0.2"
+itertools = "0.4"
+slab = { git = "https://github.com/arkpar/slab.git" }
+
+[dev-dependencies]
+json-tests = { path = "json-tests" }

util/Makefile

@@ -0,0 +1,12 @@
+# Makefile for cross-compilation
+IOS_ARCHS = i386-apple-ios x86_64-apple-ios armv7-apple-ios armv7s-apple-ios aarch64-apple-ios
+IOS_LIB = libethcore_util.a
+
+ios: $(IOS_LIB)
+
+.PHONY: $(IOS_ARCHS)
+$(IOS_ARCHS): %:
+	multirust run ios cargo build --target $@
+
+$(IOS_LIB): $(IOS_ARCHS)
+	lipo -create -output $@ $(foreach arch,$(IOS_ARCHS),$(wildcard target/$(arch)/debug/$(IOS_LIB)))

util/README.md

@@ -0,0 +1 @@
+# ethcore-util

util/benches/rlp.rs

@@ -0,0 +1,96 @@
+//! benchmarking for rlp
+//! should be started with:
+//! ```bash
+//! multirust run nightly cargo bench
+//! ```
+
+#![feature(test)]
+
+extern crate test;
+extern crate ethcore_util;
+
+use test::Bencher;
+use std::str::FromStr;
+use ethcore_util::rlp::*;
+use ethcore_util::uint::U256;
+
+#[bench]
+fn bench_stream_u64_value(b: &mut Bencher) {
+	b.iter(|| {
+		// u64
+		let mut stream = RlpStream::new();
+		stream.append(&0x1023456789abcdefu64);
+		let _ = stream.out();
+	});
+}
+
+#[bench]
+fn bench_decode_u64_value(b: &mut Bencher) {
+	b.iter(|| {
+		// u64
+		let data = vec![0x88, 0x10, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef];
+		let rlp = Rlp::new(&data);
+		let _: u64 = rlp.as_val();
+	});
+}
+
+#[bench]
+fn bench_stream_u256_value(b: &mut Bencher) {
+	b.iter(|| {
+		// u256
+		let mut stream = RlpStream::new();
+		stream.append(&U256::from_str("8090a0b0c0d0e0f009102030405060770000000000000001000000000\
+		                               00012f0")
+			               .unwrap());
+		let _ = stream.out();
+	});
+}
+
+#[bench]
+fn bench_decode_u256_value(b: &mut Bencher) {
+	b.iter(|| {
+		// u256
+		let data = vec![0xa0, 0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, 0x09, 0x10, 0x20,
+		                0x30, 0x40, 0x50, 0x60, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		                0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xf0];
+		let rlp = Rlp::new(&data);
+		let _ : U256 = rlp.as_val();
+	});
+}
+
+#[bench]
+fn bench_stream_nested_empty_lists(b: &mut Bencher) {
+	b.iter(|| {
+		// [ [], [[]], [ [], [[]] ] ]
+		let mut stream = RlpStream::new_list(3);
+		stream.append_list(0);
+		stream.append_list(1).append_list(0);
+		stream.append_list(2).append_list(0).append_list(1).append_list(0);
+		let _ = stream.out();
+	});
+}
+
+#[bench]
+fn bench_decode_nested_empty_lists(b: &mut Bencher) {
+	b.iter(|| {
+		// [ [], [[]], [ [], [[]] ] ]
+		let data = vec![0xc7, 0xc0, 0xc1, 0xc0, 0xc3, 0xc0, 0xc1, 0xc0];
+		let rlp = Rlp::new(&data);
+		let _v0: Vec<u16> = rlp.val_at(0);
+		let _v1: Vec<Vec<u16>> = rlp.val_at(1);
+		let nested_rlp = rlp.at(2);
+		let _v2a: Vec<u16> = nested_rlp.val_at(0);
+		let _v2b: Vec<Vec<u16>> = nested_rlp.val_at(1);
+	});
+}
+
+#[bench]
+fn bench_stream_1000_empty_lists(b: &mut Bencher) {
+	b.iter(|| {
+		let mut stream = RlpStream::new_list(1000);
+		for _ in 0..1000 {
+			stream.append_list(0);
+		}
+		let _ = stream.out();
+	});
+}

util/benches/trie.rs

@@ -0,0 +1,198 @@
+#![feature(test)]
+
+extern crate test;
+extern crate rand;
+extern crate ethcore_util;
+#[macro_use]
+extern crate log;
+
+use test::Bencher;
+use ethcore_util::hash::*;
+use ethcore_util::bytes::*;
+use ethcore_util::trie::*;
+use ethcore_util::hashdb::*;
+use ethcore_util::memorydb::*;
+use ethcore_util::triehash::*;
+use ethcore_util::sha3::*;
+
+
+fn random_word(alphabet: &[u8], min_count: usize, diff_count: usize, seed: &mut H256) -> Vec<u8> {
+	assert!(min_count + diff_count <= 32);
+	*seed = seed.sha3();
+	let r = min_count + (seed.bytes()[31] as usize % (diff_count + 1));
+	let mut ret: Vec<u8> = Vec::with_capacity(r);
+	for i in 0..r {
+		ret.push(alphabet[seed.bytes()[i] as usize % alphabet.len()]);
+	}
+	ret
+}
+
+fn random_bytes(min_count: usize, diff_count: usize, seed: &mut H256) -> Vec<u8> {
+	assert!(min_count + diff_count <= 32);
+	*seed = seed.sha3();
+	let r = min_count + (seed.bytes()[31] as usize % (diff_count + 1));
+	seed.bytes()[0..r].to_vec()
+}
+
+fn random_value(seed: &mut H256) -> Bytes {
+	*seed = seed.sha3();
+	match seed.bytes()[0] % 2 {
+		1 => vec![seed.bytes()[31];1],
+		_ => seed.bytes().to_vec(),
+	}
+}
+
+#[bench]
+fn trie_insertions_six_high(b: &mut Bencher) {
+	let mut d: Vec<(Bytes, Bytes)> = Vec::new();
+	let mut seed = H256::new();
+	for _ in 0..1000 {
+		let k = random_bytes(6, 0, &mut seed);
+		let v = random_value(&mut seed);
+		d.push((k, v))
+	}
+
+	b.iter(||{
+		let mut memdb = MemoryDB::new();
+		let mut root = H256::new();
+		let mut t = TrieDBMut::new(&mut memdb, &mut root);
+		for i in d.iter() {
+			t.insert(&i.0, &i.1);
+		}
+	})
+}
+
+#[bench]
+fn triehash_insertions_six_high(b: &mut Bencher) {
+	let mut d: Vec<(Bytes, Bytes)> = Vec::new();
+	let mut seed = H256::new();
+	for _ in 0..1000 {
+		let k = random_bytes(6, 0, &mut seed);
+		let v = random_value(&mut seed);
+		d.push((k, v))
+	}
+
+	b.iter(&||{
+		trie_root(d.clone());
+	})
+}
+
+#[bench]
+fn trie_insertions_six_mid(b: &mut Bencher) {
+	let alphabet = b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_";
+	let mut d: Vec<(Bytes, Bytes)> = Vec::new();
+	let mut seed = H256::new();
+	for _ in 0..1000 {
+		let k = random_word(alphabet, 6, 0, &mut seed);
+		let v = random_value(&mut seed);
+		d.push((k, v))
+	}
+	b.iter(||{
+		let mut memdb = MemoryDB::new();
+		let mut root = H256::new();
+		let mut t = TrieDBMut::new(&mut memdb, &mut root);
+		for i in d.iter() {
+			t.insert(&i.0, &i.1);
+		}
+		debug!("hash_count={:?}", t.hash_count);
+	})
+}
+
+#[bench]
+fn triehash_insertions_six_mid(b: &mut Bencher) {
+	let alphabet = b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_";
+	let mut d: Vec<(Bytes, Bytes)> = Vec::new();
+	let mut seed = H256::new();
+	for _ in 0..1000 {
+		let k = random_word(alphabet, 6, 0, &mut seed);
+		let v = random_value(&mut seed);
+		d.push((k, v))
+	}
+	b.iter(||{
+		trie_root(d.clone());
+	})
+}
+
+#[bench]
+fn trie_insertions_random_mid(b: &mut Bencher) {
+	let alphabet = b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_";
+	let mut d: Vec<(Bytes, Bytes)> = Vec::new();
+	let mut seed = H256::new();
+	for _ in 0..1000 {
+		let k = random_word(alphabet, 1, 5, &mut seed);
+		let v = random_value(&mut seed);
+		d.push((k, v))
+	}
+
+	b.iter(||{
+		let mut memdb = MemoryDB::new();
+		let mut root = H256::new();
+		let mut t = TrieDBMut::new(&mut memdb, &mut root);
+		for i in d.iter() {
+			t.insert(&i.0, &i.1);
+		}
+	})
+}
+
+#[bench]
+fn triehash_insertions_random_mid(b: &mut Bencher) {
+	let alphabet = b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_";
+	let mut d: Vec<(Bytes, Bytes)> = Vec::new();
+	let mut seed = H256::new();
+	for _ in 0..1000 {
+		let k = random_word(alphabet, 1, 5, &mut seed);
+		let v = random_value(&mut seed);
+		d.push((k, v))
+	}
+
+	b.iter(||{
+		trie_root(d.clone());
+	})
+}
+
+#[bench]
+fn trie_insertions_six_low(b: &mut Bencher) {
+	let alphabet = b"abcdef";
+	let mut d: Vec<(Bytes, Bytes)> = Vec::new();
+	let mut seed = H256::new();
+	for _ in 0..1000 {
+		let k = random_word(alphabet, 6, 0, &mut seed);
+		let v = random_value(&mut seed);
+		d.push((k, v))
+	}
+
+	b.iter(||{
+		let mut memdb = MemoryDB::new();
+		let mut root = H256::new();
+		let mut t = TrieDBMut::new(&mut memdb, &mut root);
+		for i in d.iter() {
+			t.insert(&i.0, &i.1);
+		}
+	})
+}
+
+#[bench]
+fn triehash_insertions_six_low(b: &mut Bencher) {
+	let alphabet = b"abcdef";
+	let mut d: Vec<(Bytes, Bytes)> = Vec::new();
+	let mut seed = H256::new();
+	for _ in 0..1000 {
+		let k = random_word(alphabet, 6, 0, &mut seed);
+		let v = random_value(&mut seed);
+		d.push((k, v))
+	}
+
+	b.iter(||{
+		trie_root(d.clone());
+	})
+}
+
+#[bench]
+fn sha3x10000(b: &mut Bencher) {
+	b.iter(||{
+		let mut seed = H256::new();
+		for _ in 0..10000 {
+			seed = seed.sha3()
+		}
+	})
+}