[pull] master from broxus:master

Cargo.toml

@@ -3,7 +3,7 @@ name = "everscale-types"
 description = "A set of primitive types and utilities for the Everscale blockchain."
 authors = ["Ivan Kalinin <[email protected]>"]
 repository = "https://github.com/broxus/everscale-types"
-version = "0.1.0-rc.6"
+version = "0.1.2"
 edition = "2021"
 rust-version = "1.77"
 include = ["src/**/*.rs", "benches/**/*.rs", "LICENSE-*", "README.md"]
@@ -13,31 +13,61 @@ license = "MIT OR Apache-2.0"
 name = "boc"
 harness = false
 
+[[bench]]
+name = "mine"
+harness = false
+
+[[bench]]
+name = "dict_from_slice"
+harness = false
+
 [[bench]]
 name = "dict"
 harness = false
 
+[[bench]]
+name = "slice_uniform"
+harness = false
+
 [[bench]]
 name = "usage_cell"
 harness = false
 
+# callgrind benchmarks
+
 [[bench]]
-name = "dict_from_slice"
+name = "callgrind_boc"
+harness = false
+
+[[bench]]
+name = "callgrind_dict_from_slice"
+harness = false
+
+[[bench]]
+name = "callgrind_dict"
+harness = false
+
+[[bench]]
+name = "callgrind_slice_uniform"
+harness = false
+
+[[bench]]
+name = "callgrind_usage_cell"
 harness = false
 
 [workspace]
 members = ["proc"]
 
 [dependencies]
-ahash = "0.8"
+ahash = "0.8.11"
 anyhow = { version = "1.0", optional = true }
 base64 = { version = "0.22", optional = true }
 bitflags = "2.3"
 blake3 = { version = "1.5", optional = true }
 bytes = { version = "1.4", optional = true }
-crc32c = "0.6"
-ed25519-dalek = { version = "2.0", optional = true }
-everscale-crypto = { version = "0.2", features = ["tl-proto"], optional = true }
+crc32c = "0.6.8"
+ed25519-dalek = { version = "2.1.1", optional = true }
+everscale-crypto = { version = "0.3", features = ["tl-proto"], optional = true }
 hex = "0.4"
 num-bigint = { version = "0.4", optional = true }
 num-traits = { version = "0.2", optional = true }
@@ -47,10 +77,11 @@ scc = { version = "2.1", optional = true }
 serde = { version = "1", features = ["derive"], optional = true }
 sha2 = "0.10"
 smallvec = { version = "1.9", features = ["union"] }
-thiserror = "1.0"
-tl-proto = { version = "0.4", optional = true }
+thiserror = "2.0"
+tl-proto = { version = "0.5.1", optional = true }
+typeid = { version = "1.0", optional = true }
 
-everscale-types-proc = { version = "=0.1.4", path = "proc" }
+everscale-types-proc = { version = "=0.1.5", path = "proc" }
 
 [dev-dependencies]
 anyhow = "1.0"
@@ -60,6 +91,8 @@ rand = "0.8"
 rand_xorshift = "0.3"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+iai-callgrind = "0.14"
+paste = "1.0.15"
 
 [features]
 default = ["base64", "serde", "models", "sync"]
@@ -77,6 +110,7 @@ abi = [
     "dep:num-bigint",
     "dep:num-traits",
     "dep:serde",
+    "dep:typeid",
     "models",
 ]
 venom = []
@@ -104,3 +138,6 @@ opt-level = 1
 
 [package.metadata.docs.rs]
 features = ["base64", "serde", "models", "sync", "stats", "abi"]
+
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(fuzzing)'] }

benches/callgrind_boc.rs

@@ -0,0 +1,74 @@
+use everscale_types::boc::Boc;
+use everscale_types::cell::Cell;
+use iai_callgrind::{library_benchmark, library_benchmark_group, main};
+use std::hint::black_box;
+
+#[macro_export]
+macro_rules! decl_boc_benches {
+    ($(
+        $name:literal
+    ),* $(,)?) => {
+        // generate setup functions for raw bytes
+        $(
+            paste::paste! {
+                fn [<$name _setup>]() -> &'static [u8] {
+                     include_bytes!(concat!("data/", $name))
+                }
+            }
+        )*
+
+        // generate setup functions for cells
+        $(
+            paste::paste! {
+                fn [<$name _setup_de>]() -> Cell {
+                    let bytes = include_bytes!(concat!("data/", $name));
+                    Boc::decode(&bytes).unwrap()
+                }
+            }
+        )*
+
+        // generate benchmark functions attributes for decode / encode
+        paste::paste! {
+            #[library_benchmark]
+            $(
+                #[bench::[<$name>](setup = [<$name _setup>])]
+            )*
+            fn deserialize_boc(input: &[u8]) {
+                let result = Boc::decode(input);
+                _ = black_box(result);
+            }
+
+            #[library_benchmark]
+            $(
+                #[bench::[<$name>](setup = [<$name _setup_de>])]
+            )*
+            fn serialize_boc(input: Cell) {
+                let result = Boc::encode(&input);
+                _ = black_box(result);
+                std::mem::forget(input);
+            }
+        }
+    };
+}
+
+decl_boc_benches![
+    "external_message",
+    "internal_message_empty",
+    "internal_message_with_body",
+    "internal_message_with_deploy",
+    "masterchain_block",
+    "masterchain_key_block",
+    "shard_block_empty",
+    "shard_block_with_messages",
+    "masterchain_block_proof",
+    "shard_block_proof"
+];
+
+library_benchmark_group!(
+    name = benches;
+    benchmarks =
+        deserialize_boc,
+        serialize_boc
+);
+
+main!(library_benchmark_groups = benches);

benches/callgrind_dict.rs

@@ -0,0 +1,35 @@
+use everscale_types::{cell::*, dict::*};
+use iai_callgrind::{library_benchmark, library_benchmark_group, main};
+use rand::distributions::{Distribution, Standard};
+use rand::{Rng, SeedableRng};
+use std::hint::black_box;
+
+fn build_dict<K, V>(num_elements: usize) -> Dict<K, V>
+where
+    Standard: Distribution<K> + Distribution<V>,
+    K: Store + DictKey,
+    V: Store,
+{
+    let mut rng = rand_xorshift::XorShiftRng::from_seed([0u8; 16]);
+
+    let mut result = Dict::<K, V>::new();
+    for _ in 0..num_elements {
+        let key = rng.gen::<K>();
+        let value = rng.gen::<V>();
+        result.set(key, value).unwrap();
+    }
+    result
+}
+
+#[library_benchmark]
+#[bench::small(10)]
+#[bench::medium(100)]
+#[bench::large(1000)]
+#[bench::xlarge(10000)]
+fn bench_build_dict_u64_u64(num_elements: usize) -> Dict<u64, u64> {
+    black_box(build_dict(num_elements))
+}
+
+library_benchmark_group!(name = build_dict; benchmarks = bench_build_dict_u64_u64);
+
+main!(library_benchmark_groups = build_dict);

benches/callgrind_dict_from_slice.rs

@@ -0,0 +1,63 @@
+use everscale_types::{cell::*, dict::*};
+use iai_callgrind::{library_benchmark, library_benchmark_group, main};
+use rand::distributions::{Distribution, Standard};
+use rand::{Rng, SeedableRng};
+use std::hint::black_box;
+
+fn build_dict_inserts<K, V>(num_elements: usize) -> Dict<K, V>
+where
+    Standard: Distribution<K> + Distribution<V>,
+    K: Store + DictKey,
+    V: Store,
+{
+    let mut rng = rand_xorshift::XorShiftRng::from_seed([0u8; 16]);
+
+    let mut result = Dict::<K, V>::new();
+    for _ in 0..num_elements {
+        let key = rng.gen::<K>();
+        let value = rng.gen::<V>();
+        result.add(key, value).unwrap();
+    }
+    result
+}
+
+fn build_dict_leaves<K, V>(num_elements: usize) -> Dict<K, V>
+where
+    Standard: Distribution<K> + Distribution<V>,
+    K: Store + DictKey + Ord,
+    V: Store,
+{
+    let mut rng = rand_xorshift::XorShiftRng::from_seed([0u8; 16]);
+
+    let mut values = (0..num_elements)
+        .map(|_| (rng.gen::<K>(), rng.gen::<V>()))
+        .collect::<Vec<_>>();
+    values.sort_by(|(l, _), (r, _)| l.cmp(r));
+
+    Dict::<K, V>::try_from_sorted_slice(&values).unwrap()
+}
+
+#[library_benchmark]
+#[bench::small(10)]
+#[bench::medium(100)]
+#[bench::large(1000)]
+#[bench::xlarge(10000)]
+fn bench_build_dict_u64_u64_inserts(num_elements: usize) -> Dict<u64, u64> {
+    black_box(build_dict_inserts(num_elements))
+}
+
+#[library_benchmark]
+#[bench::small(10)]
+#[bench::medium(100)]
+#[bench::large(1000)]
+#[bench::xlarge(10000)]
+fn bench_build_dict_u64_u64_leaves(num_elements: usize) -> Dict<u64, u64> {
+    black_box(build_dict_leaves(num_elements))
+}
+
+library_benchmark_group!(
+    name = build_dict;
+    benchmarks = bench_build_dict_u64_u64_inserts, bench_build_dict_u64_u64_leaves
+);
+
+main!(library_benchmark_groups = build_dict);

benches/callgrind_slice_uniform.rs

@@ -0,0 +1,24 @@
+use everscale_types::prelude::*;
+use iai_callgrind::{library_benchmark, library_benchmark_group, main};
+use std::hint::black_box;
+
+#[library_benchmark]
+#[bench::small(2)]
+#[bench::medium(4)]
+#[bench::large(8)]
+#[bench::xlarge(10)]
+fn test(bits: u32) {
+    let mut builder = CellBuilder::new();
+    builder.store_zeros(2u16.pow(bits) - 1u16).unwrap();
+    let cell = builder.build().unwrap();
+
+    let slice = cell.as_slice().unwrap();
+    black_box(slice.test_uniform());
+}
+
+library_benchmark_group!(
+    name = test_uniform;
+    benchmarks = test
+);
+
+main!(library_benchmark_groups = test_uniform);