1use std::{array, mem::MaybeUninit};
31
32use binius_hash::Blake3Compression;
33use binius_utils::{
34 FixedSizeSerializeBytes, SerializeBytes,
35 rayon::{
36 iter::{IndexedParallelIterator, ParallelIterator},
37 slice::{ParallelSlice, ParallelSliceMut},
38 },
39};
40use blake3::{BLOCK_LEN, CHUNK_LEN, OUT_LEN};
41use digest::Output;
42
43#[cfg(all(target_arch = "x86_64", target_feature = "avx512f"))]
44use super::avx512;
45#[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
46use super::neon;
47use super::{CHUNK_END, CHUNK_START, IV, MSG_SCHEDULE, ROOT};
48use crate::{
49 parallel_compression::ParallelPseudoCompression,
50 parallel_digest::{
51 MultiDigest, ParallelDigest, ParallelDigestAdapter, ParallelMultidigestImpl,
52 },
53};
54
55#[inline(always)]
60fn quarter_round<const N: usize>(
61 v: &mut [[u32; N]; 16],
62 a: usize,
63 b: usize,
64 c: usize,
65 d: usize,
66 mx: &[u32; N],
67 my: &[u32; N],
68) {
69 for i in 0..N {
71 v[a][i] = v[a][i].wrapping_add(v[b][i]).wrapping_add(mx[i]);
72 v[d][i] = (v[d][i] ^ v[a][i]).rotate_right(16);
73 v[c][i] = v[c][i].wrapping_add(v[d][i]);
74 v[b][i] = (v[b][i] ^ v[c][i]).rotate_right(12);
75 v[a][i] = v[a][i].wrapping_add(v[b][i]).wrapping_add(my[i]);
76 v[d][i] = (v[d][i] ^ v[a][i]).rotate_right(8);
77 v[c][i] = v[c][i].wrapping_add(v[d][i]);
78 v[b][i] = (v[b][i] ^ v[c][i]).rotate_right(7);
79 }
80}
81
82#[inline(always)]
86fn round<const R: usize, const N: usize>(v: &mut [[u32; N]; 16], m: &[[u32; N]; 16]) {
87 let s = MSG_SCHEDULE[R];
89
90 quarter_round(v, 0, 4, 8, 12, &m[s[0]], &m[s[1]]);
92 quarter_round(v, 1, 5, 9, 13, &m[s[2]], &m[s[3]]);
93 quarter_round(v, 2, 6, 10, 14, &m[s[4]], &m[s[5]]);
94 quarter_round(v, 3, 7, 11, 15, &m[s[6]], &m[s[7]]);
95 quarter_round(v, 0, 5, 10, 15, &m[s[8]], &m[s[9]]);
97 quarter_round(v, 1, 6, 11, 12, &m[s[10]], &m[s[11]]);
98 quarter_round(v, 2, 7, 8, 13, &m[s[12]], &m[s[13]]);
99 quarter_round(v, 3, 4, 9, 14, &m[s[14]], &m[s[15]]);
100}
101
102#[inline(always)]
107fn load_block_words<const N: usize>(block: &[[u8; BLOCK_LEN]; N]) -> [[u32; N]; 16] {
108 #[cfg(all(target_arch = "x86_64", target_feature = "avx512f"))]
109 if avx512::handles_lanes(N) {
110 return avx512::load_block_words(block);
111 }
112
113 #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
114 if neon::transposes_lanes(N) {
115 return neon::load_block_words(block);
116 }
117
118 load_block_words_portable(block)
119}
120
121#[inline(always)]
127fn load_block_words_portable<const N: usize>(block: &[[u8; BLOCK_LEN]; N]) -> [[u32; N]; 16] {
128 let mut m = [[0u32; N]; 16];
129 for lane in 0..N {
130 for (w, slot) in m.iter_mut().enumerate() {
131 let off = w * 4;
132 slot[lane] = u32::from_le_bytes([
133 block[lane][off],
134 block[lane][off + 1],
135 block[lane][off + 2],
136 block[lane][off + 3],
137 ]);
138 }
139 }
140 m
141}
142
143#[inline(always)]
148fn compress_block<const N: usize>(
149 cv: &mut [[u32; N]; 8],
150 block: &[[u32; N]; 16],
151 counter: u64,
152 block_len: u32,
153 flags: u32,
154) {
155 #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
158 if neon::handles_lanes(N) {
159 neon::compress_block(cv, block, counter, block_len, flags);
160 return;
161 }
162
163 compress_block_portable(cv, block, counter, block_len, flags);
164}
165
166#[inline(always)]
171fn compress_block_portable<const N: usize>(
172 cv: &mut [[u32; N]; 8],
173 block: &[[u32; N]; 16],
174 counter: u64,
175 block_len: u32,
176 flags: u32,
177) {
178 let counter_lo = counter as u32;
180 let counter_hi = (counter >> 32) as u32;
181
182 let mut v: [[u32; N]; 16] = [
184 cv[0],
185 cv[1],
186 cv[2],
187 cv[3],
188 cv[4],
189 cv[5],
190 cv[6],
191 cv[7],
192 [IV[0]; N],
193 [IV[1]; N],
194 [IV[2]; N],
195 [IV[3]; N],
196 [counter_lo; N],
197 [counter_hi; N],
198 [block_len; N],
199 [flags; N],
200 ];
201
202 round::<0, N>(&mut v, block);
205 round::<1, N>(&mut v, block);
206 round::<2, N>(&mut v, block);
207 round::<3, N>(&mut v, block);
208 round::<4, N>(&mut v, block);
209 round::<5, N>(&mut v, block);
210 round::<6, N>(&mut v, block);
211
212 for i in 0..8 {
214 for lane in 0..N {
215 cv[i][lane] = v[i][lane] ^ v[i + 8][lane];
216 }
217 }
218}
219
220#[inline(always)]
222fn broadcast_iv<const N: usize>() -> [[u32; N]; 8] {
223 array::from_fn(|w| [IV[w]; N])
224}
225
226#[inline(always)]
228fn serialize_cv_lane<const N: usize>(cv: &[[u32; N]; 8], lane: usize) -> [u8; OUT_LEN] {
229 let mut digest = [0u8; OUT_LEN];
230 let (chunks, _) = digest.as_chunks_mut::<4>();
231 for (w, chunk) in chunks.iter_mut().enumerate() {
232 chunk.copy_from_slice(&cv[w][lane].to_le_bytes());
233 }
234 digest
235}
236
237#[derive(Clone)]
245pub struct PortableBlake3MultiDigest<const N: usize> {
246 cv: [[u32; N]; 8],
248 block: [[u8; BLOCK_LEN]; N],
250 block_len: usize,
252 blocks_compressed: usize,
254}
255
256impl<const N: usize> Default for PortableBlake3MultiDigest<N> {
257 fn default() -> Self {
258 Self {
260 cv: broadcast_iv(),
261 block: [[0u8; BLOCK_LEN]; N],
262 block_len: 0,
263 blocks_compressed: 0,
264 }
265 }
266}
267
268impl<const N: usize> PortableBlake3MultiDigest<N> {
269 fn compress_full_block(&mut self) {
271 let flags = if self.blocks_compressed == 0 {
273 CHUNK_START
274 } else {
275 0
276 };
277 let m = load_block_words(&self.block);
278 compress_block(&mut self.cv, &m, 0, BLOCK_LEN as u32, flags);
279 self.blocks_compressed += 1;
280 self.block_len = 0;
281 }
282
283 fn write_root(&self, out: &mut [MaybeUninit<Output<blake3::Hasher>>; N]) {
287 let mut cv = self.cv;
288 let mut block = self.block;
289 for lane in 0..N {
291 block[lane][self.block_len..].fill(0);
292 }
293 let start = if self.blocks_compressed == 0 {
295 CHUNK_START
296 } else {
297 0
298 };
299 let m = load_block_words(&block);
300 compress_block(&mut cv, &m, 0, self.block_len as u32, start | CHUNK_END | ROOT);
301
302 for lane in 0..N {
304 out[lane].write(serialize_cv_lane(&cv, lane).into());
305 }
306 }
307}
308
309impl<const N: usize> MultiDigest<N> for PortableBlake3MultiDigest<N> {
310 type Digest = blake3::Hasher;
311
312 fn new() -> Self {
313 Self::default()
314 }
315
316 fn update(&mut self, data: [&[u8]; N]) {
317 let mut consumed = [0usize; N];
319 loop {
320 let remaining = (0..N)
322 .map(|i| data[i].len() - consumed[i])
323 .max()
324 .unwrap_or(0);
325 if remaining == 0 {
326 break;
327 }
328 if self.block_len == BLOCK_LEN {
330 self.compress_full_block();
331 }
332 let take = (BLOCK_LEN - self.block_len).min(remaining);
334 for lane in 0..N {
335 let avail = data[lane].len() - consumed[lane];
336 let n = take.min(avail);
337 self.block[lane][self.block_len..self.block_len + n]
338 .copy_from_slice(&data[lane][consumed[lane]..consumed[lane] + n]);
339 consumed[lane] += n;
340 }
341 self.block_len += take;
342 }
343 }
344
345 fn finalize_into(self, out: &mut [MaybeUninit<Output<Self::Digest>>; N]) {
346 self.write_root(out);
347 }
348
349 fn finalize_into_reset(&mut self, out: &mut [MaybeUninit<Output<Self::Digest>>; N]) {
350 self.write_root(out);
351 self.reset();
352 }
353
354 fn reset(&mut self) {
355 self.cv = broadcast_iv();
358 self.block_len = 0;
359 self.blocks_compressed = 0;
360 }
361
362 fn digest(data: [&[u8]; N], out: &mut [MaybeUninit<Output<Self::Digest>>; N]) {
363 let mut hasher = Self::new();
364 hasher.update(data);
365 hasher.finalize_into(out);
366 }
367}
368
369#[derive(Debug, Clone, Default)]
376pub struct PortableBlake3ParallelDigest<const LANES: usize>;
377
378impl<const LANES: usize> ParallelDigest for PortableBlake3ParallelDigest<LANES> {
379 type Digest = blake3::Hasher;
380
381 fn new() -> Self {
382 Self
383 }
384
385 fn digest<I: IntoIterator<Item: SerializeBytes>>(
386 &self,
387 source: impl IndexedParallelIterator<Item = I>,
388 out: &mut [MaybeUninit<Output<Self::Digest>>],
389 ) {
390 ParallelDigestAdapter::<blake3::Hasher>::new().digest(source, out);
393 }
394
395 fn digest_with_const_len<I: IntoIterator<Item: FixedSizeSerializeBytes>>(
396 &self,
397 n_items_per_input: usize,
398 source: impl IndexedParallelIterator<Item = I>,
399 out: &mut [MaybeUninit<Output<Self::Digest>>],
400 ) {
401 let leaf_len = n_items_per_input * I::Item::BYTE_SIZE;
403
404 if leaf_len <= CHUNK_LEN {
405 ParallelMultidigestImpl::<PortableBlake3MultiDigest<LANES>, LANES>::new()
407 .digest(source, out);
408 } else {
409 ParallelDigestAdapter::<blake3::Hasher>::new().digest(source, out);
411 }
412 }
413}
414
415#[inline]
429fn compress_node_pairs<const N: usize>(
430 inputs: &[Output<blake3::Hasher>],
431 out: &mut [MaybeUninit<Output<blake3::Hasher>>],
432) {
433 let mut blocks = [[0u8; BLOCK_LEN]; N];
435 for (lane, block) in blocks.iter_mut().enumerate().take(out.len()) {
436 block[..OUT_LEN].copy_from_slice(inputs[2 * lane].as_slice());
437 block[OUT_LEN..].copy_from_slice(inputs[2 * lane + 1].as_slice());
438 }
439
440 let m = load_block_words(&blocks);
442 let mut cv = broadcast_iv::<N>();
443 compress_block(&mut cv, &m, 0, BLOCK_LEN as u32, CHUNK_START | CHUNK_END | ROOT);
444
445 for (lane, slot) in out.iter_mut().enumerate() {
446 slot.write(serialize_cv_lane(&cv, lane).into());
447 }
448}
449
450#[derive(Debug, Clone, Default)]
459pub struct PortableBlake3ParallelCompression<const LANES: usize> {
460 compression: Blake3Compression,
462}
463
464impl<const LANES: usize> ParallelPseudoCompression<Output<blake3::Hasher>, 2>
465 for PortableBlake3ParallelCompression<LANES>
466{
467 type Compression = Blake3Compression;
468
469 fn compression(&self) -> &Self::Compression {
470 &self.compression
471 }
472
473 fn parallel_compress(
474 &self,
475 inputs: &[Output<blake3::Hasher>],
476 out: &mut [MaybeUninit<Output<blake3::Hasher>>],
477 ) {
478 assert_eq!(inputs.len(), 2 * out.len(), "Input length must be 2 * output length");
479
480 inputs
483 .par_chunks(2 * LANES)
484 .zip(out.par_chunks_mut(LANES))
485 .for_each(|(in_batch, out_batch)| compress_node_pairs::<LANES>(in_batch, out_batch));
486 }
487}
488
489#[cfg(test)]
490mod tests {
491 use std::iter::repeat_with;
492
493 use binius_hash::CompressionFunction;
494 use binius_utils::rayon::iter::{IntoParallelRefIterator, ParallelIterator};
495 use proptest::prelude::*;
496 use rand::{Rng, SeedableRng, rngs::StdRng};
497
498 use super::*;
499
500 fn check_parallel_compression<const N: usize>(pairs: &[[[u8; OUT_LEN]; 2]]) {
503 let inputs: Vec<Output<blake3::Hasher>> = pairs
505 .iter()
506 .flat_map(|[l, r]| [(*l).into(), (*r).into()])
507 .collect();
508 let mut out = repeat_with(MaybeUninit::<Output<blake3::Hasher>>::uninit)
509 .take(pairs.len())
510 .collect::<Vec<_>>();
511
512 PortableBlake3ParallelCompression::<N>::default().parallel_compress(&inputs, &mut out);
513
514 for (slot, [l, r]) in out.into_iter().zip(pairs) {
516 let expected = Blake3Compression.compress([(*l).into(), (*r).into()]);
517 assert_eq!(unsafe { slot.assume_init() }.as_slice(), expected.as_slice());
518 }
519 }
520
521 #[test]
522 fn test_parallel_compression_boundaries() {
523 let zero = [0u8; OUT_LEN];
525 let ones = [0xffu8; OUT_LEN];
526 check_parallel_compression::<16>(&[[zero, zero], [ones, ones], [zero, ones], [ones, zero]]);
527
528 let mut rng = StdRng::seed_from_u64(7);
530 for count in [0usize, 1, 15, 16, 17, 33] {
531 let pairs: Vec<[[u8; OUT_LEN]; 2]> = (0..count)
532 .map(|_| {
533 let mut pair = [[0u8; OUT_LEN]; 2];
534 rng.fill_bytes(&mut pair[0]);
535 rng.fill_bytes(&mut pair[1]);
536 pair
537 })
538 .collect();
539 check_parallel_compression::<16>(&pairs);
540 }
541 }
542
543 proptest! {
544 #[test]
545 fn parallel_compression_matches_scalar(
546 pairs in prop::collection::vec(
547 (prop::array::uniform32(any::<u8>()), prop::array::uniform32(any::<u8>())),
548 0..40usize,
549 ),
550 ) {
551 let pairs: Vec<[[u8; OUT_LEN]; 2]> = pairs.into_iter().map(|(l, r)| [l, r]).collect();
553 check_parallel_compression::<4>(&pairs);
554 check_parallel_compression::<8>(&pairs);
555 check_parallel_compression::<16>(&pairs);
556 }
557 }
558
559 #[cfg(all(target_arch = "x86_64", target_feature = "avx512f"))]
566 fn check_avx512_transpose<const N: usize>(rng: &mut StdRng) {
567 use rand::RngExt;
568
569 let block: [[u8; BLOCK_LEN]; N] = array::from_fn(|_| array::from_fn(|_| rng.random()));
572
573 let want = load_block_words_portable(&block);
575
576 let got = super::avx512::load_block_words(&block);
578
579 assert_eq!(got, want, "vector transpose diverged from the byte-wise loader at {N} lanes");
581 }
582
583 #[cfg(all(target_arch = "x86_64", target_feature = "avx512f"))]
584 #[test]
585 fn test_avx512_transpose_matches_portable() {
586 let mut rng = StdRng::seed_from_u64(13);
587
588 for _ in 0..64 {
590 check_avx512_transpose::<16>(&mut rng);
591 }
592 }
593
594 #[cfg(all(target_arch = "x86_64", target_feature = "avx512f"))]
595 #[test]
596 fn test_avx512_transpose_places_every_word() {
597 let block: [[u8; BLOCK_LEN]; 16] = array::from_fn(|lane| {
600 array::from_fn(|byte| {
601 let word = byte / 4;
602 match byte % 4 {
604 0 => (lane * 16 + word) as u8,
605 _ => 0,
606 }
607 })
608 });
609
610 let m = super::avx512::load_block_words(&block);
611
612 for lane in 0..16 {
614 for word in 0..16 {
615 assert_eq!(
616 m[word][lane],
617 (lane * 16 + word) as u32,
618 "word {word} of lane {lane} landed wrongly"
619 );
620 }
621 }
622 }
623
624 #[cfg(all(target_arch = "x86_64", target_feature = "avx512f"))]
625 proptest! {
626 #[test]
627 fn avx512_transpose_matches_portable_proptest(seed in any::<u64>()) {
628 let mut rng = StdRng::seed_from_u64(seed);
630 check_avx512_transpose::<16>(&mut rng);
631 }
632 }
633
634 #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
643 fn check_neon_core<const N: usize>(rng: &mut StdRng, counter: u64, block_len: u32, flags: u32) {
644 use rand::RngExt;
645
646 let cv_in: [[u32; N]; 8] = array::from_fn(|_| array::from_fn(|_| rng.random()));
649 let block: [[u32; N]; 16] = array::from_fn(|_| array::from_fn(|_| rng.random()));
650
651 let mut want = cv_in;
653 compress_block_portable(&mut want, &block, counter, block_len, flags);
654
655 let mut got = cv_in;
657 super::neon::compress_block(&mut got, &block, counter, block_len, flags);
658
659 assert_eq!(got, want, "vector kernel diverged from the lane loops at {N} lanes");
661 }
662
663 #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
665 fn check_neon_transpose<const N: usize>(rng: &mut StdRng) {
666 let mut blocks = [[0u8; BLOCK_LEN]; N];
668 for block in blocks.iter_mut() {
669 rng.fill_bytes(block);
670 }
671
672 assert_eq!(
674 super::neon::load_block_words(&blocks),
675 load_block_words_portable(&blocks),
676 "the shuffle network diverged from the byte-wise loader at {N} lanes"
677 );
678 }
679
680 #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
681 #[test]
682 fn test_neon_transpose_matches_portable() {
683 let mut blocks = [[0u8; BLOCK_LEN]; 16];
694 for (lane, block) in blocks.iter_mut().enumerate() {
695 let (words, _) = block.as_chunks_mut::<4>();
696 for (w, word) in words.iter_mut().enumerate() {
697 word.copy_from_slice(&((lane * 16 + w) as u32).to_le_bytes());
698 }
699 }
700
701 let m = super::neon::load_block_words(&blocks);
703 for (w, row) in m.iter().enumerate() {
704 for (lane, got) in row.iter().enumerate() {
705 assert_eq!(*got, (lane * 16 + w) as u32, "row {w}, lane {lane}");
706 }
707 }
708
709 let mut rng = StdRng::seed_from_u64(23);
711 check_neon_transpose::<4>(&mut rng);
712 check_neon_transpose::<8>(&mut rng);
713 check_neon_transpose::<12>(&mut rng);
714 check_neon_transpose::<16>(&mut rng);
715 }
716
717 #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
718 proptest! {
719 #[test]
720 fn neon_transpose_matches_portable_proptest(seed in any::<u64>()) {
721 let mut rng = StdRng::seed_from_u64(seed);
724 check_neon_transpose::<4>(&mut rng);
725 check_neon_transpose::<8>(&mut rng);
726 check_neon_transpose::<12>(&mut rng);
727 check_neon_transpose::<16>(&mut rng);
728 }
729 }
730
731 #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
732 #[test]
733 fn test_neon_core_matches_portable() {
734 let mut rng = StdRng::seed_from_u64(11);
735
736 let cases = [
741 (0u64, 64u32, 0u32),
743 (0, 64, CHUNK_START),
745 (0, 64, CHUNK_END | ROOT),
747 (0, 64, CHUNK_START | CHUNK_END | ROOT),
749 (0, 1, CHUNK_START | CHUNK_END | ROOT),
751 (0, 0, CHUNK_START | CHUNK_END | ROOT),
753 (u64::MAX, 64, CHUNK_END),
755 (1 << 32, 63, CHUNK_START),
757 ];
758
759 for (counter, block_len, flags) in cases {
761 check_neon_core::<4>(&mut rng, counter, block_len, flags);
762 check_neon_core::<8>(&mut rng, counter, block_len, flags);
763 check_neon_core::<12>(&mut rng, counter, block_len, flags);
764 check_neon_core::<16>(&mut rng, counter, block_len, flags);
765 }
766 }
767
768 #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
769 proptest! {
770 #[test]
771 fn neon_core_matches_portable_proptest(
772 seed in any::<u64>(),
773 counter in any::<u64>(),
774 block_len in 0..=64u32,
776 flags in any::<u8>(),
778 ) {
779 let mut rng = StdRng::seed_from_u64(seed);
781 check_neon_core::<4>(&mut rng, counter, block_len, flags as u32);
782 check_neon_core::<8>(&mut rng, counter, block_len, flags as u32);
783 check_neon_core::<12>(&mut rng, counter, block_len, flags as u32);
784 check_neon_core::<16>(&mut rng, counter, block_len, flags as u32);
785 }
786 }
787
788 fn check_portable_batch<const N: usize>(rng: &mut StdRng, len: usize) {
791 let messages: [Vec<u8>; N] = array::from_fn(|_| {
793 let mut m = vec![0u8; len];
794 rng.fill_bytes(&mut m);
795 m
796 });
797 let refs: [&[u8]; N] = array::from_fn(|i| messages[i].as_slice());
798 let mut out = array::from_fn::<_, N, _>(|_| MaybeUninit::uninit());
799 PortableBlake3MultiDigest::<N>::digest(refs, &mut out);
800
801 for (o, message) in out.iter().zip(messages.iter()) {
803 let got = unsafe { o.assume_init_ref() };
804 assert_eq!(got.as_slice(), blake3::hash(message).as_bytes(), "len = {len}, N = {N}");
805 }
806 }
807
808 #[test]
809 fn test_portable_lengths_match_reference() {
810 let mut rng = StdRng::seed_from_u64(0);
811
812 for len in [0, 1, 31, 63, 64, 65, 100, 127, 128, 1000, 1024] {
820 check_portable_batch::<4>(&mut rng, len);
821 check_portable_batch::<8>(&mut rng, len);
822 check_portable_batch::<16>(&mut rng, len);
823 }
824 }
825
826 #[test]
827 fn test_portable_chained_update() {
828 let mut rng = StdRng::seed_from_u64(2);
829 let messages: [Vec<u8>; 4] = array::from_fn(|_| {
831 let mut m = vec![0u8; 200];
832 rng.fill_bytes(&mut m);
833 m
834 });
835
836 let mut hasher = PortableBlake3MultiDigest::<4>::new();
839 hasher.update(array::from_fn(|i| &messages[i][..50]));
840 hasher.update(array::from_fn(|i| &messages[i][50..]));
841 let mut out = array::from_fn::<_, 4, _>(|_| MaybeUninit::uninit());
842 hasher.finalize_into(&mut out);
843
844 for (o, message) in out.iter().zip(messages.iter()) {
845 assert_eq!(unsafe { o.assume_init_ref() }.as_slice(), blake3::hash(message).as_bytes());
846 }
847 }
848
849 #[test]
850 fn test_portable_routing_matches_reference() {
851 let mut rng = StdRng::seed_from_u64(3);
852 let mut check = |leaf_len: usize| {
854 let leaves: Vec<Vec<u8>> = (0..50)
855 .map(|_| {
856 let mut m = vec![0u8; leaf_len];
857 rng.fill_bytes(&mut m);
858 m
859 })
860 .collect();
861 let digest = PortableBlake3ParallelDigest::<8>::new();
862 let mut results = repeat_with(MaybeUninit::<Output<blake3::Hasher>>::uninit)
863 .take(50)
864 .collect::<Vec<_>>();
865 digest.digest_with_const_len(
866 leaf_len,
867 leaves.par_iter().map(|leaf| leaf.iter().copied()),
868 &mut results,
869 );
870 for (result, leaf) in results.into_iter().zip(&leaves) {
871 let got = unsafe { result.assume_init() };
872 assert_eq!(got.as_slice(), blake3::hash(leaf).as_bytes(), "leaf_len {leaf_len}");
873 }
874 };
875
876 for leaf_len in [0, 1, 63, 64, 65, 100, 1000, 1024, 1025, 2048] {
882 check(leaf_len);
883 }
884 }
885}