Merge remote-tracking branch 'origin/main' into parallel-k2-k3-pows

Author: poszu

Cargo.toml

@@ -26,6 +26,7 @@ scrypt-jane = { git = "https://github.com/spacemeshos/scrypt-jane-rs", branch =
 blake3 = "1.3.3"
 bitvec = "1.0.1"
 rayon = "1.6.1"
+rand = "0.8.5"
 
 [dev-dependencies]
 criterion = "0.4"

benches/proving.rs

@@ -1,7 +1,7 @@
 use std::hint::black_box;
 
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use post::{prove::ConstDProver, prove::Prover, prove::ProvingParams};
+use post::{prove::Prover, prove::Prover8_56, prove::ProvingParams};
 use pprof::criterion::{Output, PProfProfiler};
 use rand::{thread_rng, RngCore};
 use rayon::prelude::{ParallelBridge, ParallelIterator};
@@ -23,7 +23,7 @@ fn threads_to_str(threads: usize) -> String {
 fn prover_bench(c: &mut Criterion) {
     let mut group = c.benchmark_group("proving");
 
-    let mut data = vec![0; 32 * MIB];
+    let mut data = vec![0; 64 * MIB];
     thread_rng().fill_bytes(&mut data);
     group.throughput(criterion::Throughput::Bytes(data.len() as u64));
 
@@ -36,8 +36,8 @@ fn prover_bench(c: &mut Criterion) {
     };
 
     for (nonces, threads) in itertools::iproduct!(
-        [2, 20, 200],
-        [0, 1] // 0 == automatic
+        [16, 32, 64],
+        [1, 0] // 0 == automatic
     ) {
         group.bench_with_input(
             BenchmarkId::new(
@@ -46,7 +46,7 @@ fn prover_bench(c: &mut Criterion) {
             ),
             &(nonces, threads),
             |b, &(nonces, threads)| {
-                let prover = ConstDProver::new(CHALLENGE, 0..nonces, params.clone());
+                let prover = Prover8_56::new(CHALLENGE, 0..nonces, params.clone()).unwrap();
                 b.iter(|| {
                     let f = black_box(|_, _| None);
                     match threads {

src/cipher.rs

@@ -37,6 +37,26 @@ impl AesCipher {
             k2_pow,
         }
     }
+
+    pub(crate) fn new_lazy(
+        challenge: &[u8; 32],
+        nonce: u32,
+        nonce_group: u32,
+        k2_pow: u64,
+    ) -> Self {
+        let mut hasher = blake3::Hasher::new();
+        hasher.update(challenge);
+        hasher.update(&nonce_group.to_le_bytes());
+        hasher.update(&k2_pow.to_le_bytes());
+        hasher.update(&nonce.to_le_bytes());
+        Self {
+            aes: Aes128::new(GenericArray::from_slice(
+                &hasher.finalize().as_bytes()[..16],
+            )),
+            nonce_group,
+            k2_pow,
+        }
+    }
 }
 
 #[cfg(test)]

src/compression.rs

@@ -24,6 +24,7 @@ pub(crate) fn required_bits(value: u64) -> usize {
 }
 
 #[cfg(test)]
+#[allow(clippy::unusual_byte_groupings)]
 mod tests {
     use super::*;
     use itertools::max;

src/difficulty.rs

@@ -1,18 +1,36 @@
+use eyre::Context;
+
 /// Calculate proving difficulty.
+///
+/// K1 defines how many good labels are expected to be within all the labels.
 /// The lower the value of K1 - the more difficult it will be to find a good label.
-pub(crate) fn proving_difficulty(num_labels: u64, k1: u32) -> eyre::Result<u64> {
+///
+/// The difficulty is calculated as:
+/// difficulty = 2^64 * K1 / num_labels
+pub(crate) fn proving_difficulty(k1: u32, num_labels: u64) -> eyre::Result<u64> {
     eyre::ensure!(num_labels > 0, "number of label blocks must be > 0");
     eyre::ensure!(
-        num_labels >= k1 as u64,
-        format!("k1 ({k1}) cannot be bigger than the number of labels ({num_labels})")
+        num_labels > k1 as u64,
+        format!("number of labels ({num_labels}) must be bigger than k1 ({k1})")
     );
+    let difficulty = (1u128 << 64) * k1 as u128 / num_labels as u128;
+    u64::try_from(difficulty).wrap_err("difficulty doesn't fit in u64")
+}
+
+#[test]
+fn zero_labels() {
+    assert!(proving_difficulty(1, 0).is_err());
+}
 
-    let x = u64::MAX / num_labels;
-    let y = u64::MAX % num_labels;
-    Ok(x * k1 as u64 + y * k1 as u64 / num_labels)
+#[test]
+fn too_big_k1() {
+    assert!(proving_difficulty(2, 1).is_err());
+    assert!(proving_difficulty(1, 1).is_err());
 }
 
 #[test]
-fn zero_blocks() {
-    assert!(proving_difficulty(0, 1).is_err());
+fn difficulty_calculation() {
+    assert_eq!(proving_difficulty(1, 2).unwrap(), 1u64 << 63);
+    assert_eq!(proving_difficulty(1, 4).unwrap(), 1u64 << (64 - 2));
+    assert_eq!(proving_difficulty(1, 128).unwrap(), 1u64 << (64 - 7));
 }

src/metadata.rs

@@ -7,7 +7,7 @@ use serde_with::serde_as;
 const METADATA_FILE_NAME: &str = "postdata_metadata.json";
 
 #[serde_as]
-#[derive(Debug, Deserialize, Serialize, Clone)]
+#[derive(Debug, Deserialize, Serialize, Clone, Default)]
 #[serde(rename_all = "PascalCase")]
 pub struct PostMetadata {
     #[serde_as(as = "Base64")]

src/pow.rs

@@ -78,14 +78,14 @@ mod tests {
     proptest! {
         #[test]
         fn test_k2_pow(nonce: u32) {
-            let difficulty = 0x7FFFFFFF_FFFFFFFF;
+            let difficulty = 0x7FFF_FFFF_FFFF_FFFF;
             let k2_pow = find_k2_pow(&[0; 32], nonce, ScryptParams::new(2,0,0), difficulty);
             assert!(hash_k2_pow(&[0; 32], nonce, ScryptParams::new(2,0,0), k2_pow) < difficulty);
         }
 
         #[test]
         fn test_k3_pow(nonce: u32, k2_pow: u64, indexes: [u8; 64]) {
-            let difficulty = 0x7FFFFFFF_FFFFFFFF;
+            let difficulty = 0x7FFF_FFFF_FFFF_FFFF;
             let k3_pow = find_k3_pow(&[0; 32], nonce, &indexes, ScryptParams::new(2,0,0), difficulty, k2_pow);
             assert!(hash_k3_pow(&[0; 32], nonce, &indexes, ScryptParams::new(2,0,0), k2_pow, k3_pow) < difficulty);
         }