From 3375dcfc47224d5d284584443656eef9daaea1e9 Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Thu, 13 Nov 2025 20:15:16 +0530 Subject: [PATCH 01/18] Bump `sha3` to latest git commit Signed-off-by: Anjan Roy --- sha3 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sha3 b/sha3 index 5b36415..5c82236 160000 --- a/sha3 +++ b/sha3 @@ -1 +1 @@ -Subproject commit 5b3641593ec4fbd18d1ce79157f7a0d230580c14 +Subproject commit 5c82236beb7d81e0e7fcc0b93c5fe30f77414da6 From 5404d1704357ba33d8eb322dbd9996df5794e15d Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Thu, 13 Nov 2025 21:43:55 +0530 Subject: [PATCH 02/18] Add support for using TurboSHAKE256 XOF (the default choice from now on) in very non-intrusive manner (thanks to Google Gemini for brainstorming ideas) Signed-off-by: Anjan Roy --- include/randomshake/randomshake.hpp | 88 ++++++++++++++++++++--------- 1 file changed, 62 insertions(+), 26 deletions(-) diff --git a/include/randomshake/randomshake.hpp b/include/randomshake/randomshake.hpp index 4f67b42..b378b8d 100644 --- a/include/randomshake/randomshake.hpp +++ b/include/randomshake/randomshake.hpp @@ -1,6 +1,7 @@ #pragma once #include "sha3/internals/force_inline.hpp" #include "sha3/shake256.hpp" +#include "sha3/turboshake256.hpp" #include #include #include @@ -27,15 +28,8 @@ check_endianness() } /** - After squeezing every these many bytes from underlying SHAKE256 Xof, we zeroize first `n` bytes of - Keccak permutation state and re-apply permutation. - */ -static constexpr size_t RANDOMSHAKE_RATCHET_PERIOD_BYTE_LEN = shake256::RATE; - -/** - Ensures that value is materialized (and not optimized away), but doesn't clobber memory, like google-benchmark does. - - Taken from https://theunixzoo.co.uk/blog/2021-10-14-preventing-optimisations.html. + * Ensures that value is materialized (and not optimized away), but doesn't clobber memory, like google-benchmark does. + * Taken from https://theunixzoo.co.uk/blog/2021-10-14-preventing-optimisations.html. */ template forceinline void @@ -44,27 +38,64 @@ DoNotOptimize(Tp& value) asm volatile("" : "+r,m"(value) : :); } -/** - RandomShake - SHAKE256 -backed *C*ryptographically *S*ecure *P*seudo *R*andom *N*umber *G*enerator. +// Enum listing supported eXtendable Output Functions (XOFs), which can be used for producing pseudo-random byte stream. +enum class xof_kind_t : uint8_t +{ + SHAKE256, // Based on 24-rounds keccak permutation + TURBOSHAKE256, // Based on 12-rounds keccak permutation. Almost doubles the throughput. +}; + +// A helper trait, for selecting which XOF to use in RandomSHAKE CSPRNG. +template +struct xof_selector_t +{}; - Allowing both (a) `std::random_device` sampled seed, (b) User provided seed -based initialization of CSPRNG. - After every `RANDOMSHAKE_RATCHET_PERIOD_BYTE_LEN` -many bytes are squeezed from SHAKE256 Xof instance, we perform - ratcheting i.e. zeroing out of first `ratchet_byte_len` -many bytes of Keccak permutation state and re-applying - permutation. +// Specialization for SHAKE256 XOF. +template<> +struct xof_selector_t +{ + using type = shake256::shake256_t; + static constexpr size_t rate = shake256::RATE; + + // Everytime these many bytes are squeezed from underlying sponge, we zeroize first `n` bytes of Keccak permutation + // state and re-apply 24-rounds permutation. + static constexpr size_t ratchet_period_byte_len = shake256::RATE; +}; + +// Specialization for TurboSHAKE256 XOF. +template<> +struct xof_selector_t +{ + using type = turboshake256::turboshake256_t; + static constexpr size_t rate = turboshake256::RATE; + + // Everytime these many bytes are squeezed from underlying sponge, we zeroize first `n` bytes of Keccak permutation + // state and re-apply 12-rounds permutation. + static constexpr size_t ratchet_period_byte_len = turboshake256::RATE; +}; - Design of this CSPRNG collects inspiration from https://seth.rocks/articles/cpprandom. +/** + * RandomSHAKE - TurboSHAKE256 (by default) or SHAKE256-backed Cryptographically Secure Pseudo-Random Number + * Generator (CSPRNG). + * + * Allowing both (a) `std::random_device` sampled seed, (b) User provided seed-based initialization of CSPRNG. + * After every `ratchet_period_byte_len`-many bytes are squeezed from the underlying XOF instance, we perform + * ratcheting i.e. zeroing out of first `ratchet_byte_len` -many bytes of Keccak permutation state and re-applying + * permutation. + * + * Design of this CSPRNG collects inspiration from https://seth.rocks/articles/cpprandom. */ -template +template requires(check_bit_security_level(bit_security_level) && std::is_unsigned_v && check_endianness()) struct randomshake_t { private: - shake256::shake256_t state{}; - std::array buffer{}; - size_t buffer_offset = 0; + xof_selector_t::type state{}; + std::array::ratchet_period_byte_len> buffer{}; + size_t buffer_offset = 0u; // These many bytes are zeroed from the beginning of the Keccak permutation state during ratchet operation. - const size_t ratchet_byte_len = std::min(shake256::RATE, bit_security_level) / std::numeric_limits::digits; + static constexpr size_t ratchet_byte_len = std::min(xof_selector_t::rate, bit_security_level) / 8u; public: using result_type = UIntType; @@ -73,9 +104,11 @@ struct randomshake_t static constexpr auto min = std::numeric_limits::min; static constexpr auto max = std::numeric_limits::max; - // Samples `seed_byte_len` -many bytes from std::random_device and initializes SHAKE256 Xof - making it ready for use. - // Before you use this constructor, I strongly advise you to read - // https://en.cppreference.com/w/cpp/numeric/random/random_device. + /** + * Samples `seed_byte_len` -many bytes from std::random_device and initializes chosen XOF - making it ready for use. + * Before you use this constructor, I strongly advise you to read + * https://en.cppreference.com/w/cpp/numeric/random/random_device. + */ forceinline randomshake_t() { std::array seed{}; @@ -105,7 +138,10 @@ struct randomshake_t state.squeeze(buffer); } - // Expects user to supply us with `seed_byte_len` -bytes seed, which is used for initializing underlying SHAKE256 Xof. + /** + * Explicit constructor. Expects user to supply us with `seed_byte_len` -bytes seed, which is used for initializing + * the underlying XOF. It is user's responsibility to ensure that the supplied seed has sufficient entropy. + */ forceinline explicit constexpr randomshake_t(std::span seed) { state.absorb(seed); @@ -139,7 +175,7 @@ struct randomshake_t const size_t readble_num_bytes = buffer.size() - buffer_offset; static_assert( - RANDOMSHAKE_RATCHET_PERIOD_BYTE_LEN % required_num_bytes == 0, + xof_selector_t::ratchet_period_byte_len % required_num_bytes == 0, "Buffer size nust be a multiple of `required_num_bytes`, for following ratchet->squeeze to work correctly !"); // When the buffer is exhausted, it's time to ratchet and fill the buffer with new ready-to-use random bytes. From 4b1fba980cad8c12d396c200a6a714f5a41535f3 Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Sat, 15 Nov 2025 19:24:26 +0530 Subject: [PATCH 03/18] Get rid of bit security level parameter in RandomSHAKE CSPRNG - much simpler API Thanks to Joan Daemen for the suggestion. Signed-off-by: Anjan Roy --- include/randomshake/randomshake.hpp | 97 ++++++++++++++--------------- 1 file changed, 46 insertions(+), 51 deletions(-) diff --git a/include/randomshake/randomshake.hpp b/include/randomshake/randomshake.hpp index b378b8d..9b28e80 100644 --- a/include/randomshake/randomshake.hpp +++ b/include/randomshake/randomshake.hpp @@ -13,13 +13,6 @@ namespace randomshake { -// Compile-time check to ensure that bit-security level is valid. -consteval auto -check_bit_security_level(size_t bit_security_level) -{ - return (bit_security_level == 128u) || (bit_security_level == 192u) || (bit_security_level == 256u); -} - // Compile-time check to ensure that endianness is little, as correctness of program depends on it. consteval auto check_endianness() @@ -41,8 +34,8 @@ DoNotOptimize(Tp& value) // Enum listing supported eXtendable Output Functions (XOFs), which can be used for producing pseudo-random byte stream. enum class xof_kind_t : uint8_t { - SHAKE256, // Based on 24-rounds keccak permutation - TURBOSHAKE256, // Based on 12-rounds keccak permutation. Almost doubles the throughput. + SHAKE256, // Based on 24-rounds keccak permutation. + TURBOSHAKE256, // Based on 12-rounds keccak permutation. Almost doubles the throughput. The default choice. }; // A helper trait, for selecting which XOF to use in RandomSHAKE CSPRNG. @@ -55,11 +48,23 @@ template<> struct xof_selector_t { using type = shake256::shake256_t; + + // Bit width of the rate portion of keccak sponge for SHAKE256 XOF. static constexpr size_t rate = shake256::RATE; - // Everytime these many bytes are squeezed from underlying sponge, we zeroize first `n` bytes of Keccak permutation - // state and re-apply 24-rounds permutation. + // Required seed byte length to initialize the SHAKE256 XOF. + static constexpr size_t seed_byte_len = rate / std::numeric_limits::digits; + + /** + * Everytime these many bytes are squeezed from the underlying keccak sponge, + * we zeroize first `ratchet_byte_len`-bytes of Keccak permutation state and re-apply 24-rounds permutation. + * + * Ratchet period gets computed as `8 x RATE-of-the-underlying-keccak-sponge` bits. + */ static constexpr size_t ratchet_period_byte_len = shake256::RATE; + + // First these many bytes of keccak permutation are zeroized during ratcheting. + static constexpr size_t ratchet_byte_len = shake256::TARGET_BIT_SECURITY_LEVEL / std::numeric_limits::digits; }; // Specialization for TurboSHAKE256 XOF. @@ -67,26 +72,37 @@ template<> struct xof_selector_t { using type = turboshake256::turboshake256_t; + + // Bit width of the rate portion of keccak sponge for TurboSHAKE256 XOF. static constexpr size_t rate = turboshake256::RATE; - // Everytime these many bytes are squeezed from underlying sponge, we zeroize first `n` bytes of Keccak permutation - // state and re-apply 12-rounds permutation. + // Required seed byte length to initialize the TurboSHAKE256 XOF. + static constexpr size_t seed_byte_len = rate / std::numeric_limits::digits; + + /** + * Everytime these many bytes are squeezed from the underlying keccak sponge, + * we zeroize first `ratchet_byte_len`-bytes of Keccak permutation state and re-apply 12-rounds permutation. + * + * Ratchet period gets computed as `8 x RATE-of-the-underlying-keccak-sponge` bits. + */ static constexpr size_t ratchet_period_byte_len = turboshake256::RATE; + + // First these many bytes of keccak permutation state are zeroized during ratcheting. + static constexpr size_t ratchet_byte_len = turboshake256::TARGET_BIT_SECURITY_LEVEL / std::numeric_limits::digits; }; /** - * RandomSHAKE - TurboSHAKE256 (by default) or SHAKE256-backed Cryptographically Secure Pseudo-Random Number - * Generator (CSPRNG). + * RandomSHAKE - TurboSHAKE256 (by default) or SHAKE256-backed Cryptographically Secure Pseudo-Random Number Generator (CSPRNG). * * Allowing both (a) `std::random_device` sampled seed, (b) User provided seed-based initialization of CSPRNG. * After every `ratchet_period_byte_len`-many bytes are squeezed from the underlying XOF instance, we perform * ratcheting i.e. zeroing out of first `ratchet_byte_len` -many bytes of Keccak permutation state and re-applying * permutation. * - * Design of this CSPRNG collects inspiration from https://seth.rocks/articles/cpprandom. + * Design of RandomSHAKE CSPRNG API collects inspiration from https://seth.rocks/articles/cpprandom. */ -template - requires(check_bit_security_level(bit_security_level) && std::is_unsigned_v && check_endianness()) +template + requires(std::is_unsigned_v && check_endianness()) struct randomshake_t { private: @@ -94,20 +110,16 @@ struct randomshake_t std::array::ratchet_period_byte_len> buffer{}; size_t buffer_offset = 0u; - // These many bytes are zeroed from the beginning of the Keccak permutation state during ratchet operation. - static constexpr size_t ratchet_byte_len = std::min(xof_selector_t::rate, bit_security_level) / 8u; - public: using result_type = UIntType; - static constexpr auto seed_byte_len = bit_security_level / std::numeric_limits::digits; + static constexpr auto seed_byte_len = xof_selector_t::seed_byte_len; static constexpr auto min = std::numeric_limits::min; static constexpr auto max = std::numeric_limits::max; /** - * Samples `seed_byte_len` -many bytes from std::random_device and initializes chosen XOF - making it ready for use. - * Before you use this constructor, I strongly advise you to read - * https://en.cppreference.com/w/cpp/numeric/random/random_device. + * Samples `seed_byte_len` -many bytes from std::random_device and initializes the chosen XOF - making it ready for use. + * Before you use this constructor, I strongly advise you to read https://en.cppreference.com/w/cpp/numeric/random/random_device. */ forceinline randomshake_t() { @@ -126,13 +138,13 @@ struct randomshake_t while (seed_offset < seed_span.size()) { const auto v = rd(); - static_assert(seed_byte_len % step_by == 0, - "Seed byte length must be a multiple of `step_by`, for following memcpy to work correctly !"); + static_assert(seed_byte_len % step_by == 0, "Seed byte length must be a multiple of `step_by`, for following memcpy to work correctly !"); std::memcpy(seed_span.subspan(seed_offset, step_by).data(), reinterpret_cast(&v), step_by); seed_offset += step_by; } + state.reset(); state.absorb(seed_span); state.finalize(); state.squeeze(buffer); @@ -140,10 +152,11 @@ struct randomshake_t /** * Explicit constructor. Expects user to supply us with `seed_byte_len` -bytes seed, which is used for initializing - * the underlying XOF. It is user's responsibility to ensure that the supplied seed has sufficient entropy. + * the chosen XOF. It is user's responsibility to ensure that the supplied seed has sufficient entropy. */ forceinline explicit constexpr randomshake_t(std::span seed) { + state.reset(); state.absorb(seed); state.finalize(); state.squeeze(buffer); @@ -168,31 +181,13 @@ struct randomshake_t } // Squeezes a random value of type `result_type`. - [[nodiscard("Internal state of CSPRNG has changed, you should consume this value")]] forceinline result_type - operator()() + [[nodiscard("Internal state of CSPRNG has changed, you should consume this value")]] forceinline result_type operator()() { - constexpr size_t required_num_bytes = sizeof(result_type); - const size_t readble_num_bytes = buffer.size() - buffer_offset; - - static_assert( - xof_selector_t::ratchet_period_byte_len % required_num_bytes == 0, - "Buffer size nust be a multiple of `required_num_bytes`, for following ratchet->squeeze to work correctly !"); - - // When the buffer is exhausted, it's time to ratchet and fill the buffer with new ready-to-use random bytes. - if (readble_num_bytes == 0) { - state.ratchet(ratchet_byte_len); - state.squeeze(buffer); - buffer_offset = 0; - } - result_type result{}; + auto res_ptr = reinterpret_cast(&result); + auto res_span = std::span(res_ptr, sizeof(result)); - auto src_ptr = reinterpret_cast(buffer.data()) + buffer_offset; - auto dst_ptr = reinterpret_cast(&result); - - std::memcpy(dst_ptr, src_ptr, required_num_bytes); - buffer_offset += required_num_bytes; - + this->generate(res_span); return result; } @@ -215,7 +210,7 @@ struct randomshake_t out_offset += copyable_num_bytes; if (buffer_offset == buffer.size()) { - state.ratchet(ratchet_byte_len); + state.ratchet(xof_selector_t::ratchet_byte_len); state.squeeze(buffer); buffer_offset = 0; } From 9c3326f173f4fe87554aebbce43fad02a5e87078 Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Sat, 15 Nov 2025 19:26:05 +0530 Subject: [PATCH 04/18] Use fancy C++ features to get data type of variable (reference type) Signed-off-by: Anjan Roy --- tests/test_utils.hpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/test_utils.hpp b/tests/test_utils.hpp index ce10d81..d42b887 100644 --- a/tests/test_utils.hpp +++ b/tests/test_utils.hpp @@ -2,6 +2,7 @@ #include #include #include +#include namespace randomshake_test_utils { @@ -12,7 +13,7 @@ namespace randomshake_test_utils { static inline constexpr void do_bitflip(uint8_t& val, const size_t bit_idx) { - constexpr auto T_bw = std::numeric_limits::digits; + constexpr auto T_bw = std::numeric_limits>::digits; if (bit_idx >= T_bw) { return; } From 2bada293586c6ec34777c040b7e71ccb0e243507 Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Sat, 15 Nov 2025 19:28:13 +0530 Subject: [PATCH 05/18] Update tests to conform to new RandomSHAKE API without any bit-security-level parameter Signed-off-by: Anjan Roy --- tests/test_deterministic_csprng.cpp | 139 +++++----------------------- 1 file changed, 25 insertions(+), 114 deletions(-) diff --git a/tests/test_deterministic_csprng.cpp b/tests/test_deterministic_csprng.cpp index 28c5b9e..0450742 100644 --- a/tests/test_deterministic_csprng.cpp +++ b/tests/test_deterministic_csprng.cpp @@ -9,15 +9,13 @@ static constexpr size_t GENERATED_RANDOM_BYTE_LEN = 1'024 * 1'024; // = 1MB -template -static void -expect_same_output_for_deterministic_csprng_using_same_seed() +TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_Produces_Eq_Output) { - std::array::seed_byte_len> seed{}; + std::array::seed_byte_len> seed{}; seed.fill(0xde); auto rand_gen = [&]() { - randomshake::randomshake_t csprng(seed); + randomshake::randomshake_t<> csprng(seed); return csprng(); }; @@ -30,30 +28,13 @@ expect_same_output_for_deterministic_csprng_using_same_seed() EXPECT_EQ(rand_bytes_a, rand_bytes_b); } -TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_Produces_Eq_Output_For_128b_Security) +TEST(RandomShake, Deterministic_CSPRNG_Using_Diff_Seed_Produces_Ne_Output) { - expect_same_output_for_deterministic_csprng_using_same_seed<128>(); -} - -TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_Produces_Eq_Output_For_192b_Security) -{ - expect_same_output_for_deterministic_csprng_using_same_seed<192>(); -} - -TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_Produces_Eq_Output_For_256b_Security) -{ - expect_same_output_for_deterministic_csprng_using_same_seed<256>(); -} - -template -static void -expect_diff_output_for_deterministic_csprng_using_diff_seed() -{ - std::array::seed_byte_len> seed{}; + std::array::seed_byte_len> seed{}; seed.fill(0xde); auto rand_gen = [&]() { - randomshake::randomshake_t csprng(seed); + randomshake::randomshake_t<> csprng(seed); return csprng(); }; @@ -68,32 +49,15 @@ expect_diff_output_for_deterministic_csprng_using_diff_seed() EXPECT_NE(rand_bytes_a, rand_bytes_b); } -TEST(RandomShake, Deterministic_CSPRNG_Using_Diff_Seed_Produces_Ne_Output_For_128b_Security) -{ - expect_diff_output_for_deterministic_csprng_using_diff_seed<128>(); -} - -TEST(RandomShake, Deterministic_CSPRNG_Using_Diff_Seed_Produces_Ne_Output_For_192b_Security) +TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Result_Type_Produces_Same_Output) { - expect_diff_output_for_deterministic_csprng_using_diff_seed<192>(); -} - -TEST(RandomShake, Deterministic_CSPRNG_Using_Diff_Seed_Produces_Ne_Output_For_256b_Security) -{ - expect_diff_output_for_deterministic_csprng_using_diff_seed<256>(); -} - -template -static void -expect_same_output_for_deterministic_csprng_using_same_seed_but_diff_result_type() -{ - std::array::seed_byte_len> seed{}; + std::array::seed_byte_len> seed{}; seed.fill(0xde); - randomshake::randomshake_t csprng_u8(seed); - randomshake::randomshake_t csprng_u16(seed); - randomshake::randomshake_t csprng_u32(seed); - randomshake::randomshake_t csprng_u64(seed); + randomshake::randomshake_t csprng_u8(seed); + randomshake::randomshake_t csprng_u16(seed); + randomshake::randomshake_t csprng_u32(seed); + randomshake::randomshake_t csprng_u64(seed); constexpr size_t num_rand_u8_to_gen = GENERATED_RANDOM_BYTE_LEN; constexpr size_t num_rand_u16_to_gen = num_rand_u8_to_gen / 2; @@ -111,42 +75,22 @@ expect_same_output_for_deterministic_csprng_using_same_seed_but_diff_result_type std::ranges::generate(generated_rand_u64, [&]() { return csprng_u64(); }); std::span generated_rand_u8_span(generated_rand_u8); - std::span generated_rand_u16_span(reinterpret_cast(generated_rand_u16.data()), - GENERATED_RANDOM_BYTE_LEN); - std::span generated_rand_u32_span(reinterpret_cast(generated_rand_u32.data()), - GENERATED_RANDOM_BYTE_LEN); - std::span generated_rand_u64_span(reinterpret_cast(generated_rand_u64.data()), - GENERATED_RANDOM_BYTE_LEN); + std::span generated_rand_u16_span(reinterpret_cast(generated_rand_u16.data()), GENERATED_RANDOM_BYTE_LEN); + std::span generated_rand_u32_span(reinterpret_cast(generated_rand_u32.data()), GENERATED_RANDOM_BYTE_LEN); + std::span generated_rand_u64_span(reinterpret_cast(generated_rand_u64.data()), GENERATED_RANDOM_BYTE_LEN); EXPECT_TRUE(std::ranges::equal(generated_rand_u8_span, generated_rand_u16_span)); EXPECT_TRUE(std::ranges::equal(generated_rand_u16_span, generated_rand_u32_span)); EXPECT_TRUE(std::ranges::equal(generated_rand_u32_span, generated_rand_u64_span)); } -TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Result_Type_Produces_Same_Output_For_128b_Security) +TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Public_API) { - expect_same_output_for_deterministic_csprng_using_same_seed_but_diff_result_type<128>(); -} - -TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Result_Type_Produces_Same_Output_For_192b_Security) -{ - expect_same_output_for_deterministic_csprng_using_same_seed_but_diff_result_type<192>(); -} - -TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Result_Type_Produces_Same_Output_For_256b_Security) -{ - expect_same_output_for_deterministic_csprng_using_same_seed_but_diff_result_type<256>(); -} - -template -static void -expect_same_output_for_deterministic_csprng_using_different_public_api() -{ - std::array::seed_byte_len> seed{}; + std::array::seed_byte_len> seed{}; seed.fill(0xde); - randomshake::randomshake_t csprng_u8{ seed }; - randomshake::randomshake_t csprng_bytes{ seed }; + randomshake::randomshake_t<> csprng_u8{ seed }; + randomshake::randomshake_t<> csprng_bytes{ seed }; std::vector generated_rand_u8(GENERATED_RANDOM_BYTE_LEN, 0x00); std::vector generated_byte_seq(GENERATED_RANDOM_BYTE_LEN, 0xff); @@ -157,30 +101,13 @@ expect_same_output_for_deterministic_csprng_using_different_public_api() EXPECT_EQ(generated_rand_u8, generated_byte_seq); } -TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Public_API_For_128b_Security) -{ - expect_same_output_for_deterministic_csprng_using_different_public_api<128>(); -} - -TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Public_API_For_192b_Security) -{ - expect_same_output_for_deterministic_csprng_using_different_public_api<192>(); -} - -TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Public_API_For_256b_Security) -{ - expect_same_output_for_deterministic_csprng_using_different_public_api<256>(); -} - -template -static void -expect_same_output_for_deterministic_csprng_with_oneshot_vs_multishot_squeezing() +TEST(RandomShake, Deterministic_CSPRNG_Oneshot_vs_Multishot_Squeezing) { - std::array::seed_byte_len> seed{}; + std::array::seed_byte_len> seed{}; seed.fill(0xde); - randomshake::randomshake_t csprng_oneshot{ seed }; - randomshake::randomshake_t csprng_multishot{ seed }; + randomshake::randomshake_t<> csprng_oneshot{ seed }; + randomshake::randomshake_t<> csprng_multishot{ seed }; std::vector generated_bytes_oneshot(GENERATED_RANDOM_BYTE_LEN, 0x00); std::vector generated_bytes_multishot(GENERATED_RANDOM_BYTE_LEN, 0xff); @@ -200,9 +127,8 @@ expect_same_output_for_deterministic_csprng_with_oneshot_vs_multishot_squeezing( csprng_multishot.generate(generated_bytes_multishot_span.subspan(out_offset, 1)); out_offset++; - const auto next_squeeze_byte_len = - std::min(generated_bytes_multishot_span[out_offset], // Value held by last byte squeezed - out_byte_len - out_offset); // How many bytes are yet to be squeezed + const auto next_squeeze_byte_len = std::min(generated_bytes_multishot_span[out_offset], // Value held by last byte squeezed + out_byte_len - out_offset); // How many bytes are yet to be squeezed csprng_multishot.generate(generated_bytes_multishot_span.subspan(out_offset, next_squeeze_byte_len)); out_offset += next_squeeze_byte_len; @@ -211,18 +137,3 @@ expect_same_output_for_deterministic_csprng_with_oneshot_vs_multishot_squeezing( EXPECT_EQ(generated_bytes_oneshot, generated_bytes_multishot); } - -TEST(RandomShake, Deterministic_CSPRNG_Oneshot_vs_Multishot_Squeezing_for_128b_Security) -{ - expect_same_output_for_deterministic_csprng_with_oneshot_vs_multishot_squeezing<128>(); -} - -TEST(RandomShake, Deterministic_CSPRNG_Oneshot_vs_Multishot_Squeezing_for_192b_Security) -{ - expect_same_output_for_deterministic_csprng_with_oneshot_vs_multishot_squeezing<192>(); -} - -TEST(RandomShake, Deterministic_CSPRNG_Oneshot_vs_Multishot_Squeezing_for_256b_Security) -{ - expect_same_output_for_deterministic_csprng_with_oneshot_vs_multishot_squeezing<256>(); -} From 993b312c4b0def570179ad1f32fc7db1dfb26df3 Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Sat, 15 Nov 2025 19:35:01 +0530 Subject: [PATCH 06/18] Fix issue in same seed vs. diff seed test in case of deterministic CSPRNG Signed-off-by: Anjan Roy --- tests/test_deterministic_csprng.cpp | 25 +++++++++++-------------- 1 file changed, 11 insertions(+), 14 deletions(-) diff --git a/tests/test_deterministic_csprng.cpp b/tests/test_deterministic_csprng.cpp index 0450742..148b310 100644 --- a/tests/test_deterministic_csprng.cpp +++ b/tests/test_deterministic_csprng.cpp @@ -14,16 +14,14 @@ TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_Produces_Eq_Output) std::array::seed_byte_len> seed{}; seed.fill(0xde); - auto rand_gen = [&]() { - randomshake::randomshake_t<> csprng(seed); - return csprng(); - }; - std::vector rand_bytes_a(GENERATED_RANDOM_BYTE_LEN, 0x00); std::vector rand_bytes_b(GENERATED_RANDOM_BYTE_LEN, 0xff); - std::ranges::generate(rand_bytes_a, rand_gen); - std::ranges::generate(rand_bytes_b, rand_gen); + randomshake::randomshake_t<> csprng_a(seed); + std::ranges::generate(rand_bytes_a, [&]() { return csprng_a(); }); + + randomshake::randomshake_t<> csprng_b(seed); + std::ranges::generate(rand_bytes_b, [&]() { return csprng_b(); }); EXPECT_EQ(rand_bytes_a, rand_bytes_b); } @@ -33,18 +31,17 @@ TEST(RandomShake, Deterministic_CSPRNG_Using_Diff_Seed_Produces_Ne_Output) std::array::seed_byte_len> seed{}; seed.fill(0xde); - auto rand_gen = [&]() { - randomshake::randomshake_t<> csprng(seed); - return csprng(); - }; - std::vector rand_bytes_a(GENERATED_RANDOM_BYTE_LEN, 0x00); std::vector rand_bytes_b(GENERATED_RANDOM_BYTE_LEN, 0x00); - std::ranges::generate(rand_bytes_a, rand_gen); + randomshake::randomshake_t<> csprng_a(seed); + std::ranges::generate(rand_bytes_a, [&]() { return csprng_a(); }); + seed.fill(0xde); randomshake_test_utils::do_bitflip(seed[0], 3); - std::ranges::generate(rand_bytes_b, rand_gen); + + randomshake::randomshake_t<> csprng_b(seed); + std::ranges::generate(rand_bytes_b, [&]() { return csprng_b(); }); EXPECT_NE(rand_bytes_a, rand_bytes_b); } From 1848f99e092e2682994d0e5411f09d4b7595f1e6 Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Sat, 15 Nov 2025 19:43:05 +0530 Subject: [PATCH 07/18] Increase column limit in clang-format style spec. file Signed-off-by: Anjan Roy --- .clang-format | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.clang-format b/.clang-format index 6f0145f..0b38cb0 100644 --- a/.clang-format +++ b/.clang-format @@ -81,7 +81,7 @@ BreakBeforeTernaryOperators: true BreakConstructorInitializers: BeforeComma BreakInheritanceList: BeforeComma BreakStringLiterals: true -ColumnLimit: 120 +ColumnLimit: 160 CommentPragmas: '^ IWYU pragma:' CompactNamespaces: false ConstructorInitializerIndentWidth: 2 From b3279face7a3d7d1c8130898a792b2d9a9ebad3f Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Sat, 15 Nov 2025 19:46:10 +0530 Subject: [PATCH 08/18] Update benchmark functions to correctly benchmark various parameterizations of RandomSHAKE CSPRNG Signed-off-by: Anjan Roy --- benches/bench_csprng_creation.cpp | 32 +++++--------------- benches/bench_csprng_generation.cpp | 45 ++++++++++------------------- 2 files changed, 22 insertions(+), 55 deletions(-) diff --git a/benches/bench_csprng_creation.cpp b/benches/bench_csprng_creation.cpp index 826d5c4..9d44713 100644 --- a/benches/bench_csprng_creation.cpp +++ b/benches/bench_csprng_creation.cpp @@ -3,56 +3,38 @@ #include #include -template static void bench_deterministic_csprng_creation(benchmark::State& state) { - std::array::seed_byte_len> seed{}; + std::array::seed_byte_len> seed{}; seed.fill(0xde); for (auto _ : state) { benchmark::DoNotOptimize(seed); - randomshake::randomshake_t csprng(seed); + randomshake::randomshake_t<> csprng(seed); benchmark::DoNotOptimize(&csprng); benchmark::ClobberMemory(); } } -template static void bench_nondeterministic_csprng_creation(benchmark::State& state) { for (auto _ : state) { - randomshake::randomshake_t csprng; + randomshake::randomshake_t<> csprng; benchmark::DoNotOptimize(&csprng); benchmark::ClobberMemory(); } } -BENCHMARK(bench_deterministic_csprng_creation<128>) - ->Name("deterministic_csprng/128b/create") - ->ComputeStatistics("min", compute_min) - ->ComputeStatistics("max", compute_max); -BENCHMARK(bench_deterministic_csprng_creation<192>) - ->Name("deterministic_csprng/192b/create") - ->ComputeStatistics("min", compute_min) - ->ComputeStatistics("max", compute_max); -BENCHMARK(bench_deterministic_csprng_creation<256>) - ->Name("deterministic_csprng/256b/create") +BENCHMARK(bench_deterministic_csprng_creation) + ->Name("deterministic_csprng/create") ->ComputeStatistics("min", compute_min) ->ComputeStatistics("max", compute_max); -BENCHMARK(bench_nondeterministic_csprng_creation<128>) - ->Name("non-deterministic_csprng/128b/create") - ->ComputeStatistics("min", compute_min) - ->ComputeStatistics("max", compute_max); -BENCHMARK(bench_nondeterministic_csprng_creation<192>) - ->Name("non-deterministic_csprng/192b/create") - ->ComputeStatistics("min", compute_min) - ->ComputeStatistics("max", compute_max); -BENCHMARK(bench_nondeterministic_csprng_creation<256>) - ->Name("non-deterministic_csprng/256b/create") +BENCHMARK(bench_nondeterministic_csprng_creation) + ->Name("non-deterministic_csprng/create") ->ComputeStatistics("min", compute_min) ->ComputeStatistics("max", compute_max); diff --git a/benches/bench_csprng_generation.cpp b/benches/bench_csprng_generation.cpp index ecf670f..0fe05d7 100644 --- a/benches/bench_csprng_generation.cpp +++ b/benches/bench_csprng_generation.cpp @@ -2,16 +2,17 @@ #include "randomshake/randomshake.hpp" #include #include +#include #include -template +template static void bench_csprng_output_generation(benchmark::State& state) { - std::array::seed_byte_len> seed{}; + std::array::seed_byte_len> seed{}; seed.fill(0xde); - randomshake::randomshake_t csprng(seed); + randomshake::randomshake_t csprng(seed); result_type result{}; for (auto _ : state) { @@ -28,14 +29,14 @@ bench_csprng_output_generation(benchmark::State& state) state.SetBytesProcessed(state.iterations() * sizeof(result_type)); } -template +template static void bench_csprng_byte_sequence_squeezing(benchmark::State& state) { - std::array::seed_byte_len> seed{}; + std::array::seed_byte_len> seed{}; seed.fill(0xde); - randomshake::randomshake_t csprng(seed); + randomshake::randomshake_t csprng(seed); constexpr size_t RANDOM_OUTPUT_BYTE_LEN = 1'024 * 1'024; // 1 MB std::vector rand_byte_seq(RANDOM_OUTPUT_BYTE_LEN, 0); @@ -54,32 +55,16 @@ bench_csprng_byte_sequence_squeezing(benchmark::State& state) state.SetBytesProcessed(state.iterations() * rand_byte_seq.size()); } -BENCHMARK(bench_csprng_output_generation<256, uint8_t>) - ->Name("csprng/256b/generate_u8") - ->ComputeStatistics("min", compute_min) - ->ComputeStatistics("max", compute_max); -BENCHMARK(bench_csprng_output_generation<256, uint16_t>) - ->Name("csprng/256b/generate_u16") - ->ComputeStatistics("min", compute_min) - ->ComputeStatistics("max", compute_max); -BENCHMARK(bench_csprng_output_generation<256, uint32_t>) - ->Name("csprng/256b/generate_u32") - ->ComputeStatistics("min", compute_min) - ->ComputeStatistics("max", compute_max); -BENCHMARK(bench_csprng_output_generation<256, uint64_t>) - ->Name("csprng/256b/generate_u64") - ->ComputeStatistics("min", compute_min) - ->ComputeStatistics("max", compute_max); +BENCHMARK(bench_csprng_output_generation)->Name("csprng/generate_u8")->ComputeStatistics("min", compute_min)->ComputeStatistics("max", compute_max); +BENCHMARK(bench_csprng_output_generation)->Name("csprng/generate_u16")->ComputeStatistics("min", compute_min)->ComputeStatistics("max", compute_max); +BENCHMARK(bench_csprng_output_generation)->Name("csprng/generate_u32")->ComputeStatistics("min", compute_min)->ComputeStatistics("max", compute_max); +BENCHMARK(bench_csprng_output_generation)->Name("csprng/generate_u64")->ComputeStatistics("min", compute_min)->ComputeStatistics("max", compute_max); -BENCHMARK(bench_csprng_byte_sequence_squeezing<128>) - ->Name("csprng/128b/generate_byte_seq") - ->ComputeStatistics("min", compute_min) - ->ComputeStatistics("max", compute_max); -BENCHMARK(bench_csprng_byte_sequence_squeezing<192>) - ->Name("csprng/192b/generate_byte_seq") +BENCHMARK(bench_csprng_byte_sequence_squeezing) + ->Name("csprng/shake256/generate_byte_seq") ->ComputeStatistics("min", compute_min) ->ComputeStatistics("max", compute_max); -BENCHMARK(bench_csprng_byte_sequence_squeezing<256>) - ->Name("csprng/256b/generate_byte_seq") +BENCHMARK(bench_csprng_byte_sequence_squeezing) + ->Name("csprng/turboshake256/generate_byte_seq") ->ComputeStatistics("min", compute_min) ->ComputeStatistics("max", compute_max); From 23309422b724307d24bcafc213d2a0b617088a01 Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Sat, 15 Nov 2025 19:56:12 +0530 Subject: [PATCH 09/18] Add new test for ensuring that two CSPRNGs with same seed but diff underlying XOFs produce different output bytes Signed-off-by: Anjan Roy --- tests/test_deterministic_csprng.cpp | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/tests/test_deterministic_csprng.cpp b/tests/test_deterministic_csprng.cpp index 148b310..a487b64 100644 --- a/tests/test_deterministic_csprng.cpp +++ b/tests/test_deterministic_csprng.cpp @@ -46,7 +46,27 @@ TEST(RandomShake, Deterministic_CSPRNG_Using_Diff_Seed_Produces_Ne_Output) EXPECT_NE(rand_bytes_a, rand_bytes_b); } -TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Result_Type_Produces_Same_Output) +TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_XOF_Kind_Produces_Ne_Output) +{ + std::array::seed_byte_len> seed_a{}; + seed_a.fill(0xde); + + std::vector rand_bytes_a(GENERATED_RANDOM_BYTE_LEN, 0x00); + std::vector rand_bytes_b(GENERATED_RANDOM_BYTE_LEN, 0x00); + + randomshake::randomshake_t csprng_a(seed_a); + std::ranges::generate(rand_bytes_a, [&]() { return csprng_a(); }); + + std::array::seed_byte_len> seed_b{}; + seed_b.fill(0xde); + + randomshake::randomshake_t<> csprng_b(seed_b); + std::ranges::generate(rand_bytes_b, [&]() { return csprng_b(); }); + + EXPECT_NE(rand_bytes_a, rand_bytes_b); +} + +TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Result_Type_Produces_Eq_Output) { std::array::seed_byte_len> seed{}; seed.fill(0xde); From 2d0762f4d040898fcac67296d5ed95dc5288f9d2 Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Sat, 15 Nov 2025 20:54:43 +0530 Subject: [PATCH 10/18] Move test constant definition to its own header file Signed-off-by: Anjan Roy --- tests/test_consts.hpp | 4 ++++ tests/test_deterministic_csprng.cpp | 3 +-- 2 files changed, 5 insertions(+), 2 deletions(-) create mode 100644 tests/test_consts.hpp diff --git a/tests/test_consts.hpp b/tests/test_consts.hpp new file mode 100644 index 0000000..9ad8cb7 --- /dev/null +++ b/tests/test_consts.hpp @@ -0,0 +1,4 @@ +#pragma once +#include + +static constexpr size_t GENERATED_RANDOM_BYTE_LEN = 1'024 * 1'024; // = 1MB diff --git a/tests/test_deterministic_csprng.cpp b/tests/test_deterministic_csprng.cpp index a487b64..ab4cbeb 100644 --- a/tests/test_deterministic_csprng.cpp +++ b/tests/test_deterministic_csprng.cpp @@ -1,4 +1,5 @@ #include "randomshake/randomshake.hpp" +#include "test_consts.hpp" #include "test_utils.hpp" #include #include @@ -7,8 +8,6 @@ #include #include -static constexpr size_t GENERATED_RANDOM_BYTE_LEN = 1'024 * 1'024; // = 1MB - TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_Produces_Eq_Output) { std::array::seed_byte_len> seed{}; From 37e78a1e38ff42cf49c0ee36b2418e6d4927cb24 Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Sat, 15 Nov 2025 20:54:59 +0530 Subject: [PATCH 11/18] Add test to detect if ratcheting kicks in Signed-off-by: Anjan Roy --- tests/test_ratcheting.cpp | 105 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 105 insertions(+) create mode 100644 tests/test_ratcheting.cpp diff --git a/tests/test_ratcheting.cpp b/tests/test_ratcheting.cpp new file mode 100644 index 0000000..0549f1b --- /dev/null +++ b/tests/test_ratcheting.cpp @@ -0,0 +1,105 @@ +#include "randomshake/randomshake.hpp" +#include "test_consts.hpp" +#include +#include +#include +#include +#include + +// A dummy CSPRNG based on specified XOF choice, without ratcheting. Only squeezing after finalizing the sponge. +template +struct dummy_noratchet_csprng +{ +private: + randomshake::xof_selector_t::type state; + +public: + dummy_noratchet_csprng(std::span::seed_byte_len> seed) + { + state.reset(); + state.absorb(seed); + state.finalize(); + } + + uint8_t operator()() + { + uint8_t result = 0; + + auto res_ptr = reinterpret_cast(&result); + auto res_span = std::span(res_ptr, sizeof(result)); + + state.squeeze(res_span); + return result; + } +}; + +template +static void +test_ratchet_getting_activated_post_ratchet_period_bytes_output() +{ + // --- Paint output buffers. --- + + /** + * In following section, we paint subspans of two byte arrays with different byte patterns. + * + * We have two equal sized byte arrays, holding pseudo-random output from two different CSPRNGS. + * One is a RandomSHAKE CSPRNG while another one is a dummy CSPRNG based on same XOF, but no ratcheting. + */ + std::vector original_csprng_bytes(GENERATED_RANDOM_BYTE_LEN, 0x00); + std::vector dummy_noratchet_csprng_bytes(GENERATED_RANDOM_BYTE_LEN, 0x00); + + auto original_csprng_bytes_span = std::span(original_csprng_bytes); + auto dummy_noratchet_csprng_bytes_span = std::span(dummy_noratchet_csprng_bytes); + + /** + * After producing these many bytes, the RandomSHAKE CSPRNG should ratchet. But the dummy one should not. + * + * 1) Hence till these many bytes, both CSPRNG's should produce exact same byte stream. So initially we paint + * this portion of two buffers with different byte patterns to be able to catch both CSPRNG's producing same output stream. + * + * 2) And after these many bytes, their output should completely diverge. To detect ratcheting kick-in, + * we paint this portion of two buffers with same byte pattern. + */ + constexpr auto RATCHET_PERIOD_BYTE_LEN = randomshake::xof_selector_t::ratchet_period_byte_len; + + auto first_of_original = original_csprng_bytes_span.template first(); + std::fill(first_of_original.begin(), first_of_original.end(), 0x11); + + auto first_of_dummy = dummy_noratchet_csprng_bytes_span.template first(); + std::fill(first_of_dummy.begin(), first_of_dummy.end(), 0x22); + + auto last_of_original = original_csprng_bytes_span.template last(); + std::fill(last_of_original.begin(), last_of_original.end(), 0xff); + + auto last_of_dummy = dummy_noratchet_csprng_bytes_span.template last(); + std::fill(last_of_dummy.begin(), last_of_dummy.end(), 0xff); + + EXPECT_FALSE(std::ranges::equal(first_of_original, first_of_dummy)); + EXPECT_TRUE(std::ranges::equal(last_of_original, last_of_dummy)); + + // --- Painting done and tested to be working. --- + + std::array::seed_byte_len> seed{}; + seed.fill(0xde); + + randomshake::randomshake_t original_csprng(seed); + dummy_noratchet_csprng dummy_noratchet_csprng(seed); + + std::ranges::generate(original_csprng_bytes_span, [&]() { return original_csprng(); }); + std::ranges::generate(dummy_noratchet_csprng_bytes_span, [&]() { return dummy_noratchet_csprng(); }); + + // During final testing to detect if ratcheting kicked in, we flip the assertions. + + EXPECT_TRUE(std::ranges::equal(first_of_original, first_of_dummy)); + EXPECT_FALSE(std::ranges::equal(last_of_original, last_of_dummy)); +} + +TEST(RandomShake, Deterministic_CSPRNG_Detect_Ratchet_Working_For_SHAKE256_XOF) +{ + test_ratchet_getting_activated_post_ratchet_period_bytes_output(); +} + +TEST(RandomShake, Deterministic_CSPRNG_Detect_Ratchet_Working_For_TurboSHAKE256_XOF) +{ + test_ratchet_getting_activated_post_ratchet_period_bytes_output(); +} From 62b703ecb83cbd4ebe67aed2e48a36cb02e0214f Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Sat, 15 Nov 2025 21:03:57 +0530 Subject: [PATCH 12/18] Update existing examples to work with new API Signed-off-by: Anjan Roy --- examples/csprng_generate_byte_seq.cpp | 2 +- examples/csprng_with_bernoulli_dist.cpp | 2 +- examples/csprng_with_binomial_dist.cpp | 2 +- examples/csprng_with_uniform_int_dist.cpp | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/examples/csprng_generate_byte_seq.cpp b/examples/csprng_generate_byte_seq.cpp index f162390..cc407e4 100644 --- a/examples/csprng_generate_byte_seq.cpp +++ b/examples/csprng_generate_byte_seq.cpp @@ -5,7 +5,7 @@ int main() { - randomshake::randomshake_t<256> csprng; + randomshake::randomshake_t<> csprng; constexpr size_t RANDOM_OUTPUT_BYTE_LEN = 1'024 * 1'024; std::vector rand_byte_seq(RANDOM_OUTPUT_BYTE_LEN, 0); diff --git a/examples/csprng_with_bernoulli_dist.cpp b/examples/csprng_with_bernoulli_dist.cpp index 10002ed..0ae133b 100644 --- a/examples/csprng_with_bernoulli_dist.cpp +++ b/examples/csprng_with_bernoulli_dist.cpp @@ -10,7 +10,7 @@ int main() { - randomshake::randomshake_t<256> csprng; + randomshake::randomshake_t<> csprng; std::bernoulli_distribution dist{ .25 }; std::map hist; diff --git a/examples/csprng_with_binomial_dist.cpp b/examples/csprng_with_binomial_dist.cpp index b5ab8b3..8d9d524 100644 --- a/examples/csprng_with_binomial_dist.cpp +++ b/examples/csprng_with_binomial_dist.cpp @@ -7,7 +7,7 @@ int main() { - randomshake::randomshake_t<256> csprng; + randomshake::randomshake_t<> csprng; std::binomial_distribution dist{ 1'000, .5 }; for (auto _ : std::ranges::iota_view{ 1, 10 }) { diff --git a/examples/csprng_with_uniform_int_dist.cpp b/examples/csprng_with_uniform_int_dist.cpp index 3691cf3..293a3fd 100644 --- a/examples/csprng_with_uniform_int_dist.cpp +++ b/examples/csprng_with_uniform_int_dist.cpp @@ -8,11 +8,11 @@ int main() { - std::array::seed_byte_len> seed{}; + std::array::seed_byte_len> seed{}; seed.fill(0xfe); // Deterministic CSPRNG : Seed -based initialization of CSPRNG - randomshake::randomshake_t<256> csprng(seed); + randomshake::randomshake_t<> csprng(seed); std::uniform_int_distribution dist{ 97, 102 }; for (auto _ : std::ranges::iota_view{ 1, 10 }) { From 9b4c793a186086211cd29a7adb26368349134f14 Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Sat, 15 Nov 2025 21:08:51 +0530 Subject: [PATCH 13/18] Add new example program showing how to override default XOF Signed-off-by: Anjan Roy --- ...generate_byte_seq_with_non_default_xof.cpp | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 examples/csprng_generate_byte_seq_with_non_default_xof.cpp diff --git a/examples/csprng_generate_byte_seq_with_non_default_xof.cpp b/examples/csprng_generate_byte_seq_with_non_default_xof.cpp new file mode 100644 index 0000000..f6be986 --- /dev/null +++ b/examples/csprng_generate_byte_seq_with_non_default_xof.cpp @@ -0,0 +1,21 @@ +#include "randomshake/randomshake.hpp" +#include +#include + +int +main() +{ + /** + * By default, RandomSHAKE CSPRNG relies on TurboSHAKE256 XOF. But we can specify SHAKE256 to override + * that default choice. Though remember, the default XOF choice is faster. It can have almost double + * throughput compared to SHAKE256. + */ + randomshake::randomshake_t csprng; + + constexpr size_t RANDOM_OUTPUT_BYTE_LEN = 1'024 * 1'024; + std::vector rand_byte_seq(RANDOM_OUTPUT_BYTE_LEN, 0); + + csprng.generate(rand_byte_seq); + + return EXIT_SUCCESS; +} From a83cfb7238d6ad182f8b07eb5d555eb9c70068ba Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Sat, 15 Nov 2025 22:00:58 +0530 Subject: [PATCH 14/18] Add example showing usage of RandomSHAKE CSPRNG with `uniform_real_distribution` of stdlib Signed-off-by: Anjan Roy --- examples/csprng_with_uniform_real_dist.cpp | 66 ++++++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 examples/csprng_with_uniform_real_dist.cpp diff --git a/examples/csprng_with_uniform_real_dist.cpp b/examples/csprng_with_uniform_real_dist.cpp new file mode 100644 index 0000000..3a925a4 --- /dev/null +++ b/examples/csprng_with_uniform_real_dist.cpp @@ -0,0 +1,66 @@ +#include "randomshake/randomshake.hpp" +#include +#include +#include +#include +#include +#include + +float +compute_mean(std::span vals) +{ + float res = 0.f; + for (auto v : vals) { + res += v; + } + + return res / static_cast(vals.size()); +} + +float +compute_standard_deviation(std::span vals) +{ + const auto mean = compute_mean(vals); + + float squared_diff = 0.f; + for (auto v : vals) { + squared_diff += std::pow(v - mean, 2.f); + } + + const auto squared_diff_mean = squared_diff / static_cast(vals.size()); + const auto standard_deviation = std::sqrt(squared_diff_mean); + + return standard_deviation; +} + +float +expected_standard_deviation_for_continuous_uniform_distributed_real_numbers(const float start_interval, const float end_interval) +{ + return (end_interval - start_interval) / std::sqrt(12.f); +} + +int +main() +{ + const float start_interval = 0.f; + const float end_interval = 1.f; + + assert(start_interval < end_interval); + + randomshake::randomshake_t<> csprng; + std::uniform_real_distribution dist{ start_interval, end_interval }; + + constexpr size_t NUMBER_OF_RANDOM_FLOATS = 1'000'000; + std::vector rand_floats(NUMBER_OF_RANDOM_FLOATS, 0.f); + std::ranges::generate(rand_floats, [&]() { return dist(csprng); }); + + const auto computed_sd = compute_standard_deviation(rand_floats); + const auto expected_sd = expected_standard_deviation_for_continuous_uniform_distributed_real_numbers(start_interval, end_interval); + const auto difference = std::abs(computed_sd - expected_sd); + + std::cout << "Computed Standard Deviation: " << computed_sd << "\n"; + std::cout << "Expected Standard Deviation: " << expected_sd << "\n"; + std::cout << "Absolute Difference : " << difference << "\n"; + + return EXIT_SUCCESS; +} From 15f8eb1f8ca1c331751334cf4e2004ca00ef686f Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Sat, 15 Nov 2025 22:03:50 +0530 Subject: [PATCH 15/18] Add comment in github actions ci script Signed-off-by: Anjan Roy --- .github/workflows/test_ci.yml | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/.github/workflows/test_ci.yml b/.github/workflows/test_ci.yml index c497db1..fa1c871 100644 --- a/.github/workflows/test_ci.yml +++ b/.github/workflows/test_ci.yml @@ -1,5 +1,5 @@ # Collects inspiration from https://github.com/itzmeanjan/sha3/blob/fb21648e136d7a64ce5c065fa829d4e3254414f4/.github/workflows/test_ci.yml -name: Test RandomShake Cryptographically Secure PRNG +name: Test RandomShake CSPRNG on: push: @@ -12,7 +12,10 @@ jobs: runs-on: ${{matrix.os}} strategy: matrix: - os: [ubuntu-latest, macos-latest] + os: [ + ubuntu-latest, # x86_64 + macos-latest, # aarch64 + ] compiler: [g++, clang++] build_type: [debug, release] test_type: [standard, asan, ubsan] From 6ae9173b41de2cb0c218c7effe673870af665298 Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Mon, 17 Nov 2025 12:35:22 +0530 Subject: [PATCH 16/18] Update project documentation and benchmark results Signed-off-by: Anjan Roy --- README.md | 113 +- ..._6.11.0-18-generic_x86_64_with_g++_14.json | 1332 ----------------- ...x_6.14.0-1015-aws_aarch64_with_g++_13.json | 799 ++++++++++ ...ux_6.14.0-1015-aws_x86_64_with_g++_13.json | 799 ++++++++++ ...x_6.17.0-6-generic_x86_64_with_g++_15.json | 846 +++++++++++ ...ux_6.8.0-1021-aws_aarch64_with_g++_13.json | 1254 ---------------- ...nux_6.8.0-1021-aws_x86_64_with_g++_13.json | 1254 ---------------- 7 files changed, 2503 insertions(+), 3894 deletions(-) delete mode 100644 bench_result_on_Linux_6.11.0-18-generic_x86_64_with_g++_14.json create mode 100644 bench_result_on_Linux_6.14.0-1015-aws_aarch64_with_g++_13.json create mode 100644 bench_result_on_Linux_6.14.0-1015-aws_x86_64_with_g++_13.json create mode 100644 bench_result_on_Linux_6.17.0-6-generic_x86_64_with_g++_15.json delete mode 100644 bench_result_on_Linux_6.8.0-1021-aws_aarch64_with_g++_13.json delete mode 100644 bench_result_on_Linux_6.8.0-1021-aws_x86_64_with_g++_13.json diff --git a/README.md b/README.md index 160adc2..0f19093 100644 --- a/README.md +++ b/README.md @@ -1,38 +1,50 @@ -# RandomShake -Shake256 Xof -based Portable C++20 Cryptographically Secure Pseudo Random Number Generator (CSPRNG) - plug and play with C++ `` header's random distributions. +# RandomSHAKE -## Why ? +(Turbo)SHAKE256 XOF -based Portable C++20 Cryptographically Secure Pseudo Random Number Generator (CSPRNG) - plug and play with C++ standard library's `` header's statistical distributions. -C++11 introduced `` header to its standard library, which offers multiple pseudo-random number generator engines and distributions. The design of the `` header is very much modular, it's possible to plug any psuedo-random number generator engine with any distribution and start getting results as per the rules of the statistical distribution. All that is needed is providing the distribution with a source *u*niform *r*andom *n*umber *g*enerator (URNG). One thing that the standard library's `` header lacks is the psuedo-random number generator engines, which come by default, are not cryptographically secure. Hence using those engines with provided distributions, in cryptographic settings, might be quite catastrophic ! +## Why ? -This is where "RandomShake" comes, collecting inspiration from https://seth.rocks/articles/cpprandom. +C++11 introduced `` header to its standard library, which offers multiple pseudo-random number generator engines and statistical distributions. The design of the `` header is very much modular, it's possible to plug any psuedo-random number generator engine with any distribution and start getting results as per the rules of the statistical distribution. All that is needed, is providing the distribution with a source *U*niform *R*andom *N*umber *G*enerator (URNG). One thing that the standard library's `` header lacks is a cryptographically secure psuedo-random number generator engine. Using any of the provided engines such as Mersenne Twister or Linear Congruential engine with provided distributions, in cryptographic settings, might be quite catastrophic! -"RandomShake" is a *C*ryptographically *S*ecure *P*seudo-*R*andom *N*umber *G*enerator (CSPRNG) engine, which is backed by Shake256 extendable output function (Xof) with frequent ratcheting of the underlying keccak-1600 permutation state, generating unsigned integer (of all standard bit-widths) stream for all three NIST security levels. It's very easy to plug this CSPRNG engine into any of the C++ standard library's random distributions. Just plug and play. And now you can use those distributions with "RandomShake" CSPRNG, in cryptographic settings. It also offers API for generating arbitrary many bytes at a time. "RandomShake" offers following two ways for seeding the internal Shake256 state. +This is where "RandomSHAKE" comes, collecting inspiration from . -- [**Non-deterministic CSPRNG**] Sampling k -bit non-deterministic randomness from `std::random_device` engine. -- [**Deterministic and re-producible CSPRNG**] Taking k -bit seed as input from function caller. +"RandomSHAKE" is a *C*ryptographically *S*ecure *P*seudo-*R*andom *N*umber *G*enerator (CSPRNG) engine, which is backed by (Turbo)SHAKE256 eXtendable Output Function (XOF) with occasional ratcheting, generating unsigned integer (of all standard bit-widths) stream. It's optional to specify which XOF you want to use. By default you get TurboSHAKE256, which doubles the throughput compared to SHAKE256. In case you really want SHAKE256, you need to be explicit. For initializing the CSPRNG, either you can rely on the convenient default constructor, which samples initial seed from the **non-deterministic** `std::random_device` API or you can explicitly supply a seed for **deterministic** and reproducible behaviour. It's very easy to plug this CSPRNG engine into any of the C++ standard library's statistical distributions defined in `` header. Just plug and play. And now you can use those distributions with "RandomSHAKE" CSPRNG, in cryptographic settings - producing integers or floats, whatever you need. It also offers API for generating arbitrary long byte stream at a time. -Using the non-deterministic CSPRNG is very convenient, but there is a caveat - this CSPRNG samples its seed from `std::random_device` engine, which is supposed to be non-deterministic, but is not guaranteed to be - it's implementation-defined behavior. I strongly advise you to read https://en.cppreference.com/w/cpp/numeric/random/random_device. +> [!CAUTION] +> Using the non-deterministic CSPRNG initialization API is very convenient, but there is a caveat - this CSPRNG samples its seed from `std::random_device` engine, which is supposed to be non-deterministic, but is not guaranteed to be - it's implementation-defined behavior. I strongly advise you to read . ```cpp -using csprng_256b_t = randomshake::randomshake_t<256>; +// Result type: uint8_t, XOF: TurboSHAKE256. Default case. +using csprng_t = randomshake::randomshake_t<>; + +// Or +// Result type: uint16_t, XOF: TurboSHAKE256. Override only default result data type. +using csprng_t = randomshake::randomshake_t; + +// Or +// Result type: uint8_t, XOF: SHAKE256. Override only default XOF. +using csprng_t = randomshake::randomshake_t; -csprng_256b_t csprng; // Automatically seeded using `std::random_device` +// Or +// Result type: uint64_t, XOF: SHAKE256. Override both default result data type and XOF. +using csprng_t = randomshake::randomshake_t; + +csprng_t csprng; // Default constructor. Automatically seeded using `std::random_device`. Non-deterministic. ``` -While for the deterministic CSPRNG, as an user, it's your responsibility to supply a seed of required byte length with sufficient entropy - this CSPRNG is the one to use, if you need reproducible random bytes. +While for the deterministic CSPRNG, as an user, it's your responsibility to supply a seed of required byte length with sufficient entropy. You should use this CSPRNG API, if you need reproducible random bytes. ```cpp -std::array seed{}; -seed.fill(0xde); // Please don't do it in any practical scenario ! +std::array seed{}; +seed.fill(0xde); // Please don't do it in any practical scenario ! -csprng_256b_t csprng(seed); // Initialized by the seed we supply +csprng_t csprng(seed); // Explicit constructor. Initialized by the seed, we supply. Deterministic. ``` Using the CSPRNG instance for sampling random value(s), is super easy. ```cpp -// Sample a single random uint8_t. +// Sample a single random uint8_t or uint16_t or uint32_t or uint64_t. Based on result data type template parameter. const auto random_value = csprng(); // or @@ -41,24 +53,23 @@ std::vector rand_values(16, 0x00); std::ranges::generate(rand_values, [&]() { return csprng(); }); // or -// Fill the vector, by squeezing many bytes at a time. +// Fill the vector, by squeezing many bytes at a time. Convenient `generate` API for squeezing arbitrary many bytes. csprng.generate(rand_values); ``` -### "RandomShake" CSPRNG Performance Overview +### "RandomSHAKE" CSPRNG Performance Overview -CSPRNG Operation for bit-security level `256` | Time taken on AWS EC2 Instance `c7i.large` | Time taken on AWS EC2 Instance `c8g.large` +CSPRNG Operation | Time taken on AWS EC2 Instance `c7i.large` | Time taken on AWS EC2 Instance `c8g.large` --- | --- | --- -Deterministic seeding of instance | 2.71us | 2.98us -Non-Deterministic seeding of instance | 7.39us | 5.14us - -CSPRNG Operation for bit-security level `256` | Bandwidth on AWS EC2 Instance `c7i.large` (Linux 6.8.0-1021-aws, g++ 13) | Bandwidth on AWS EC2 Instance `c8g.large` (Linux 6.8.0-1021-aws, g++ 13) ----|---|--- -Sampling of `u8` | 379.1 MB/s | 199.9 MB/s -Sampling of `u16` | 428.4 MB/s | 258.0 MB/s -Sampling of `u32` | 459.1 MB/s | 303.8 MB/s -Sampling of `u64` | 470.4 MB/s | 331.2 MB/s -Sampling arbitrary long byte sequence | 483.7 MB/s | 357.5 MB/s +Deterministic seeding of instance | 1.63 us | 1.83 us +Non-Deterministic seeding of instance | 30.34 us | 11.49 us +--- | --- | --- +Sampling of `u8` | 315.4 MB/s | 202.7 MB/s +Sampling of `u16` | 208.5 MB/s | 278.4 MB/s +Sampling of `u32` | 315.1 MB/s | 388.3 MB/s +Sampling of `u64` | 588.5 MB/s | 491.5 MB/s +Sampling arbitrary long byte sequence (using TurboSHAKE256 XOF, default) | 718.8 MB/s | 637.5 MB/s +Sampling arbitrary long byte sequence (using SHAKE256 XOF, explicit) | 400.1 MB/s | 354.7 MB/s ## How to setup ? @@ -67,27 +78,27 @@ Sampling arbitrary long byte sequence | 483.7 MB/s | 357.5 MB/s ```bash # I'm using $ c++ --version -c++ (Ubuntu 14.2.0-4ubuntu2) 14.2.0 +c++ (Ubuntu 15.2.0-4ubuntu4) 15.2.0 ``` - You will also need both `make` and `cmake` for building this project and test framework/ benchmark harness. ```bash $ make --version -GNU Make 4.3 +GNU Make 4.4.1 $ cmake --version -cmake version 3.30.3 +cmake version 3.31.6 ``` -- For running tests, you must have `google-test` globally installed. Follow steps described @ https://github.com/google/googletest/blob/main/googletest/README.md. -- For running benchmarks, you must have `google-benchmark` globally installed. You may find steps described @ https://github.com/google/benchmark/?tab=readme-ov-file#installation helpful. +- For running tests, you must have `google-test` globally installed. Follow steps described @ . +- For running benchmarks, you must have `google-benchmark` globally installed. You may find steps described @ helpful. > [!NOTE] -> In case you are planning to run benchmarks on a machine which runs GNU/Linux kernel, I suggest you build `google-benchmark` with libPFM, so that you get to know how many CPU cycles does it take for each benchmarked functions to execute. I describe the steps @ https://gist.github.com/itzmeanjan/05dc3e946f635d00c5e0b21aae6203a7. +> In case you are planning to run benchmarks on a machine which runs GNU/Linux kernel, I suggest you build `google-benchmark` with libPFM, so that you get to know how many CPU cycles does it take for each benchmarked functions to execute. I describe the steps @ . > [!NOTE] -> I use the BASH script @ https://gist.github.com/itzmeanjan/84b7df57604708e33f04fc43e55ecb0c to quickly setup a GNU/Linux machine, so that I can run tests and benchmarks. Running this script does the whole setup phase for you on Ubuntu and large family of OS. +> I use the BASH script @ to quickly setup a GNU/Linux machine, so that I can run tests and benchmarks. Running this script does the whole setup phase for you on Ubuntu and adjacent family of Linux distributions. ## How to test ? @@ -131,28 +142,22 @@ make perf -j ``` > [!CAUTION] -> You must disable CPU frequency scaling during benchmarking. I found guide @ https://github.com/google/benchmark/blob/4931aefb51d1e5872b096a97f43e13fa0fc33c8c/docs/reducing_variance.md helpful. +> You must disable CPU frequency scaling during benchmarking. I found guide @ helpful. I've run benchmarks on some platforms and here are the results. -Benchmarking Results on DESKTOP -grade Machine(s) ---- - -### On 12th Gen Intel(R) Core(TM) i7-1260P -I maintain the benchmark results in JSON format @ [bench_result_on_Linux_6.11.0-18-generic_x86_64_with_g++_14](./bench_result_on_Linux_6.11.0-18-generic_x86_64_with_g++_14.json). +### Benchmarking on DESKTOP-grade Machine(s) -Benchmarking Results on SERVER -grade Machine(s) ---- +- x86_64. 12th Gen Intel(R) Core(TM) i7-1260P. JSON dump @ [bench_result_on_Linux_6.17.0-6-generic_x86_64_with_g++_15](./bench_result_on_Linux_6.17.0-6-generic_x86_64_with_g++_15.json). -### On Intel(R) Xeon(R) Platinum 8488C i.e. AWS EC2 Instance `c7i.large` -Find the benchmark results in JSON format @ [bench_result_on_Linux_6.8.0-1021-aws_x86_64_with_g++_13](./bench_result_on_Linux_6.8.0-1021-aws_x86_64_with_g++_13.json). +### Benchmarking on SERVER-grade Machine(s) -### On AWS EC2 Instance `c8g.large` i.e. AWS Graviton4 -Find the benchmark results in JSON format @ [bench_result_on_Linux_6.8.0-1021-aws_aarch64_with_g++_13](./bench_result_on_Linux_6.8.0-1021-aws_aarch64_with_g++_13.json). +- x86_64. AWS EC2 Instance `c7i.large` i.e. Intel Xeon. JSON dump @ [bench_result_on_Linux_6.14.0-1015-aws_x86_64_with_g++_13](./bench_result_on_Linux_6.14.0-1015-aws_x86_64_with_g++_13.json). +- aarch64. AWS EC2 Instance `c8g.large` i.e. AWS Graviton4. JSON dump @ [bench_result_on_Linux_6.14.0-1015-aws_aarch64_with_g++_13](./bench_result_on_Linux_6.14.0-1015-aws_aarch64_with_g++_13.json). ## How to use ? -Using "RandomShake" CSPRNG is very easy. +Using "RandomSHAKE" CSPRNG is very easy. - Clone this repository, whiile importing all git submodule -based dependencies. @@ -174,7 +179,7 @@ git clone https://github.com/itzmeanjan/RandomShake.git --recurse-submodules int main() { - randomshake::randomshake_t<256> csprng; + randomshake::randomshake_t<> csprng; std::binomial_distribution dist{ 1'000, .5 }; for (auto _ : std::ranges::iota_view{ 1, 10 }) { @@ -186,9 +191,9 @@ main() ``` > [!NOTE] -> In above demonstration, I'm showing how to use "RandomShake" CSPRNG (at 256 -bit security) with C++ standard library's Binomial Distribution, but it should be fairly easy, plugging this CSPRNG with any other available distribution. +> In above demonstration, I'm showing how to use "RandomSHAKE" CSPRNG with C++ standard library's Binomial Distribution, but it should be fairly easy, plugging this CSPRNG with any other available distribution in `` header. -- Compile the C++ translation unit, while including path to both "RandomShake" and "sha3". +- Compile the C++ translation unit, while including path to both "RandomSHAKE" and "sha3". ```bash c++ -std=c++20 -Wall -Wextra -Wpedantic -O3 -march=native -I ./include -I ./sha3/include examples/csprng_with_binomial_dist.cpp @@ -208,6 +213,6 @@ c++ -std=c++20 -Wall -Wextra -Wpedantic -O3 -march=native -I ./include -I ./sha [BINOMIAL dISTRIBUTION] Number of heads in 1,000 flips: 491 ``` -In case you just want to generate arbitrary many random bytes, there is an API `generate` - which can generate arbitrary many random bytes and it should be fine calling this as many times needed. +In case you just want to generate arbitrary many random bytes, there is an API `generate` - which can generate arbitrary many random bytes and it should be fine calling this as many times needed. Ratcheting is taken care of under the hood. -I maintain a few examples of using "RandomShake" API with various C++ STL distributions @ [examples](./examples) directory. You can run them all by `$ make example -j`. +I maintain a few examples of using "RandomSHAKE" API with various C++ STL distributions @ [examples](./examples) directory. You can run them all by `$ make example -j`. diff --git a/bench_result_on_Linux_6.11.0-18-generic_x86_64_with_g++_14.json b/bench_result_on_Linux_6.11.0-18-generic_x86_64_with_g++_14.json deleted file mode 100644 index 3891af1..0000000 --- a/bench_result_on_Linux_6.11.0-18-generic_x86_64_with_g++_14.json +++ /dev/null @@ -1,1332 +0,0 @@ -{ - "context": { - "date": "2025-03-04T20:56:45+04:00", - "host_name": "linux", - "executable": "./build/benchmark/perf.out", - "num_cpus": 16, - "mhz_per_cpu": 509, - "cpu_scaling_enabled": false, - "caches": [ - { - "type": "Data", - "level": 1, - "size": 49152, - "num_sharing": 2 - }, - { - "type": "Instruction", - "level": 1, - "size": 32768, - "num_sharing": 2 - }, - { - "type": "Unified", - "level": 2, - "size": 1310720, - "num_sharing": 2 - }, - { - "type": "Unified", - "level": 3, - "size": 18874368, - "num_sharing": 16 - } - ], - "load_avg": [0.541016,0.506836,0.561523], - "library_version": "v1.9.1-7-gf4f93b55", - "library_build_type": "release", - "json_schema_version": 1 - }, - "benchmarks": [ - { - "name": "deterministic_csprng/128b/create_mean", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8059104563251803e+03, - "cpu_time": 1.8056989347234817e+03, - "time_unit": "ns", - "CYCLES": 8.1874143761962323e+03 - }, - { - "name": "deterministic_csprng/128b/create_median", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8029848078227619e+03, - "cpu_time": 1.8027912889090373e+03, - "time_unit": "ns", - "CYCLES": 8.1864029162889092e+03 - }, - { - "name": "deterministic_csprng/128b/create_stddev", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.2275665894007631e+01, - "cpu_time": 1.2285957762388220e+01, - "time_unit": "ns", - "CYCLES": 5.3932593369511164e+00 - }, - { - "name": "deterministic_csprng/128b/create_cv", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 6.7974942229346164e-03, - "cpu_time": 6.8039901481526050e-03, - "time_unit": "ns", - "CYCLES": 6.5872558650888213e-04 - }, - { - "name": "deterministic_csprng/128b/create_min", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.7940502543230941e+03, - "cpu_time": 1.7938361665155633e+03, - "time_unit": "ns", - "CYCLES": 8.1813589704845372e+03 - }, - { - "name": "deterministic_csprng/128b/create_max", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8274467991295110e+03, - "cpu_time": 1.8272528709579924e+03, - "time_unit": "ns", - "CYCLES": 8.1997962501259190e+03 - }, - { - "name": "deterministic_csprng/192b/create_mean", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8116443330241850e+03, - "cpu_time": 1.8114156335023690e+03, - "time_unit": "ns", - "CYCLES": 8.1639592435525701e+03 - }, - { - "name": "deterministic_csprng/192b/create_median", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8115076257715561e+03, - "cpu_time": 1.8113355154751109e+03, - "time_unit": "ns", - "CYCLES": 8.1657514274400601e+03 - }, - { - "name": "deterministic_csprng/192b/create_stddev", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 8.9178853113431860e+00, - "cpu_time": 8.9517641718717620e+00, - "time_unit": "ns", - "CYCLES": 4.6269453708935639e+00 - }, - { - "name": "deterministic_csprng/192b/create_cv", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 4.9225364762720963e-03, - "cpu_time": 4.9418609436220557e-03, - "time_unit": "ns", - "CYCLES": 5.6675262980369011e-04 - }, - { - "name": "deterministic_csprng/192b/create_min", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.7995923461044745e+03, - "cpu_time": 1.7994699630845494e+03, - "time_unit": "ns", - "CYCLES": 8.1532212883365055e+03 - }, - { - "name": "deterministic_csprng/192b/create_max", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8248841187000228e+03, - "cpu_time": 1.8246807260464702e+03, - "time_unit": "ns", - "CYCLES": 8.1690756830635992e+03 - }, - { - "name": "deterministic_csprng/256b/create_mean", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8209101532135082e+03, - "cpu_time": 1.8206315163528238e+03, - "time_unit": "ns", - "CYCLES": 8.1542515308172406e+03 - }, - { - "name": "deterministic_csprng/256b/create_median", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8137362520917486e+03, - "cpu_time": 1.8135431655639793e+03, - "time_unit": "ns", - "CYCLES": 8.1531451396887478e+03 - }, - { - "name": "deterministic_csprng/256b/create_stddev", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.6398665391211274e+01, - "cpu_time": 1.6386564092692101e+01, - "time_unit": "ns", - "CYCLES": 8.4643671513516452e+00 - }, - { - "name": "deterministic_csprng/256b/create_cv", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 9.0057520752856550e-03, - "cpu_time": 9.0004835934722523e-03, - "time_unit": "ns", - "CYCLES": 1.0380311570427267e-03 - }, - { - "name": "deterministic_csprng/256b/create_min", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8057197519921945e+03, - "cpu_time": 1.8055501031259246e+03, - "time_unit": "ns", - "CYCLES": 8.1432217073366728e+03 - }, - { - "name": "deterministic_csprng/256b/create_max", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8503384806948009e+03, - "cpu_time": 1.8500808534004750e+03, - "time_unit": "ns", - "CYCLES": 8.1731556129965447e+03 - }, - { - "name": "non-deterministic_csprng/128b/create_mean", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.2188691601106211e+03, - "cpu_time": 7.2177488580708405e+03, - "time_unit": "ns", - "CYCLES": 3.3489795581791004e+04 - }, - { - "name": "non-deterministic_csprng/128b/create_median", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.2180991905141927e+03, - "cpu_time": 7.2170300046399088e+03, - "time_unit": "ns", - "CYCLES": 3.3617488761148634e+04 - }, - { - "name": "non-deterministic_csprng/128b/create_stddev", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.1090547026289852e+00, - "cpu_time": 2.0226463041855114e+00, - "time_unit": "ns", - "CYCLES": 2.9460424697761943e+02 - }, - { - "name": "non-deterministic_csprng/128b/create_cv", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 2.9215859933893942e-04, - "cpu_time": 2.8023229180713336e-04, - "time_unit": "ns", - "CYCLES": 8.7968362260712335e-03 - }, - { - "name": "non-deterministic_csprng/128b/create_min", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.2171846162022221e+03, - "cpu_time": 7.2166810331494680e+03, - "time_unit": "ns", - "CYCLES": 3.2802356601536318e+04 - }, - { - "name": "non-deterministic_csprng/128b/create_max", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.2244901272130419e+03, - "cpu_time": 7.2233876888178593e+03, - "time_unit": "ns", - "CYCLES": 3.3762997164509972e+04 - }, - { - "name": "non-deterministic_csprng/192b/create_mean", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.0827784912290648e+04, - "cpu_time": 1.0826332773954062e+04, - "time_unit": "ns", - "CYCLES": 5.0139861596164257e+04 - }, - { - "name": "non-deterministic_csprng/192b/create_median", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.0826930322625612e+04, - "cpu_time": 1.0825426339803589e+04, - "time_unit": "ns", - "CYCLES": 5.0076077333539550e+04 - }, - { - "name": "non-deterministic_csprng/192b/create_stddev", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.1941459987659657e+00, - "cpu_time": 2.3298547008610599e+00, - "time_unit": "ns", - "CYCLES": 3.9239622676172428e+02 - }, - { - "name": "non-deterministic_csprng/192b/create_cv", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 2.0264033840156767e-04, - "cpu_time": 2.1520257593284152e-04, - "time_unit": "ns", - "CYCLES": 7.8260333050409331e-03 - }, - { - "name": "non-deterministic_csprng/192b/create_min", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.0825881447843210e+04, - "cpu_time": 1.0824750676668458e+04, - "time_unit": "ns", - "CYCLES": 4.9427588894903718e+04 - }, - { - "name": "non-deterministic_csprng/192b/create_max", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.0833226587261011e+04, - "cpu_time": 1.0832327662207113e+04, - "time_unit": "ns", - "CYCLES": 5.0620570876189006e+04 - }, - { - "name": "non-deterministic_csprng/256b/create_mean", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.4436156552299886e+04, - "cpu_time": 1.4434296504794256e+04, - "time_unit": "ns", - "CYCLES": 6.7212195164449950e+04 - }, - { - "name": "non-deterministic_csprng/256b/create_median", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.4436148159742716e+04, - "cpu_time": 1.4434415919166902e+04, - "time_unit": "ns", - "CYCLES": 6.7349715228374058e+04 - }, - { - "name": "non-deterministic_csprng/256b/create_stddev", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.5719071733066967e-01, - "cpu_time": 8.6998553587771765e-01, - "time_unit": "ns", - "CYCLES": 2.7208319720760915e+02 - }, - { - "name": "non-deterministic_csprng/256b/create_cv", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 5.2450990995247845e-05, - "cpu_time": 6.0272112020752627e-05, - "time_unit": "ns", - "CYCLES": 4.0481224656016010e-03 - }, - { - "name": "non-deterministic_csprng/256b/create_min", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.4435090628110256e+04, - "cpu_time": 1.4432335601608331e+04, - "time_unit": "ns", - "CYCLES": 6.6764590163934423e+04 - }, - { - "name": "non-deterministic_csprng/256b/create_max", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.4437539540352096e+04, - "cpu_time": 1.4435197855448947e+04, - "time_unit": "ns", - "CYCLES": 6.7491886070728942e+04 - }, - { - "name": "csprng/256b/generate_u8_mean", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.0818082872092480e+00, - "cpu_time": 2.0814919032975689e+00, - "time_unit": "ns", - "CYCLES": 9.4314591086605848e+00, - "bytes_per_second": 4.8047108420786095e+08 - }, - { - "name": "csprng/256b/generate_u8_median", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.0877394946173036e+00, - "cpu_time": 2.0874467549669511e+00, - "time_unit": "ns", - "CYCLES": 9.4350094243846421e+00, - "bytes_per_second": 4.7905481691902578e+08 - }, - { - "name": "csprng/256b/generate_u8_stddev", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.1660188844520610e-02, - "cpu_time": 2.1591940337885661e-02, - "time_unit": "ns", - "CYCLES": 2.4644024897285035e-02, - "bytes_per_second": 4.9749528178720791e+06 - }, - { - "name": "csprng/256b/generate_u8_cv", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 1.0404506974826684e-02, - "cpu_time": 1.0373300181316578e-02, - "time_unit": "ns", - "CYCLES": 2.6129599474863092e-03, - "bytes_per_second": 1.0354323041258856e-02 - }, - { - "name": "csprng/256b/generate_u8_min", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.0507757434697731e+00, - "cpu_time": 2.0506328421138367e+00, - "time_unit": "ns", - "CYCLES": 9.3985265401455695e+00, - "bytes_per_second": 4.7144462784502310e+08 - }, - { - "name": "csprng/256b/generate_u8_max", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.1212848824154524e+00, - "cpu_time": 2.1211398771707453e+00, - "time_unit": "ns", - "CYCLES": 9.4742492620452676e+00, - "bytes_per_second": 4.8765433746256512e+08 - }, - { - "name": "csprng/256b/generate_u16_mean", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 3.8426160090152286e+00, - "cpu_time": 3.8421128371451623e+00, - "time_unit": "ns", - "CYCLES": 1.7202513565970769e+01, - "bytes_per_second": 5.2081180104220486e+08 - }, - { - "name": "csprng/256b/generate_u16_median", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 3.8038613783336457e+00, - "cpu_time": 3.8034767853847646e+00, - "time_unit": "ns", - "CYCLES": 1.7197365828756602e+01, - "bytes_per_second": 5.2583481840507627e+08 - }, - { - "name": "csprng/256b/generate_u16_stddev", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 9.2852935781024534e-02, - "cpu_time": 9.2921508806361006e-02, - "time_unit": "ns", - "CYCLES": 3.8811974106102404e-02, - "bytes_per_second": 1.2172130439289400e+07 - }, - { - "name": "csprng/256b/generate_u16_cv", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 2.4163990251219646e-02, - "cpu_time": 2.4185002561092211e-02, - "time_unit": "ns", - "CYCLES": 2.2561804097558447e-03, - "bytes_per_second": 2.3371456666172991e-02 - }, - { - "name": "csprng/256b/generate_u16_min", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 3.7661186556835893e+00, - "cpu_time": 3.7652281101110403e+00, - "time_unit": "ns", - "CYCLES": 1.7138097755153677e+01, - "bytes_per_second": 4.9190192152377832e+08 - }, - { - "name": "csprng/256b/generate_u16_max", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 4.0662753932367499e+00, - "cpu_time": 4.0658511635907910e+00, - "time_unit": "ns", - "CYCLES": 1.7264360862198686e+01, - "bytes_per_second": 5.3117631694856805e+08 - }, - { - "name": "csprng/256b/generate_u32_mean", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.2977771215157308e+00, - "cpu_time": 7.2966435325669750e+00, - "time_unit": "ns", - "CYCLES": 3.1845609131385046e+01, - "bytes_per_second": 5.4871118710555995e+08 - }, - { - "name": "csprng/256b/generate_u32_median", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.2180278727144209e+00, - "cpu_time": 7.2170304804712710e+00, - "time_unit": "ns", - "CYCLES": 3.2397490271024850e+01, - "bytes_per_second": 5.5425518315866637e+08 - }, - { - "name": "csprng/256b/generate_u32_stddev", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.4234651182196387e-01, - "cpu_time": 2.4193401487526628e-01, - "time_unit": "ns", - "CYCLES": 1.7284009488660561e+00, - "bytes_per_second": 1.7231595529543851e+07 - }, - { - "name": "csprng/256b/generate_u32_cv", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 3.3208264350450468e-02, - "cpu_time": 3.3156891082241666e-02, - "time_unit": "ns", - "CYCLES": 5.4274388087073890e-02, - "bytes_per_second": 3.1403762005364162e-02 - }, - { - "name": "csprng/256b/generate_u32_min", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.0968189260132162e+00, - "cpu_time": 7.0963273811410827e+00, - "time_unit": "ns", - "CYCLES": 2.6930412308567711e+01, - "bytes_per_second": 5.0518356101892817e+08 - }, - { - "name": "csprng/256b/generate_u32_max", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.9201919690412250e+00, - "cpu_time": 7.9179140190789541e+00, - "time_unit": "ns", - "CYCLES": 3.2499099556001553e+01, - "bytes_per_second": 5.6367185237679994e+08 - }, - { - "name": "csprng/256b/generate_u64_mean", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.4408040007531289e+01, - "cpu_time": 1.4405669025200433e+01, - "time_unit": "ns", - "CYCLES": 6.2889426430634117e+01, - "bytes_per_second": 5.5536983154464197e+08 - }, - { - "name": "csprng/256b/generate_u64_median", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.4435585011702013e+01, - "cpu_time": 1.4433146869570905e+01, - "time_unit": "ns", - "CYCLES": 6.2893435914643518e+01, - "bytes_per_second": 5.5427978851247215e+08 - }, - { - "name": "csprng/256b/generate_u64_stddev", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.1635356693333536e-01, - "cpu_time": 1.1637270054817614e-01, - "time_unit": "ns", - "CYCLES": 1.1700089508937707e-01, - "bytes_per_second": 4.5256876745578060e+06 - }, - { - "name": "csprng/256b/generate_u64_cv", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 8.0755999339615706e-03, - "cpu_time": 8.0782572711201785e-03, - "time_unit": "ns", - "CYCLES": 1.8604223592089350e-03, - "bytes_per_second": 8.1489620384502647e-03 - }, - { - "name": "csprng/256b/generate_u64_min", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.4143180241995410e+01, - "cpu_time": 1.4142229454221200e+01, - "time_unit": "ns", - "CYCLES": 6.2638881089062565e+01, - "bytes_per_second": 5.5027268497789872e+08 - }, - { - "name": "csprng/256b/generate_u64_max", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.4540098650924776e+01, - "cpu_time": 1.4538246615532648e+01, - "time_unit": "ns", - "CYCLES": 6.3070960791966733e+01, - "bytes_per_second": 5.6568167175452971e+08 - }, - { - "name": "csprng/128b/generate_byte_seq_mean", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8218316526288521e+06, - "cpu_time": 1.8215148592105333e+06, - "time_unit": "ns", - "CYCLES": 7.9139269381578937e+06, - "bytes_per_second": 5.7567217065976262e+08 - }, - { - "name": "csprng/128b/generate_byte_seq_median", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8244756447290308e+06, - "cpu_time": 1.8241829868421243e+06, - "time_unit": "ns", - "CYCLES": 7.9155995460526310e+06, - "bytes_per_second": 5.7481958704832959e+08 - }, - { - "name": "csprng/128b/generate_byte_seq_stddev", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 8.2830638847866303e+03, - "cpu_time": 8.2538572082637584e+03, - "time_unit": "ns", - "CYCLES": 7.4828176847676987e+03, - "bytes_per_second": 2.6133260330646336e+06 - }, - { - "name": "csprng/128b/generate_byte_seq_cv", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 4.5465583347585386e-03, - "cpu_time": 4.5313147825986333e-03, - "time_unit": "ns", - "CYCLES": 9.4552524217635201e-04, - "bytes_per_second": 4.5396080725416512e-03 - }, - { - "name": "csprng/128b/generate_byte_seq_min", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8077201184496514e+06, - "cpu_time": 1.8074740921052783e+06, - "time_unit": "ns", - "CYCLES": 7.9039168552631577e+06, - "bytes_per_second": 5.7245706039182150e+08 - }, - { - "name": "csprng/128b/generate_byte_seq_max", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8320225131231523e+06, - "cpu_time": 1.8317111842105608e+06, - "time_unit": "ns", - "CYCLES": 7.9250183552631577e+06, - "bytes_per_second": 5.8013334994951868e+08 - }, - { - "name": "csprng/192b/generate_byte_seq_mean", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8375808802614447e+06, - "cpu_time": 1.8372175605263193e+06, - "time_unit": "ns", - "CYCLES": 7.9389463684210526e+06, - "bytes_per_second": 5.7076539784862626e+08 - }, - { - "name": "csprng/192b/generate_byte_seq_median", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8371937829119577e+06, - "cpu_time": 1.8370134736841985e+06, - "time_unit": "ns", - "CYCLES": 7.9400393223684207e+06, - "bytes_per_second": 5.7080500421388459e+08 - }, - { - "name": "csprng/192b/generate_byte_seq_stddev", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.2613458991671367e+04, - "cpu_time": 1.2581250891531819e+04, - "time_unit": "ns", - "CYCLES": 1.0326023627207755e+04, - "bytes_per_second": 3.9046898469290887e+06 - }, - { - "name": "csprng/192b/generate_byte_seq_cv", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 6.8641653421408957e-03, - "cpu_time": 6.8479918556447880e-03, - "time_unit": "ns", - "CYCLES": 1.3006793531547007e-03, - "bytes_per_second": 6.8411467507437417e-03 - }, - { - "name": "csprng/192b/generate_byte_seq_min", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8180115657742135e+06, - "cpu_time": 1.8178280526316133e+06, - "time_unit": "ns", - "CYCLES": 7.9239502105263155e+06, - "bytes_per_second": 5.6404606329676342e+08 - }, - { - "name": "csprng/192b/generate_byte_seq_max", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8596546973353005e+06, - "cpu_time": 1.8590254736842462e+06, - "time_unit": "ns", - "CYCLES": 7.9588578157894732e+06, - "bytes_per_second": 5.7682903423236811e+08 - }, - { - "name": "csprng/256b/generate_byte_seq_mean", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8420636328827594e+06, - "cpu_time": 1.8415552552631558e+06, - "time_unit": "ns", - "CYCLES": 7.9901252644736841e+06, - "bytes_per_second": 5.6940491375554812e+08 - }, - { - "name": "csprng/256b/generate_byte_seq_median", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8421682302447916e+06, - "cpu_time": 1.8417420789473839e+06, - "time_unit": "ns", - "CYCLES": 7.9912560000000000e+06, - "bytes_per_second": 5.6933925312653434e+08 - }, - { - "name": "csprng/256b/generate_byte_seq_stddev", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.2563263238752606e+03, - "cpu_time": 7.2449207511539089e+03, - "time_unit": "ns", - "CYCLES": 1.0275224315779356e+04, - "bytes_per_second": 2.2408604189720419e+06 - }, - { - "name": "csprng/256b/generate_byte_seq_cv", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 3.9392375997996257e-03, - "cpu_time": 3.9341316153549896e-03, - "time_unit": "ns", - "CYCLES": 1.2859903913479125e-03, - "bytes_per_second": 3.9354427136785624e-03 - }, - { - "name": "csprng/256b/generate_byte_seq_min", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8313713026145704e+06, - "cpu_time": 1.8312437368420758e+06, - "time_unit": "ns", - "CYCLES": 7.9740177763157897e+06, - "bytes_per_second": 5.6623835326636422e+08 - }, - { - "name": "csprng/256b/generate_byte_seq_max", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8520741184003879e+06, - "cpu_time": 1.8518279342104886e+06, - "time_unit": "ns", - "CYCLES": 8.0060963552631577e+06, - "bytes_per_second": 5.7260318706030774e+08 - } - ] -} diff --git a/bench_result_on_Linux_6.14.0-1015-aws_aarch64_with_g++_13.json b/bench_result_on_Linux_6.14.0-1015-aws_aarch64_with_g++_13.json new file mode 100644 index 0000000..019c0d5 --- /dev/null +++ b/bench_result_on_Linux_6.14.0-1015-aws_aarch64_with_g++_13.json @@ -0,0 +1,799 @@ +{ + "context": { + "date": "2025-11-17T06:50:05+00:00", + "host_name": "ip-172-31-34-105", + "executable": "./build/benchmark/bench.out", + "num_cpus": 2, + "mhz_per_cpu": 2000, + "cpu_scaling_enabled": false, + "aslr_enabled": false, + "caches": [ + { + "type": "Data", + "level": 1, + "size": 65536, + "num_sharing": 1 + }, + { + "type": "Instruction", + "level": 1, + "size": 65536, + "num_sharing": 1 + }, + { + "type": "Unified", + "level": 2, + "size": 2097152, + "num_sharing": 1 + }, + { + "type": "Unified", + "level": 3, + "size": 37748736, + "num_sharing": 2 + } + ], + "load_avg": [0.51416,0.185059,0.0673828], + "library_version": "v1.9.4-67-g57d14f70", + "library_build_type": "release", + "json_schema_version": 1 + }, + "benchmarks": [ + { + "name": "deterministic_csprng/create_mean", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.8308370072772973e+03, + "cpu_time": 1.8297339003645200e+03, + "time_unit": "ns" + }, + { + "name": "deterministic_csprng/create_median", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.8298744496268287e+03, + "cpu_time": 1.8297256888644999e+03, + "time_unit": "ns" + }, + { + "name": "deterministic_csprng/create_stddev", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.7532718043504611e+00, + "cpu_time": 2.8499977699825835e-01, + "time_unit": "ns" + }, + { + "name": "deterministic_csprng/create_cv", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 1.5038322873126479e-03, + "cpu_time": 1.5576023209794640e-04, + "time_unit": "ns" + }, + { + "name": "deterministic_csprng/create_min", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.8293363252720762e+03, + "cpu_time": 1.8293911861926597e+03, + "time_unit": "ns" + }, + { + "name": "deterministic_csprng/create_max", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.8384886267130962e+03, + "cpu_time": 1.8303470910254910e+03, + "time_unit": "ns" + }, + { + "name": "non-deterministic_csprng/create_mean", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.1490077996554202e+04, + "cpu_time": 1.1489096956272053e+04, + "time_unit": "ns" + }, + { + "name": "non-deterministic_csprng/create_median", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.1488304783001036e+04, + "cpu_time": 1.1488342932151932e+04, + "time_unit": "ns" + }, + { + "name": "non-deterministic_csprng/create_stddev", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 4.6208812384250386e+00, + "cpu_time": 2.1965007458232804e+00, + "time_unit": "ns" + }, + { + "name": "non-deterministic_csprng/create_cv", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 4.0216273900062390e-04, + "cpu_time": 1.9118132209896454e-04, + "time_unit": "ns" + }, + { + "name": "non-deterministic_csprng/create_min", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.1485962343097091e+04, + "cpu_time": 1.1486368693083939e+04, + "time_unit": "ns" + }, + { + "name": "non-deterministic_csprng/create_max", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.1501102387399291e+04, + "cpu_time": 1.1492788005578785e+04, + "time_unit": "ns" + }, + { + "name": "csprng/generate_u8_mean", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 4.7038532091292478e+00, + "cpu_time": 4.7036147365309287e+00, + "time_unit": "ns", + "bytes_per_second": 2.1260244975921059e+08 + }, + { + "name": "csprng/generate_u8_median", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 4.7033764554122142e+00, + "cpu_time": 4.7034623860361027e+00, + "time_unit": "ns", + "bytes_per_second": 2.1260933331157726e+08 + }, + { + "name": "csprng/generate_u8_stddev", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.5122572142070125e-03, + "cpu_time": 6.2146821832476519e-04, + "time_unit": "ns", + "bytes_per_second": 2.8087606743289096e+04 + }, + { + "name": "csprng/generate_u8_cv", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 3.2149328369176583e-04, + "cpu_time": 1.3212566358764295e-04, + "time_unit": "ns", + "bytes_per_second": 1.3211327891612056e-04 + }, + { + "name": "csprng/generate_u8_min", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 4.7027975154696664e+00, + "cpu_time": 4.7029642705974855e+00, + "time_unit": "ns", + "bytes_per_second": 2.1254827822342691e+08 + }, + { + "name": "csprng/generate_u8_max", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 4.7079470710350870e+00, + "cpu_time": 4.7048134586572283e+00, + "time_unit": "ns", + "bytes_per_second": 2.1263185141590616e+08 + }, + { + "name": "csprng/generate_u16_mean", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 6.8513121419945717e+00, + "cpu_time": 6.8504448692548916e+00, + "time_unit": "ns", + "bytes_per_second": 2.9195196762413114e+08 + }, + { + "name": "csprng/generate_u16_median", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 6.8494449906914712e+00, + "cpu_time": 6.8493880672876344e+00, + "time_unit": "ns", + "bytes_per_second": 2.9199688832359111e+08 + }, + { + "name": "csprng/generate_u16_stddev", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 6.4740680401004962e-03, + "cpu_time": 4.7319061327954891e-03, + "time_unit": "ns", + "bytes_per_second": 2.0162882935381689e+05 + }, + { + "name": "csprng/generate_u16_cv", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 9.4493841558001895e-04, + "cpu_time": 6.9074435647712438e-04, + "time_unit": "ns", + "bytes_per_second": 6.9062329325829614e-04 + }, + { + "name": "csprng/generate_u16_min", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 6.8426326670322037e+00, + "cpu_time": 6.8427981243922051e+00, + "time_unit": "ns", + "bytes_per_second": 2.9160470014314002e+08 + }, + { + "name": "csprng/generate_u16_max", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 6.8637566116831383e+00, + "cpu_time": 6.8586000123395126e+00, + "time_unit": "ns", + "bytes_per_second": 2.9227809496099156e+08 + }, + { + "name": "csprng/generate_u32_mean", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 9.8291725928107816e+00, + "cpu_time": 9.8279809420539976e+00, + "time_unit": "ns", + "bytes_per_second": 4.0700240930150145e+08 + }, + { + "name": "csprng/generate_u32_median", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 9.8246389613509013e+00, + "cpu_time": 9.8244160257414030e+00, + "time_unit": "ns", + "bytes_per_second": 4.0714888495023894e+08 + }, + { + "name": "csprng/generate_u32_stddev", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.6472775819674046e-02, + "cpu_time": 1.7892327879018448e-02, + "time_unit": "ns", + "bytes_per_second": 7.4035499096731783e+05 + }, + { + "name": "csprng/generate_u32_cv", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 1.6759066609251018e-03, + "cpu_time": 1.8205497125515430e-03, + "time_unit": "ns", + "bytes_per_second": 1.8190432637436151e-03 + }, + { + "name": "csprng/generate_u32_min", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 9.8083090155274490e+00, + "cpu_time": 9.8032911070908586e+00, + "time_unit": "ns", + "bytes_per_second": 4.0559074013270235e+08 + }, + { + "name": "csprng/generate_u32_max", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 9.8622299980655619e+00, + "cpu_time": 9.8621580923944876e+00, + "time_unit": "ns", + "bytes_per_second": 4.0802623897465867e+08 + }, + { + "name": "csprng/generate_u64_mean", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.5523688682980630e+01, + "cpu_time": 1.5522816166103373e+01, + "time_unit": "ns", + "bytes_per_second": 5.1537115771340823e+08 + }, + { + "name": "csprng/generate_u64_median", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.5523143810343040e+01, + "cpu_time": 1.5523270756964411e+01, + "time_unit": "ns", + "bytes_per_second": 5.1535531074204367e+08 + }, + { + "name": "csprng/generate_u64_stddev", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.8548479636726754e-02, + "cpu_time": 1.9828549460083722e-02, + "time_unit": "ns", + "bytes_per_second": 6.5777833306326962e+05 + }, + { + "name": "csprng/generate_u64_cv", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 1.1948500137768383e-03, + "cpu_time": 1.2773809370610614e-03, + "time_unit": "ns", + "bytes_per_second": 1.2763196450140742e-03 + }, + { + "name": "csprng/generate_u64_min", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.5498520600665241e+01, + "cpu_time": 1.5497031721909611e+01, + "time_unit": "ns", + "bytes_per_second": 5.1399853894716531e+08 + }, + { + "name": "csprng/generate_u64_max", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.5564167858247520e+01, + "cpu_time": 1.5564246576238483e+01, + "time_unit": "ns", + "bytes_per_second": 5.1622789083471042e+08 + }, + { + "name": "csprng/shake256/generate_byte_seq_mean", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.8192102980000298e+06, + "cpu_time": 2.8189390500000119e+06, + "time_unit": "ns", + "bytes_per_second": 3.7197542881732970e+08 + }, + { + "name": "csprng/shake256/generate_byte_seq_median", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.8187256500001466e+06, + "cpu_time": 2.8188244300000244e+06, + "time_unit": "ns", + "bytes_per_second": 3.7199053225382805e+08 + }, + { + "name": "csprng/shake256/generate_byte_seq_stddev", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.1937372776634816e+03, + "cpu_time": 7.2219593690043951e+02, + "time_unit": "ns", + "bytes_per_second": 9.5286040976518241e+04 + }, + { + "name": "csprng/shake256/generate_byte_seq_cv", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 4.2342966699232337e-04, + "cpu_time": 2.5619423623239975e-04, + "time_unit": "ns", + "bytes_per_second": 2.5616219135622388e-04 + }, + { + "name": "csprng/shake256/generate_byte_seq_min", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.8177912400002470e+06, + "cpu_time": 2.8178958799999873e+06, + "time_unit": "ns", + "bytes_per_second": 3.7180073322229195e+08 + }, + { + "name": "csprng/shake256/generate_byte_seq_max", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.8217171000000010e+06, + "cpu_time": 2.8202634000000162e+06, + "time_unit": "ns", + "bytes_per_second": 3.7211311015508658e+08 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_mean", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.5691134955055874e+06, + "cpu_time": 1.5690102134831441e+06, + "time_unit": "ns", + "bytes_per_second": 6.6830424450454044e+08 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_median", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.5691551123594625e+06, + "cpu_time": 1.5686539157303346e+06, + "time_unit": "ns", + "bytes_per_second": 6.6845592259645784e+08 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_stddev", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 7.1785017519686312e+02, + "cpu_time": 6.9537024778318073e+02, + "time_unit": "ns", + "bytes_per_second": 2.9615200471678388e+05 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_cv", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 4.5748773256555484e-04, + "cpu_time": 4.4319038958929696e-04, + "time_unit": "ns", + "bytes_per_second": 4.4313949395359829e-04 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_min", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.5682611573033249e+06, + "cpu_time": 1.5682082022471742e+06, + "time_unit": "ns", + "bytes_per_second": 6.6795057278515363e+08 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_max", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.5699082808988334e+06, + "cpu_time": 1.5698407078651828e+06, + "time_unit": "ns", + "bytes_per_second": 6.6864590970601737e+08 + } + ] +} diff --git a/bench_result_on_Linux_6.14.0-1015-aws_x86_64_with_g++_13.json b/bench_result_on_Linux_6.14.0-1015-aws_x86_64_with_g++_13.json new file mode 100644 index 0000000..f677bad --- /dev/null +++ b/bench_result_on_Linux_6.14.0-1015-aws_x86_64_with_g++_13.json @@ -0,0 +1,799 @@ +{ + "context": { + "date": "2025-11-17T06:34:00+00:00", + "host_name": "ip-172-31-45-14", + "executable": "./build/benchmark/bench.out", + "num_cpus": 2, + "mhz_per_cpu": 3311, + "cpu_scaling_enabled": false, + "aslr_enabled": false, + "caches": [ + { + "type": "Data", + "level": 1, + "size": 49152, + "num_sharing": 2 + }, + { + "type": "Instruction", + "level": 1, + "size": 32768, + "num_sharing": 2 + }, + { + "type": "Unified", + "level": 2, + "size": 2097152, + "num_sharing": 2 + }, + { + "type": "Unified", + "level": 3, + "size": 110100480, + "num_sharing": 2 + } + ], + "load_avg": [0.663574,0.252441,0.0942383], + "library_version": "v1.9.4-67-g57d14f70", + "library_build_type": "release", + "json_schema_version": 1 + }, + "benchmarks": [ + { + "name": "deterministic_csprng/create_mean", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.6325025833314055e+03, + "cpu_time": 1.6322808017074481e+03, + "time_unit": "ns" + }, + { + "name": "deterministic_csprng/create_median", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.6325887196472099e+03, + "cpu_time": 1.6323178897156586e+03, + "time_unit": "ns" + }, + { + "name": "deterministic_csprng/create_stddev", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.3792995323363311e+00, + "cpu_time": 2.4631916384597305e+00, + "time_unit": "ns" + }, + { + "name": "deterministic_csprng/create_cv", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 1.4574552938721582e-03, + "cpu_time": 1.5090489552306858e-03, + "time_unit": "ns" + }, + { + "name": "deterministic_csprng/create_min", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.6283294184881547e+03, + "cpu_time": 1.6283346901168611e+03, + "time_unit": "ns" + }, + { + "name": "deterministic_csprng/create_max", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.6374391430104338e+03, + "cpu_time": 1.6374449161437785e+03, + "time_unit": "ns" + }, + { + "name": "non-deterministic_csprng/create_mean", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 3.0342735134549403e+04, + "cpu_time": 3.0342116514756963e+04, + "time_unit": "ns" + }, + { + "name": "non-deterministic_csprng/create_median", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 3.0342755316841045e+04, + "cpu_time": 3.0342230034722266e+04, + "time_unit": "ns" + }, + { + "name": "non-deterministic_csprng/create_stddev", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.7512122646476861e+01, + "cpu_time": 1.6901472905090461e+01, + "time_unit": "ns" + }, + { + "name": "non-deterministic_csprng/create_cv", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 5.7714383917015070e-04, + "cpu_time": 5.5703012335577809e-04, + "time_unit": "ns" + }, + { + "name": "non-deterministic_csprng/create_min", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 3.0310949869802629e+04, + "cpu_time": 3.0311052517361095e+04, + "time_unit": "ns" + }, + { + "name": "non-deterministic_csprng/create_max", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 3.0374451171877317e+04, + "cpu_time": 3.0371572482638941e+04, + "time_unit": "ns" + }, + { + "name": "csprng/generate_u8_mean", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 3.0242631769328057e+00, + "cpu_time": 3.0239700613035305e+00, + "time_unit": "ns", + "bytes_per_second": 3.3069274007015216e+08 + }, + { + "name": "csprng/generate_u8_median", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 3.0238147112720450e+00, + "cpu_time": 3.0238270048332132e+00, + "time_unit": "ns", + "bytes_per_second": 3.3070675056584257e+08 + }, + { + "name": "csprng/generate_u8_stddev", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 6.9831164411734590e-03, + "cpu_time": 7.0900003028323208e-03, + "time_unit": "ns", + "bytes_per_second": 7.7503356193995452e+05 + }, + { + "name": "csprng/generate_u8_cv", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 2.3090306737972802e-03, + "cpu_time": 2.3446000321101271e-03, + "time_unit": "ns", + "bytes_per_second": 2.3436666972959288e-03 + }, + { + "name": "csprng/generate_u8_min", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 3.0112197796690197e+00, + "cpu_time": 3.0111876804139404e+00, + "time_unit": "ns", + "bytes_per_second": 3.2918012913265944e+08 + }, + { + "name": "csprng/generate_u8_max", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 3.0378391714215547e+00, + "cpu_time": 3.0378504396205535e+00, + "time_unit": "ns", + "bytes_per_second": 3.3209487621925062e+08 + }, + { + "name": "csprng/generate_u16_mean", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 9.1480521214934356e+00, + "cpu_time": 9.1476254839908737e+00, + "time_unit": "ns", + "bytes_per_second": 2.1863672626038826e+08 + }, + { + "name": "csprng/generate_u16_median", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 9.1460421206662321e+00, + "cpu_time": 9.1460743165189520e+00, + "time_unit": "ns", + "bytes_per_second": 2.1867305398202509e+08 + }, + { + "name": "csprng/generate_u16_stddev", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.7878796638203586e-02, + "cpu_time": 1.7919594251746093e-02, + "time_unit": "ns", + "bytes_per_second": 4.2714858702277776e+05 + }, + { + "name": "csprng/generate_u16_cv", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 1.9543829003987839e-03, + "cpu_time": 1.9589339641316659e-03, + "time_unit": "ns", + "bytes_per_second": 1.9536909206830126e-03 + }, + { + "name": "csprng/generate_u16_min", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 9.1261085446931212e+00, + "cpu_time": 9.1260020959304935e+00, + "time_unit": "ns", + "bytes_per_second": 2.1758893756634679e+08 + }, + { + "name": "csprng/generate_u16_max", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 9.1923176514689544e+00, + "cpu_time": 9.1916437589579392e+00, + "time_unit": "ns", + "bytes_per_second": 2.1915401497571963e+08 + }, + { + "name": "csprng/generate_u32_mean", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.2119091166775611e+01, + "cpu_time": 1.2118892247532990e+01, + "time_unit": "ns", + "bytes_per_second": 3.3006596152925724e+08 + }, + { + "name": "csprng/generate_u32_median", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.2107094639186530e+01, + "cpu_time": 1.2107032668956517e+01, + "time_unit": "ns", + "bytes_per_second": 3.3038652938630384e+08 + }, + { + "name": "csprng/generate_u32_stddev", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 3.7028150030177391e-02, + "cpu_time": 3.7174024077167425e-02, + "time_unit": "ns", + "bytes_per_second": 1.0109358154809939e+06 + }, + { + "name": "csprng/generate_u32_cv", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 3.0553570000108397e-03, + "cpu_time": 3.0674440631927261e-03, + "time_unit": "ns", + "bytes_per_second": 3.0628296562212579e-03 + }, + { + "name": "csprng/generate_u32_min", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.2067865882922874e+01, + "cpu_time": 1.2067906302052078e+01, + "time_unit": "ns", + "bytes_per_second": 3.2816979465498835e+08 + }, + { + "name": "csprng/generate_u32_max", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.2188770059725076e+01, + "cpu_time": 1.2188812209866182e+01, + "time_unit": "ns", + "bytes_per_second": 3.3145766132770050e+08 + }, + { + "name": "csprng/generate_u64_mean", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.2973776985903456e+01, + "cpu_time": 1.2973427242982359e+01, + "time_unit": "ns", + "bytes_per_second": 6.1664823228353846e+08 + }, + { + "name": "csprng/generate_u64_median", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.2964244530225358e+01, + "cpu_time": 1.2964289832028758e+01, + "time_unit": "ns", + "bytes_per_second": 6.1707988073513746e+08 + }, + { + "name": "csprng/generate_u64_stddev", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 3.1100010050130595e-02, + "cpu_time": 3.0967572803258285e-02, + "time_unit": "ns", + "bytes_per_second": 1.4702158889692961e+06 + }, + { + "name": "csprng/generate_u64_cv", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 2.3971438759832269e-03, + "cpu_time": 2.3870001521771665e-03, + "time_unit": "ns", + "bytes_per_second": 2.3842051464655497e-03 + }, + { + "name": "csprng/generate_u64_min", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.2934900565323208e+01, + "cpu_time": 1.2934944381824243e+01, + "time_unit": "ns", + "bytes_per_second": 6.1407922769042230e+08 + }, + { + "name": "csprng/generate_u64_max", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.3027589633980245e+01, + "cpu_time": 1.3027634935785622e+01, + "time_unit": "ns", + "bytes_per_second": 6.1847965973795259e+08 + }, + { + "name": "csprng/shake256/generate_byte_seq_mean", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.4996820339285573e+06, + "cpu_time": 2.4995874339285744e+06, + "time_unit": "ns", + "bytes_per_second": 4.1950094863019615e+08 + }, + { + "name": "csprng/shake256/generate_byte_seq_median", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.4993128035712326e+06, + "cpu_time": 2.4992963928571441e+06, + "time_unit": "ns", + "bytes_per_second": 4.1954848208902156e+08 + }, + { + "name": "csprng/shake256/generate_byte_seq_stddev", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 4.6184420537757978e+03, + "cpu_time": 4.6720520880949171e+03, + "time_unit": "ns", + "bytes_per_second": 7.8474367755762569e+05 + }, + { + "name": "csprng/shake256/generate_byte_seq_cv", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 1.8476118126581681e-03, + "cpu_time": 1.8691292909693913e-03, + "time_unit": "ns", + "bytes_per_second": 1.8706600786483631e-03 + }, + { + "name": "csprng/shake256/generate_byte_seq_min", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.4899816249990589e+06, + "cpu_time": 2.4899515357142808e+06, + "time_unit": "ns", + "bytes_per_second": 4.1834741806246805e+08 + }, + { + "name": "csprng/shake256/generate_byte_seq_max", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.5064589642848237e+06, + "cpu_time": 2.5064717857142976e+06, + "time_unit": "ns", + "bytes_per_second": 4.2112305599522442e+08 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_mean", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.3914605683167470e+06, + "cpu_time": 1.3914332683168291e+06, + "time_unit": "ns", + "bytes_per_second": 7.5359587171897662e+08 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_median", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.3910614653465280e+06, + "cpu_time": 1.3910688861386145e+06, + "time_unit": "ns", + "bytes_per_second": 7.5379157129591870e+08 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_stddev", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.1937760952030453e+03, + "cpu_time": 2.2047796703576910e+03, + "time_unit": "ns", + "bytes_per_second": 1.1927511148191069e+06 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_cv", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 1.5765995423476940e-03, + "cpu_time": 1.5845385621868450e-03, + "time_unit": "ns", + "bytes_per_second": 1.5827463493110743e-03 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_min", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.3890013663367743e+06, + "cpu_time": 1.3890068613861357e+06, + "time_unit": "ns", + "bytes_per_second": 7.5156760657170045e+08 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_max", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.3951770792076974e+06, + "cpu_time": 1.3951851980197933e+06, + "time_unit": "ns", + "bytes_per_second": 7.5491059774434185e+08 + } + ] +} diff --git a/bench_result_on_Linux_6.17.0-6-generic_x86_64_with_g++_15.json b/bench_result_on_Linux_6.17.0-6-generic_x86_64_with_g++_15.json new file mode 100644 index 0000000..461c656 --- /dev/null +++ b/bench_result_on_Linux_6.17.0-6-generic_x86_64_with_g++_15.json @@ -0,0 +1,846 @@ +{ + "context": { + "date": "2025-11-17T12:27:07+05:30", + "host_name": "linux", + "executable": "./build/benchmark/perf.out", + "num_cpus": 16, + "mhz_per_cpu": 844, + "cpu_scaling_enabled": false, + "caches": [ + { + "type": "Data", + "level": 1, + "size": 49152, + "num_sharing": 2 + }, + { + "type": "Instruction", + "level": 1, + "size": 32768, + "num_sharing": 2 + }, + { + "type": "Unified", + "level": 2, + "size": 1310720, + "num_sharing": 2 + }, + { + "type": "Unified", + "level": 3, + "size": 18874368, + "num_sharing": 16 + } + ], + "load_avg": [0.458496,0.442871,0.483887], + "library_version": "v1.9.1-7-gf4f93b55", + "library_build_type": "release", + "json_schema_version": 1 + }, + "benchmarks": [ + { + "name": "deterministic_csprng/create_mean", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.1016915300454089e+03, + "cpu_time": 1.1015112261672480e+03, + "time_unit": "ns", + "CYCLES": 4.7982822420070979e+03 + }, + { + "name": "deterministic_csprng/create_median", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.0993656877416031e+03, + "cpu_time": 1.0992525426723412e+03, + "time_unit": "ns", + "CYCLES": 4.7975388314461743e+03 + }, + { + "name": "deterministic_csprng/create_stddev", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 4.8028075619133670e+00, + "cpu_time": 4.8386224827757740e+00, + "time_unit": "ns", + "CYCLES": 2.8565375897318406e+00 + }, + { + "name": "deterministic_csprng/create_cv", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 4.3594848747865109e-03, + "cpu_time": 4.3927128183813011e-03, + "time_unit": "ns", + "CYCLES": 5.9532504460116235e-04 + }, + { + "name": "deterministic_csprng/create_min", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.0961288082685580e+03, + "cpu_time": 1.0955762571248599e+03, + "time_unit": "ns", + "CYCLES": 4.7949157768593768e+03 + }, + { + "name": "deterministic_csprng/create_max", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.1102623791853373e+03, + "cpu_time": 1.1100609703636560e+03, + "time_unit": "ns", + "CYCLES": 4.8052576241761280e+03 + }, + { + "name": "non-deterministic_csprng/create_mean", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 6.1357956617239783e+04, + "cpu_time": 6.1351734618755501e+04, + "time_unit": "ns", + "CYCLES": 2.8621489553023659e+05 + }, + { + "name": "non-deterministic_csprng/create_median", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 6.1354926818576001e+04, + "cpu_time": 6.1351208588957074e+04, + "time_unit": "ns", + "CYCLES": 2.8687041564417176e+05 + }, + { + "name": "non-deterministic_csprng/create_stddev", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.1252255408983554e+01, + "cpu_time": 1.0553998398411766e+01, + "time_unit": "ns", + "CYCLES": 1.7552656754849904e+03 + }, + { + "name": "non-deterministic_csprng/create_cv", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 1.8338706223834710e-04, + "cpu_time": 1.7202444990341577e-04, + "time_unit": "ns", + "CYCLES": 6.1326845768568984e-03 + }, + { + "name": "non-deterministic_csprng/create_min", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 6.1346350570495415e+04, + "cpu_time": 6.1338104732690656e+04, + "time_unit": "ns", + "CYCLES": 2.8140933742331289e+05 + }, + { + "name": "non-deterministic_csprng/create_max", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "non-deterministic_csprng/create", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 6.1380962313619733e+04, + "cpu_time": 6.1369562664329562e+04, + "time_unit": "ns", + "CYCLES": 2.8722328396143735e+05 + }, + { + "name": "csprng/generate_u8_mean", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.4228281430445326e+00, + "cpu_time": 2.4222624242695465e+00, + "time_unit": "ns", + "CYCLES": 1.0994251879101643e+01, + "bytes_per_second": 4.1283946992549682e+08 + }, + { + "name": "csprng/generate_u8_median", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.4219129145723559e+00, + "cpu_time": 2.4215147027247967e+00, + "time_unit": "ns", + "CYCLES": 1.0993904411018722e+01, + "bytes_per_second": 4.1296471777036095e+08 + }, + { + "name": "csprng/generate_u8_stddev", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 5.9805503905902046e-03, + "cpu_time": 6.0060603377831796e-03, + "time_unit": "ns", + "CYCLES": 5.8289406898618459e-03, + "bytes_per_second": 1.0240166720691394e+06 + }, + { + "name": "csprng/generate_u8_cv", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 2.4684170884175989e-03, + "cpu_time": 2.4795250413853719e-03, + "time_unit": "ns", + "CYCLES": 5.3018074844562665e-04, + "bytes_per_second": 2.4804233768005246e-03 + }, + { + "name": "csprng/generate_u8_min", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.4119312987161043e+00, + "cpu_time": 2.4115520734943212e+00, + "time_unit": "ns", + "CYCLES": 1.0984286543535852e+01, + "bytes_per_second": 4.1122000227114987e+08 + }, + { + "name": "csprng/generate_u8_max", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u8", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.4318683974007307e+00, + "cpu_time": 2.4317883237124756e+00, + "time_unit": "ns", + "CYCLES": 1.1002990771159762e+01, + "bytes_per_second": 4.1467070563855064e+08 + }, + { + "name": "csprng/generate_u16_mean", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 7.0237291357712026e+00, + "cpu_time": 7.0226566208172425e+00, + "time_unit": "ns", + "CYCLES": 3.2787426478024592e+01, + "bytes_per_second": 2.8479521423536795e+08 + }, + { + "name": "csprng/generate_u16_median", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 7.0131810989895271e+00, + "cpu_time": 7.0116652090336817e+00, + "time_unit": "ns", + "CYCLES": 3.2787471055222028e+01, + "bytes_per_second": 2.8523894688610214e+08 + }, + { + "name": "csprng/generate_u16_stddev", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.2873715460638742e-02, + "cpu_time": 2.2881358833614411e-02, + "time_unit": "ns", + "CYCLES": 3.5145718996052620e-03, + "bytes_per_second": 9.2248397576687846e+05 + }, + { + "name": "csprng/generate_u16_cv", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 3.2566340498731685e-03, + "cpu_time": 3.2582197975887447e-03, + "time_unit": "ns", + "CYCLES": 1.0719267344635496e-04, + "bytes_per_second": 3.2391133335706091e-03 + }, + { + "name": "csprng/generate_u16_min", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 7.0066082641862737e+00, + "cpu_time": 7.0060227757051718e+00, + "time_unit": "ns", + "CYCLES": 3.2782285928493032e+01, + "bytes_per_second": 2.8240751379123092e+08 + }, + { + "name": "csprng/generate_u16_max", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u16", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 7.0827089165867205e+00, + "cpu_time": 7.0819645453148086e+00, + "time_unit": "ns", + "CYCLES": 3.2793574147947758e+01, + "bytes_per_second": 2.8546866946185386e+08 + }, + { + "name": "csprng/generate_u32_mean", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 6.0118334423489674e+00, + "cpu_time": 6.0110423672424265e+00, + "time_unit": "ns", + "CYCLES": 2.6909348154805169e+01, + "bytes_per_second": 6.6544877355507994e+08 + }, + { + "name": "csprng/generate_u32_median", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 6.0153044416647976e+00, + "cpu_time": 6.0139761681198722e+00, + "time_unit": "ns", + "CYCLES": 2.6905004473244798e+01, + "bytes_per_second": 6.6511740468773460e+08 + }, + { + "name": "csprng/generate_u32_stddev", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.0317138241519851e-02, + "cpu_time": 2.0232524817250096e-02, + "time_unit": "ns", + "CYCLES": 1.2228776667610007e-02, + "bytes_per_second": 2.2390432551069665e+06 + }, + { + "name": "csprng/generate_u32_cv", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 3.3795244722517556e-03, + "cpu_time": 3.3658928986274629e-03, + "time_unit": "ns", + "CYCLES": 4.5444343717505957e-04, + "bytes_per_second": 3.3647116714110802e-03 + }, + { + "name": "csprng/generate_u32_min", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 5.9798033051333466e+00, + "cpu_time": 5.9795947596027883e+00, + "time_unit": "ns", + "CYCLES": 2.6891613118762464e+01, + "bytes_per_second": 6.6144430195280004e+08 + }, + { + "name": "csprng/generate_u32_max", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u32", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 6.0480302275664393e+00, + "cpu_time": 6.0473723761633300e+00, + "time_unit": "ns", + "CYCLES": 2.6928600748999511e+01, + "bytes_per_second": 6.6894165253862643e+08 + }, + { + "name": "csprng/generate_u64_mean", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 9.6762598841827874e+00, + "cpu_time": 9.6745015903207197e+00, + "time_unit": "ns", + "CYCLES": 4.2692086819612072e+01, + "bytes_per_second": 8.2693340975500846e+08 + }, + { + "name": "csprng/generate_u64_median", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 9.6933727266402698e+00, + "cpu_time": 9.6907284019240674e+00, + "time_unit": "ns", + "CYCLES": 4.2693120358390402e+01, + "bytes_per_second": 8.2553136261210036e+08 + }, + { + "name": "csprng/generate_u64_stddev", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 4.7312059832198577e-02, + "cpu_time": 4.6747432733979855e-02, + "time_unit": "ns", + "CYCLES": 1.2046673588397585e-02, + "bytes_per_second": 4.0070781094924184e+06 + }, + { + "name": "csprng/generate_u64_cv", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 4.8894986697842644e-03, + "cpu_time": 4.8320249159657363e-03, + "time_unit": "ns", + "CYCLES": 2.8217579616800399e-04, + "bytes_per_second": 4.8457083269613883e-03 + }, + { + "name": "csprng/generate_u64_min", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 9.6016293391612102e+00, + "cpu_time": 9.6007870504970629e+00, + "time_unit": "ns", + "CYCLES": 4.2673507568896007e+01, + "bytes_per_second": 8.2222443733614564e+08 + }, + { + "name": "csprng/generate_u64_max", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "csprng/generate_u64", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 9.7308240070386312e+00, + "cpu_time": 9.7297035173492432e+00, + "time_unit": "ns", + "CYCLES": 4.2707479888464938e+01, + "bytes_per_second": 8.3326501857843149e+08 + }, + { + "name": "csprng/shake256/generate_byte_seq_mean", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.7146397804736341e+06, + "cpu_time": 1.7143344207317040e+06, + "time_unit": "ns", + "CYCLES": 7.3856708170731710e+06, + "bytes_per_second": 6.1165330902405155e+08 + }, + { + "name": "csprng/shake256/generate_byte_seq_median", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.7151405426841117e+06, + "cpu_time": 1.7148357682926743e+06, + "time_unit": "ns", + "CYCLES": 7.3847151341463421e+06, + "bytes_per_second": 6.1147313811497414e+08 + }, + { + "name": "csprng/shake256/generate_byte_seq_stddev", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 2.7876526668407919e+03, + "cpu_time": 2.6880834623947667e+03, + "time_unit": "ns", + "CYCLES": 9.4644167706746612e+03, + "bytes_per_second": 9.5946769142061262e+05 + }, + { + "name": "csprng/shake256/generate_byte_seq_cv", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 1.6257949328988270e-03, + "cpu_time": 1.5680041361168327e-03, + "time_unit": "ns", + "CYCLES": 1.2814566212179580e-03, + "bytes_per_second": 1.5686462858372017e-03 + }, + { + "name": "csprng/shake256/generate_byte_seq_min", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.7105763048365165e+06, + "cpu_time": 1.7103923536585413e+06, + "time_unit": "ns", + "CYCLES": 7.3728629878048785e+06, + "bytes_per_second": 6.1036677156445611e+08 + }, + { + "name": "csprng/shake256/generate_byte_seq_max", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "csprng/shake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 1.7182311707207500e+06, + "cpu_time": 1.7179441097560928e+06, + "time_unit": "ns", + "CYCLES": 7.4005273048780486e+06, + "bytes_per_second": 6.1306167427437842e+08 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_mean", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 9.6858938331934041e+05, + "cpu_time": 9.6827456874999998e+05, + "time_unit": "ns", + "CYCLES": 4.1428863201388898e+06, + "bytes_per_second": 1.0829536688665550e+09 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_median", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 9.6804858331880590e+05, + "cpu_time": 9.6788112847223063e+05, + "time_unit": "ns", + "CYCLES": 4.1418538576388890e+06, + "bytes_per_second": 1.0833727215039153e+09 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_stddev", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 4.5811494189165733e+03, + "cpu_time": 4.5133225244674413e+03, + "time_unit": "ns", + "CYCLES": 5.9273812988958289e+03, + "bytes_per_second": 5.0459941087806365e+06 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_cv", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 10, + "real_time": 4.7297126086774232e-03, + "cpu_time": 4.6612011408023882e-03, + "time_unit": "ns", + "CYCLES": 1.4307371336940557e-03, + "bytes_per_second": 4.6594736726474125e-03 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_min", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "min", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 9.6321134717274830e+05, + "cpu_time": 9.6305699305555667e+05, + "time_unit": "ns", + "CYCLES": 4.1354865625000000e+06, + "bytes_per_second": 1.0763703797874053e+09 + }, + { + "name": "csprng/turboshake256/generate_byte_seq_max", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "csprng/turboshake256/generate_byte_seq", + "run_type": "aggregate", + "repetitions": 10, + "threads": 1, + "aggregate_name": "max", + "aggregate_unit": "time", + "iterations": 10, + "real_time": 9.7452054862717190e+05, + "cpu_time": 9.7417768055555841e+05, + "time_unit": "ns", + "CYCLES": 4.1508839097222220e+06, + "bytes_per_second": 1.0887995285441117e+09 + } + ] +} diff --git a/bench_result_on_Linux_6.8.0-1021-aws_aarch64_with_g++_13.json b/bench_result_on_Linux_6.8.0-1021-aws_aarch64_with_g++_13.json deleted file mode 100644 index ee2da58..0000000 --- a/bench_result_on_Linux_6.8.0-1021-aws_aarch64_with_g++_13.json +++ /dev/null @@ -1,1254 +0,0 @@ -{ - "context": { - "date": "2025-03-04T17:09:34+00:00", - "host_name": "ip-172-31-32-23", - "executable": "./build/benchmark/bench.out", - "num_cpus": 2, - "mhz_per_cpu": 2000, - "cpu_scaling_enabled": false, - "caches": [ - { - "type": "Data", - "level": 1, - "size": 65536, - "num_sharing": 1 - }, - { - "type": "Instruction", - "level": 1, - "size": 65536, - "num_sharing": 1 - }, - { - "type": "Unified", - "level": 2, - "size": 2097152, - "num_sharing": 1 - }, - { - "type": "Unified", - "level": 3, - "size": 37748736, - "num_sharing": 2 - } - ], - "load_avg": [1.4375,1.49121,0.702637], - "library_version": "v1.9.1-45-gff5c94d8", - "library_build_type": "release", - "json_schema_version": 1 - }, - "benchmarks": [ - { - "name": "deterministic_csprng/128b/create_mean", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9377521605003044e+03, - "cpu_time": 2.9359596377830476e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/128b/create_median", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9360421292313731e+03, - "cpu_time": 2.9360317412016529e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/128b/create_stddev", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 6.4951957075395628e+00, - "cpu_time": 1.2519564222788446e+00, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/128b/create_cv", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 2.2109406623441715e-03, - "cpu_time": 4.2642153732883086e-04, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/128b/create_min", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9338088812410083e+03, - "cpu_time": 2.9334987513378528e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/128b/create_max", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9560520660635902e+03, - "cpu_time": 2.9381288745251932e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/192b/create_mean", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9334683522049863e+03, - "cpu_time": 2.9304607400740902e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/192b/create_median", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9307763871155084e+03, - "cpu_time": 2.9307166432951699e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/192b/create_stddev", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 9.8266927469170131e+00, - "cpu_time": 1.0346396897806773e+00, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/192b/create_cv", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 3.3498546999938248e-03, - "cpu_time": 3.5306382905321532e-04, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/192b/create_min", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9287574038793327e+03, - "cpu_time": 2.9288132024529559e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/192b/create_max", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9612792440193025e+03, - "cpu_time": 2.9318883191360228e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/256b/create_mean", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9359221259133551e+03, - "cpu_time": 2.9323331134978976e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/256b/create_median", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9318762640536233e+03, - "cpu_time": 2.9319740280133174e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/256b/create_stddev", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 8.7490215206219339e+00, - "cpu_time": 1.1792394450467119e+00, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/256b/create_cv", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 2.9799910029630452e-03, - "cpu_time": 4.0215057410037237e-04, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/256b/create_min", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9315120281383352e+03, - "cpu_time": 2.9314070096099476e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/256b/create_max", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9537152398310413e+03, - "cpu_time": 2.9349615602035105e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/128b/create_mean", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 4.2038385200489620e+03, - "cpu_time": 4.1927212559518512e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/128b/create_median", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 4.1921642260360959e+03, - "cpu_time": 4.1918546252208598e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/128b/create_stddev", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 3.6813919054761001e+01, - "cpu_time": 2.6171935851815777e+00, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/128b/create_cv", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 8.7572153114797158e-03, - "cpu_time": 6.2422312989834331e-04, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/128b/create_min", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 4.1908411942620214e+03, - "cpu_time": 4.1909844877668802e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/128b/create_max", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 4.3085723355187056e+03, - "cpu_time": 4.1999042314257467e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/192b/create_mean", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 4.7356852082480309e+03, - "cpu_time": 4.7325622260786704e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/192b/create_median", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 4.7324278446977951e+03, - "cpu_time": 4.7323418231931291e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/192b/create_stddev", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.0309470149598258e+01, - "cpu_time": 9.2588020719479547e-01, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/192b/create_cv", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 2.1769753892514855e-03, - "cpu_time": 1.9564036624658730e-04, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/192b/create_min", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 4.7314845515167708e+03, - "cpu_time": 4.7315475023819254e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/192b/create_max", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 4.7649469171089604e+03, - "cpu_time": 4.7342606165781872e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/256b/create_mean", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 5.2830825993593471e+03, - "cpu_time": 5.2738834846487080e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/256b/create_median", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 5.2731074967050499e+03, - "cpu_time": 5.2730569598794518e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/256b/create_stddev", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.2746028436570334e+01, - "cpu_time": 2.4693244301567474e+00, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/256b/create_cv", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 4.3054463012425041e-03, - "cpu_time": 4.6821747908244293e-04, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/256b/create_min", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 5.2715095874918206e+03, - "cpu_time": 5.2716842719909118e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/256b/create_max", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 5.3386507816923231e+03, - "cpu_time": 5.2795818421548383e+03, - "time_unit": "ns" - }, - { - "name": "csprng/256b/generate_u8_mean", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 5.0065153020277915e+00, - "cpu_time": 5.0031936813125473e+00, - "time_unit": "ns", - "bytes_per_second": 1.9987233868740895e+08 - }, - { - "name": "csprng/256b/generate_u8_median", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 5.0031021954356811e+00, - "cpu_time": 5.0028933176958530e+00, - "time_unit": "ns", - "bytes_per_second": 1.9988433423004434e+08 - }, - { - "name": "csprng/256b/generate_u8_stddev", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.0990356594253283e-02, - "cpu_time": 7.8213454088199314e-04, - "time_unit": "ns", - "bytes_per_second": 3.1239305850475765e+04 - }, - { - "name": "csprng/256b/generate_u8_cv", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 2.1952108265407386e-03, - "cpu_time": 1.5632705641665395e-04, - "time_unit": "ns", - "bytes_per_second": 1.5629629420273400e-04 - }, - { - "name": "csprng/256b/generate_u8_min", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 5.0022414325721112e+00, - "cpu_time": 5.0024054180398156e+00, - "time_unit": "ns", - "bytes_per_second": 1.9979920450918958e+08 - }, - { - "name": "csprng/256b/generate_u8_max", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 5.0377609778845223e+00, - "cpu_time": 5.0050249321888867e+00, - "time_unit": "ns", - "bytes_per_second": 1.9990382954443711e+08 - }, - { - "name": "csprng/256b/generate_u16_mean", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.7549451568392582e+00, - "cpu_time": 7.7506422316900920e+00, - "time_unit": "ns", - "bytes_per_second": 2.5804314166513854e+08 - }, - { - "name": "csprng/256b/generate_u16_median", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.7505335524702286e+00, - "cpu_time": 7.7503486863273396e+00, - "time_unit": "ns", - "bytes_per_second": 2.5805290664626247e+08 - }, - { - "name": "csprng/256b/generate_u16_stddev", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.4898684815026509e-02, - "cpu_time": 1.5437677809318762e-03, - "time_unit": "ns", - "bytes_per_second": 5.1380651184146918e+04 - }, - { - "name": "csprng/256b/generate_u16_cv", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 1.9211850649758658e-03, - "cpu_time": 1.9917933698705183e-04, - "time_unit": "ns", - "bytes_per_second": 1.9911651537254715e-04 - }, - { - "name": "csprng/256b/generate_u16_min", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.7488691471569409e+00, - "cpu_time": 7.7491234178236557e+00, - "time_unit": "ns", - "bytes_per_second": 2.5791348342251951e+08 - }, - { - "name": "csprng/256b/generate_u16_max", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.7973001945538911e+00, - "cpu_time": 7.7545383570488111e+00, - "time_unit": "ns", - "bytes_per_second": 2.5809370843156618e+08 - }, - { - "name": "csprng/256b/generate_u32_mean", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.3199223109781723e+01, - "cpu_time": 1.3167131373101711e+01, - "time_unit": "ns", - "bytes_per_second": 3.0378675994812644e+08 - }, - { - "name": "csprng/256b/generate_u32_median", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.3168746512469479e+01, - "cpu_time": 1.3167519851128446e+01, - "time_unit": "ns", - "bytes_per_second": 3.0377778399098516e+08 - }, - { - "name": "csprng/256b/generate_u32_stddev", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.2813181225049622e-02, - "cpu_time": 2.9246527299248417e-03, - "time_unit": "ns", - "bytes_per_second": 6.7489835563281711e+04 - }, - { - "name": "csprng/256b/generate_u32_cv", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 5.5164747666920626e-03, - "cpu_time": 2.2211768433475401e-04, - "time_unit": "ns", - "bytes_per_second": 2.2216187293615442e-04 - }, - { - "name": "csprng/256b/generate_u32_min", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.3166782396532914e+01, - "cpu_time": 1.3160818616924246e+01, - "time_unit": "ns", - "bytes_per_second": 3.0369234896086621e+08 - }, - { - "name": "csprng/256b/generate_u32_max", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.3391718274849319e+01, - "cpu_time": 1.3171224147353943e+01, - "time_unit": "ns", - "bytes_per_second": 3.0393246168260175e+08 - }, - { - "name": "csprng/256b/generate_u64_mean", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.4158033191905140e+01, - "cpu_time": 2.4157597135772072e+01, - "time_unit": "ns", - "bytes_per_second": 3.3115922829278088e+08 - }, - { - "name": "csprng/256b/generate_u64_median", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.4176967121759255e+01, - "cpu_time": 2.4177766235409145e+01, - "time_unit": "ns", - "bytes_per_second": 3.3088251097831309e+08 - }, - { - "name": "csprng/256b/generate_u64_stddev", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9540986715016721e-02, - "cpu_time": 3.0151443385702296e-02, - "time_unit": "ns", - "bytes_per_second": 4.1364861959194270e+05 - }, - { - "name": "csprng/256b/generate_u64_cv", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 1.2228225071284073e-03, - "cpu_time": 1.2481143391970331e-03, - "time_unit": "ns", - "bytes_per_second": 1.2490928358675610e-03 - }, - { - "name": "csprng/256b/generate_u64_min", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.4108587170880998e+01, - "cpu_time": 2.4107228815927233e+01, - "time_unit": "ns", - "bytes_per_second": 3.3080181585063225e+08 - }, - { - "name": "csprng/256b/generate_u64_max", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.4184537531122352e+01, - "cpu_time": 2.4183664105436044e+01, - "time_unit": "ns", - "bytes_per_second": 3.3185066857267874e+08 - }, - { - "name": "csprng/128b/generate_byte_seq_mean", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9472675312502380e+06, - "cpu_time": 2.9329965354166622e+06, - "time_unit": "ns", - "bytes_per_second": 3.5751033976011729e+08 - }, - { - "name": "csprng/128b/generate_byte_seq_median", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9324209687503120e+06, - "cpu_time": 2.9324391354166684e+06, - "time_unit": "ns", - "bytes_per_second": 3.5757809790648937e+08 - }, - { - "name": "csprng/128b/generate_byte_seq_stddev", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 3.3116320520802998e+04, - "cpu_time": 2.3167768046329056e+03, - "time_unit": "ns", - "bytes_per_second": 2.8194928397673677e+05 - }, - { - "name": "csprng/128b/generate_byte_seq_cv", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 1.1236279085514498e-02, - "cpu_time": 7.8990096873871149e-04, - "time_unit": "ns", - "bytes_per_second": 7.8864651625438142e-04 - }, - { - "name": "csprng/128b/generate_byte_seq_min", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9312901666666372e+06, - "cpu_time": 2.9313235208333991e+06, - "time_unit": "ns", - "bytes_per_second": 3.5675633836660206e+08 - }, - { - "name": "csprng/128b/generate_byte_seq_max", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 3.0264529166667368e+06, - "cpu_time": 2.9391937499999949e+06, - "time_unit": "ns", - "bytes_per_second": 3.5771418355824518e+08 - }, - { - "name": "csprng/192b/generate_byte_seq_mean", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9353934437502008e+06, - "cpu_time": 2.9335837520833393e+06, - "time_unit": "ns", - "bytes_per_second": 3.5743861976116800e+08 - }, - { - "name": "csprng/192b/generate_byte_seq_median", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9337688437494813e+06, - "cpu_time": 2.9334907083333014e+06, - "time_unit": "ns", - "bytes_per_second": 3.5744991534125203e+08 - }, - { - "name": "csprng/192b/generate_byte_seq_stddev", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 5.0504885987814569e+03, - "cpu_time": 1.0773706318285474e+03, - "time_unit": "ns", - "bytes_per_second": 1.3128513098804042e+05 - }, - { - "name": "csprng/192b/generate_byte_seq_cv", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 1.7205491173711463e-03, - "cpu_time": 3.6725409017671052e-04, - "time_unit": "ns", - "bytes_per_second": 3.6729419746462212e-04 - }, - { - "name": "csprng/192b/generate_byte_seq_min", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9329330625008275e+06, - "cpu_time": 2.9314626250000289e+06, - "time_unit": "ns", - "bytes_per_second": 3.5723396093681961e+08 - }, - { - "name": "csprng/192b/generate_byte_seq_max", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9495914583333638e+06, - "cpu_time": 2.9352640416666633e+06, - "time_unit": "ns", - "bytes_per_second": 3.5769720925573444e+08 - }, - { - "name": "csprng/256b/generate_byte_seq_mean", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9323896812497219e+06, - "cpu_time": 2.9253105375000034e+06, - "time_unit": "ns", - "bytes_per_second": 3.5844963119265473e+08 - }, - { - "name": "csprng/256b/generate_byte_seq_median", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9247120937494487e+06, - "cpu_time": 2.9247208333333200e+06, - "time_unit": "ns", - "bytes_per_second": 3.5852173943276429e+08 - }, - { - "name": "csprng/256b/generate_byte_seq_stddev", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.4360048636090771e+04, - "cpu_time": 2.0952286744629537e+03, - "time_unit": "ns", - "bytes_per_second": 2.5629177513644792e+05 - }, - { - "name": "csprng/256b/generate_byte_seq_cv", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 8.3072344688203369e-03, - "cpu_time": 7.1624145457512868e-04, - "time_unit": "ns", - "bytes_per_second": 7.1500080578601466e-04 - }, - { - "name": "csprng/256b/generate_byte_seq_min", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.9242217708341419e+06, - "cpu_time": 2.9241760833333223e+06, - "time_unit": "ns", - "bytes_per_second": 3.5772869828402519e+08 - }, - { - "name": "csprng/256b/generate_byte_seq_max", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 3.0017150833323570e+06, - "cpu_time": 2.9312045833333284e+06, - "time_unit": "ns", - "bytes_per_second": 3.5858852891126478e+08 - } - ] -} diff --git a/bench_result_on_Linux_6.8.0-1021-aws_x86_64_with_g++_13.json b/bench_result_on_Linux_6.8.0-1021-aws_x86_64_with_g++_13.json deleted file mode 100644 index eb77b3e..0000000 --- a/bench_result_on_Linux_6.8.0-1021-aws_x86_64_with_g++_13.json +++ /dev/null @@ -1,1254 +0,0 @@ -{ - "context": { - "date": "2025-03-04T17:19:55+00:00", - "host_name": "ip-172-31-46-234", - "executable": "./build/benchmark/bench.out", - "num_cpus": 2, - "mhz_per_cpu": 3801, - "cpu_scaling_enabled": false, - "caches": [ - { - "type": "Data", - "level": 1, - "size": 49152, - "num_sharing": 2 - }, - { - "type": "Instruction", - "level": 1, - "size": 32768, - "num_sharing": 2 - }, - { - "type": "Unified", - "level": 2, - "size": 2097152, - "num_sharing": 2 - }, - { - "type": "Unified", - "level": 3, - "size": 110100480, - "num_sharing": 2 - } - ], - "load_avg": [1.0332,1.55566,0.772949], - "library_version": "v1.9.1-45-gff5c94d8", - "library_build_type": "release", - "json_schema_version": 1 - }, - "benchmarks": [ - { - "name": "deterministic_csprng/128b/create_mean", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.3106853478245907e+03, - "cpu_time": 2.3066014881242500e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/128b/create_median", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.2717695113233249e+03, - "cpu_time": 2.2717411459856394e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/128b/create_stddev", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 8.3754678796575519e+01, - "cpu_time": 7.5655687837696817e+01, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/128b/create_cv", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 3.6246682775492076e-02, - "cpu_time": 3.2799635406123295e-02, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/128b/create_min", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.2682645644472946e+03, - "cpu_time": 2.2682625174643404e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/128b/create_max", - "family_index": 0, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.4926618903730928e+03, - "cpu_time": 2.4759452838158368e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/192b/create_mean", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.2815606688800594e+03, - "cpu_time": 2.2800922244716171e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/192b/create_median", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.2627376224794630e+03, - "cpu_time": 2.2627197100979834e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/192b/create_stddev", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 5.9478556919494203e+01, - "cpu_time": 5.5121581986032155e+01, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/192b/create_cv", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 2.6069241870605268e-02, - "cpu_time": 2.4175154581216947e-02, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/192b/create_min", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.2613355899267594e+03, - "cpu_time": 2.2613340351445431e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/192b/create_max", - "family_index": 1, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.4508165195560950e+03, - "cpu_time": 2.4369456474208464e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/256b/create_mean", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.3100004996118669e+03, - "cpu_time": 2.3047127279782694e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/256b/create_median", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.2684702738976762e+03, - "cpu_time": 2.2683322823696790e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/256b/create_stddev", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 9.0692583870021537e+01, - "cpu_time": 7.9365481636427390e+01, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/256b/create_cv", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 3.9260850326768321e-02, - "cpu_time": 3.4436171012969606e-02, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/256b/create_min", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.2640797923936857e+03, - "cpu_time": 2.2640780785150741e+03, - "time_unit": "ns" - }, - { - "name": "deterministic_csprng/256b/create_max", - "family_index": 2, - "per_family_instance_index": 0, - "run_name": "deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.5017987647134514e+03, - "cpu_time": 2.4661752198939294e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/128b/create_mean", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 6.2008815868859256e+03, - "cpu_time": 6.1875219672131179e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/128b/create_median", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 6.1139791693994748e+03, - "cpu_time": 6.1136949071038198e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/128b/create_stddev", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8806500127288405e+02, - "cpu_time": 1.6009457709505355e+02, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/128b/create_cv", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 3.0328752232685365e-02, - "cpu_time": 2.5873779187108200e-02, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/128b/create_min", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 6.1070191038267239e+03, - "cpu_time": 6.1070141202185896e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/128b/create_max", - "family_index": 3, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/128b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 6.5779475409846009e+03, - "cpu_time": 6.5005095081967247e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/192b/create_mean", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 6.5341018841652458e+03, - "cpu_time": 6.5187068730276642e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/192b/create_median", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 6.4831572535724717e+03, - "cpu_time": 6.4828206330053763e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/192b/create_stddev", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.6674495522446972e+02, - "cpu_time": 1.1912045566483627e+02, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/192b/create_cv", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 2.5519185066360802e-02, - "cpu_time": 1.8273632790226972e-02, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/192b/create_min", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 6.4740439948013736e+03, - "cpu_time": 6.4731303601262498e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/192b/create_max", - "family_index": 4, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/192b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.0084856135130103e+03, - "cpu_time": 6.8574589753109540e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/256b/create_mean", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.0990015032282099e+03, - "cpu_time": 7.0881889880951985e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/256b/create_median", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.0486545349058197e+03, - "cpu_time": 7.0481189719531667e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/256b/create_stddev", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.5708859306785160e+02, - "cpu_time": 1.2349407790717733e+02, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/256b/create_cv", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 2.2128265925344139e-02, - "cpu_time": 1.7422514850350193e-02, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/256b/create_min", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.0464742231633527e+03, - "cpu_time": 7.0464685734462673e+03, - "time_unit": "ns" - }, - { - "name": "non-deterministic_csprng/256b/create_max", - "family_index": 5, - "per_family_instance_index": 0, - "run_name": "non-deterministic_csprng/256b/create", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.5460043886209914e+03, - "cpu_time": 7.4395593724777955e+03, - "time_unit": "ns" - }, - { - "name": "csprng/256b/generate_u8_mean", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.6428275638832903e+00, - "cpu_time": 2.6408669065732520e+00, - "time_unit": "ns", - "bytes_per_second": 3.7909685898890805e+08 - }, - { - "name": "csprng/256b/generate_u8_median", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.5973351893476946e+00, - "cpu_time": 2.5970807708154653e+00, - "time_unit": "ns", - "bytes_per_second": 3.8504814132978475e+08 - }, - { - "name": "csprng/256b/generate_u8_stddev", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.0103625505338723e-01, - "cpu_time": 9.6567133258004242e-02, - "time_unit": "ns", - "bytes_per_second": 1.3167530735679926e+07 - }, - { - "name": "csprng/256b/generate_u8_cv", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 3.8230362220427139e-02, - "cpu_time": 3.6566452106179127e-02, - "time_unit": "ns", - "bytes_per_second": 3.4733948391973336e-02 - }, - { - "name": "csprng/256b/generate_u8_min", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.5875470793570243e+00, - "cpu_time": 2.5875449815566269e+00, - "time_unit": "ns", - "bytes_per_second": 3.5176813688787454e+08 - }, - { - "name": "csprng/256b/generate_u8_max", - "family_index": 6, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u8", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.8617305777086202e+00, - "cpu_time": 2.8427816369245185e+00, - "time_unit": "ns", - "bytes_per_second": 3.8646671154617590e+08 - }, - { - "name": "csprng/256b/generate_u16_mean", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 4.6766530524440197e+00, - "cpu_time": 4.6701766926338593e+00, - "time_unit": "ns", - "bytes_per_second": 4.2842029430524129e+08 - }, - { - "name": "csprng/256b/generate_u16_median", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 4.6336875786304326e+00, - "cpu_time": 4.6334464274890381e+00, - "time_unit": "ns", - "bytes_per_second": 4.3164414033920288e+08 - }, - { - "name": "csprng/256b/generate_u16_stddev", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.2046146775957227e-01, - "cpu_time": 1.0085722405109261e-01, - "time_unit": "ns", - "bytes_per_second": 8.7969443868915197e+06 - }, - { - "name": "csprng/256b/generate_u16_cv", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 2.5758050984051314e-02, - "cpu_time": 2.1596018885146662e-02, - "time_unit": "ns", - "bytes_per_second": 2.0533444619278154e-02 - }, - { - "name": "csprng/256b/generate_u16_min", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 4.6281763726200156e+00, - "cpu_time": 4.6281725014975041e+00, - "time_unit": "ns", - "bytes_per_second": 4.0379893557791811e+08 - }, - { - "name": "csprng/256b/generate_u16_max", - "family_index": 7, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u16", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 5.0158654191018481e+00, - "cpu_time": 4.9529600595345666e+00, - "time_unit": "ns", - "bytes_per_second": 4.3213601034811783e+08 - }, - { - "name": "csprng/256b/generate_u32_mean", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 8.7233219900730639e+00, - "cpu_time": 8.7165691111689156e+00, - "time_unit": "ns", - "bytes_per_second": 4.5912828071048319e+08 - }, - { - "name": "csprng/256b/generate_u32_median", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 8.6389070458175290e+00, - "cpu_time": 8.6388338143598435e+00, - "time_unit": "ns", - "bytes_per_second": 4.6302545995453358e+08 - }, - { - "name": "csprng/256b/generate_u32_stddev", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.3295656093525774e-01, - "cpu_time": 2.1263319552378063e-01, - "time_unit": "ns", - "bytes_per_second": 1.0573702973881740e+07 - }, - { - "name": "csprng/256b/generate_u32_cv", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 2.6705028336722739e-02, - "cpu_time": 2.4394138658445849e-02, - "time_unit": "ns", - "bytes_per_second": 2.3029953540477502e-02 - }, - { - "name": "csprng/256b/generate_u32_min", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 8.6324566264172660e+00, - "cpu_time": 8.6324462529883110e+00, - "time_unit": "ns", - "bytes_per_second": 4.2941134187461543e+08 - }, - { - "name": "csprng/256b/generate_u32_max", - "family_index": 8, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u32", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 9.3802886727237969e+00, - "cpu_time": 9.3150776654799365e+00, - "time_unit": "ns", - "bytes_per_second": 4.6336807467701429e+08 - }, - { - "name": "csprng/256b/generate_u64_mean", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.7064248569995648e+01, - "cpu_time": 1.7024434674661816e+01, - "time_unit": "ns", - "bytes_per_second": 4.7037413093296474e+08 - }, - { - "name": "csprng/256b/generate_u64_median", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.6699130551051532e+01, - "cpu_time": 1.6699112556452050e+01, - "time_unit": "ns", - "bytes_per_second": 4.7906737438502598e+08 - }, - { - "name": "csprng/256b/generate_u64_stddev", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 6.4096424577003430e-01, - "cpu_time": 5.7321733499382865e-01, - "time_unit": "ns", - "bytes_per_second": 1.5226640025906641e+07 - }, - { - "name": "csprng/256b/generate_u64_cv", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 3.7561820735373751e-02, - "cpu_time": 3.3670271345160860e-02, - "time_unit": "ns", - "bytes_per_second": 3.2371338099961670e-02 - }, - { - "name": "csprng/256b/generate_u64_min", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.6682106230811527e+01, - "cpu_time": 1.6682074293381252e+01, - "time_unit": "ns", - "bytes_per_second": 4.3814660210222208e+08 - }, - { - "name": "csprng/256b/generate_u64_max", - "family_index": 9, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_u64", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 1.8378775216125298e+01, - "cpu_time": 1.8258728840109899e+01, - "time_unit": "ns", - "bytes_per_second": 4.7955667019023317e+08 - }, - { - "name": "csprng/128b/generate_byte_seq_mean", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.1681130846156278e+06, - "cpu_time": 2.1677456030769097e+06, - "time_unit": "ns", - "bytes_per_second": 4.8416002842900813e+08 - }, - { - "name": "csprng/128b/generate_byte_seq_median", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.1457040615386041e+06, - "cpu_time": 2.1455438692307477e+06, - "time_unit": "ns", - "bytes_per_second": 4.8872270751189291e+08 - }, - { - "name": "csprng/128b/generate_byte_seq_stddev", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 7.2660895160965258e+04, - "cpu_time": 7.1937248365659238e+04, - "time_unit": "ns", - "bytes_per_second": 1.4824288316379532e+07 - }, - { - "name": "csprng/128b/generate_byte_seq_cv", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 3.3513424957650167e-02, - "cpu_time": 3.3185281641697775e-02, - "time_unit": "ns", - "bytes_per_second": 3.0618571228362364e-02 - }, - { - "name": "csprng/128b/generate_byte_seq_min", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.1422028769235956e+06, - "cpu_time": 2.1417963538461584e+06, - "time_unit": "ns", - "bytes_per_second": 4.4198772067119861e+08 - }, - { - "name": "csprng/128b/generate_byte_seq_max", - "family_index": 10, - "per_family_instance_index": 0, - "run_name": "csprng/128b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.3748429538465226e+06, - "cpu_time": 2.3724097999999681e+06, - "time_unit": "ns", - "bytes_per_second": 4.8957782476238048e+08 - }, - { - "name": "csprng/192b/generate_byte_seq_mean", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.1642489621213335e+06, - "cpu_time": 2.1589104530303054e+06, - "time_unit": "ns", - "bytes_per_second": 4.8636298626057798e+08 - }, - { - "name": "csprng/192b/generate_byte_seq_median", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.1207401060606940e+06, - "cpu_time": 2.1205658712121383e+06, - "time_unit": "ns", - "bytes_per_second": 4.9447933438707650e+08 - }, - { - "name": "csprng/192b/generate_byte_seq_stddev", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 9.6794140752425068e+04, - "cpu_time": 8.7142658656779517e+04, - "time_unit": "ns", - "bytes_per_second": 1.8342110419123169e+07 - }, - { - "name": "csprng/192b/generate_byte_seq_cv", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 4.4724124833378821e-02, - "cpu_time": 4.0364183949576839e-02, - "time_unit": "ns", - "bytes_per_second": 3.7712800803669802e-02 - }, - { - "name": "csprng/192b/generate_byte_seq_min", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.1178081212123306e+06, - "cpu_time": 2.1178168939393600e+06, - "time_unit": "ns", - "bytes_per_second": 4.4152968032756799e+08 - }, - { - "name": "csprng/192b/generate_byte_seq_max", - "family_index": 11, - "per_family_instance_index": 0, - "run_name": "csprng/192b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.3944389393942733e+06, - "cpu_time": 2.3748709242424392e+06, - "time_unit": "ns", - "bytes_per_second": 4.9512118021192074e+08 - }, - { - "name": "csprng/256b/generate_byte_seq_mean", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "mean", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.1706011630769456e+06, - "cpu_time": 2.1688553292307621e+06, - "time_unit": "ns", - "bytes_per_second": 4.8366348218383974e+08 - }, - { - "name": "csprng/256b/generate_byte_seq_median", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "median", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.1556431230771104e+06, - "cpu_time": 2.1556502923076805e+06, - "time_unit": "ns", - "bytes_per_second": 4.8643142372529662e+08 - }, - { - "name": "csprng/256b/generate_byte_seq_stddev", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "stddev", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 5.2022623405039216e+04, - "cpu_time": 4.6982224064364200e+04, - "time_unit": "ns", - "bytes_per_second": 9.9357597821507566e+06 - }, - { - "name": "csprng/256b/generate_byte_seq_cv", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "cv", - "aggregate_unit": "percentage", - "iterations": 10, - "real_time": 2.3966919529009329e-02, - "cpu_time": 2.1662221279197820e-02, - "time_unit": "ns", - "bytes_per_second": 2.0542712336455018e-02 - }, - { - "name": "csprng/256b/generate_byte_seq_min", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "min", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.1492705999994893e+06, - "cpu_time": 2.1492749076923174e+06, - "time_unit": "ns", - "bytes_per_second": 4.5543038983171737e+08 - }, - { - "name": "csprng/256b/generate_byte_seq_max", - "family_index": 12, - "per_family_instance_index": 0, - "run_name": "csprng/256b/generate_byte_seq", - "run_type": "aggregate", - "repetitions": 10, - "threads": 1, - "aggregate_name": "max", - "aggregate_unit": "time", - "iterations": 10, - "real_time": 2.3184720769222621e+06, - "cpu_time": 2.3023847846153867e+06, - "time_unit": "ns", - "bytes_per_second": 4.8787430414188343e+08 - } - ] -} From 650f2a29078e1e568069547be5a7c7f2c9ac0c11 Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Mon, 17 Nov 2025 12:44:11 +0530 Subject: [PATCH 17/18] Change test suite name to `RandomSHAKE` Signed-off-by: Anjan Roy --- tests/test_bit_flipping.cpp | 2 +- tests/test_deterministic_csprng.cpp | 12 ++++++------ tests/test_ratcheting.cpp | 4 ++-- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/tests/test_bit_flipping.cpp b/tests/test_bit_flipping.cpp index 2ece887..455bfa5 100644 --- a/tests/test_bit_flipping.cpp +++ b/tests/test_bit_flipping.cpp @@ -3,7 +3,7 @@ #include #include -TEST(RandomShakeTestUtility, Bit_Flipping_Must_Work_Correctly) +TEST(RandomSHAKETestUtility, Bit_Flipping_Must_Work_Correctly) { auto input_word = std::numeric_limits::min(); constexpr auto T_bw = std::numeric_limits::digits; diff --git a/tests/test_deterministic_csprng.cpp b/tests/test_deterministic_csprng.cpp index ab4cbeb..2e9fc46 100644 --- a/tests/test_deterministic_csprng.cpp +++ b/tests/test_deterministic_csprng.cpp @@ -8,7 +8,7 @@ #include #include -TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_Produces_Eq_Output) +TEST(RandomSHAKE, Deterministic_CSPRNG_Using_Same_Seed_Produces_Eq_Output) { std::array::seed_byte_len> seed{}; seed.fill(0xde); @@ -25,7 +25,7 @@ TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_Produces_Eq_Output) EXPECT_EQ(rand_bytes_a, rand_bytes_b); } -TEST(RandomShake, Deterministic_CSPRNG_Using_Diff_Seed_Produces_Ne_Output) +TEST(RandomSHAKE, Deterministic_CSPRNG_Using_Diff_Seed_Produces_Ne_Output) { std::array::seed_byte_len> seed{}; seed.fill(0xde); @@ -45,7 +45,7 @@ TEST(RandomShake, Deterministic_CSPRNG_Using_Diff_Seed_Produces_Ne_Output) EXPECT_NE(rand_bytes_a, rand_bytes_b); } -TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_XOF_Kind_Produces_Ne_Output) +TEST(RandomSHAKE, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_XOF_Kind_Produces_Ne_Output) { std::array::seed_byte_len> seed_a{}; seed_a.fill(0xde); @@ -65,7 +65,7 @@ TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_XOF_Kind_Produc EXPECT_NE(rand_bytes_a, rand_bytes_b); } -TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Result_Type_Produces_Eq_Output) +TEST(RandomSHAKE, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Result_Type_Produces_Eq_Output) { std::array::seed_byte_len> seed{}; seed.fill(0xde); @@ -100,7 +100,7 @@ TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Result_Type_Pro EXPECT_TRUE(std::ranges::equal(generated_rand_u32_span, generated_rand_u64_span)); } -TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Public_API) +TEST(RandomSHAKE, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Public_API) { std::array::seed_byte_len> seed{}; seed.fill(0xde); @@ -117,7 +117,7 @@ TEST(RandomShake, Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Public_API) EXPECT_EQ(generated_rand_u8, generated_byte_seq); } -TEST(RandomShake, Deterministic_CSPRNG_Oneshot_vs_Multishot_Squeezing) +TEST(RandomSHAKE, Deterministic_CSPRNG_Oneshot_vs_Multishot_Squeezing) { std::array::seed_byte_len> seed{}; seed.fill(0xde); diff --git a/tests/test_ratcheting.cpp b/tests/test_ratcheting.cpp index 0549f1b..2421463 100644 --- a/tests/test_ratcheting.cpp +++ b/tests/test_ratcheting.cpp @@ -94,12 +94,12 @@ test_ratchet_getting_activated_post_ratchet_period_bytes_output() EXPECT_FALSE(std::ranges::equal(last_of_original, last_of_dummy)); } -TEST(RandomShake, Deterministic_CSPRNG_Detect_Ratchet_Working_For_SHAKE256_XOF) +TEST(RandomSHAKE, Deterministic_CSPRNG_Detect_Ratchet_Working_For_SHAKE256_XOF) { test_ratchet_getting_activated_post_ratchet_period_bytes_output(); } -TEST(RandomShake, Deterministic_CSPRNG_Detect_Ratchet_Working_For_TurboSHAKE256_XOF) +TEST(RandomSHAKE, Deterministic_CSPRNG_Detect_Ratchet_Working_For_TurboSHAKE256_XOF) { test_ratchet_getting_activated_post_ratchet_period_bytes_output(); } From b04e5d3df1264ee1562dc02afddd24fe5a3b4384 Mon Sep 17 00:00:00 2001 From: Anjan Roy Date: Mon, 17 Nov 2025 12:44:38 +0530 Subject: [PATCH 18/18] Add test execution console output in README Signed-off-by: Anjan Roy --- README.md | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/README.md b/README.md index 0f19093..e5e0a28 100644 --- a/README.md +++ b/README.md @@ -108,6 +108,19 @@ For running all functional correctness tests, just issue make test -j ``` +```bash +PASSED TESTS (9/9): + 1 ms: build/test/test.out RandomSHAKETestUtility.Bit_Flipping_Must_Work_Correctly + 4 ms: build/test/test.out RandomSHAKE.Deterministic_CSPRNG_Oneshot_vs_Multishot_Squeezing + 11 ms: build/test/test.out RandomSHAKE.Deterministic_CSPRNG_Using_Same_Seed_With_Diff_XOF_Kind_Produces_Ne_Output + 11 ms: build/test/test.out RandomSHAKE.Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Public_API + 11 ms: build/test/test.out RandomSHAKE.Deterministic_CSPRNG_Detect_Ratchet_Working_For_TurboSHAKE256_XOF + 16 ms: build/test/test.out RandomSHAKE.Deterministic_CSPRNG_Using_Diff_Seed_Produces_Ne_Output + 17 ms: build/test/test.out RandomSHAKE.Deterministic_CSPRNG_Using_Same_Seed_Produces_Eq_Output + 18 ms: build/test/test.out RandomSHAKE.Deterministic_CSPRNG_Detect_Ratchet_Working_For_SHAKE256_XOF + 20 ms: build/test/test.out RandomSHAKE.Deterministic_CSPRNG_Using_Same_Seed_With_Diff_Result_Type_Produces_Eq_Output +``` + > [!NOTE] > There is a help menu, which introduces you to all available commands; just run `make` from the root directory of this project.