7#include <botan/internal/hash_engine.h>
9#include <botan/assert.h>
10#include <botan/exceptn.h>
11#include <botan/hash.h>
14#if defined(BOTAN_HAS_HASH_ENGINE_SHA2_32)
15 #include <botan/internal/hash_engine_sha2_32.h>
18#if defined(BOTAN_HAS_HASH_ENGINE_SHA2_64)
19 #include <botan/internal/hash_engine_sha2_64.h>
22#if defined(BOTAN_HAS_HASH_ENGINE_KECCAK)
23 #include <botan/internal/hash_engine_keccak.h>
26#if defined(BOTAN_HAS_THREAD_UTILS)
27 #include <botan/internal/bit_ops.h>
28 #include <botan/internal/thread_pool.h>
39 Base_Hash_Engine(std::unique_ptr<HashFunction> hash, std::span<const uint8_t> common_prefix) :
40 Hash_Engine(common_prefix), m_hash(std::move(hash)) {}
42 std::string
name()
const override {
return m_hash->name(); }
44 std::string provider()
const override {
return "base"; }
46 size_t output_length()
const override {
return m_hash->output_length(); }
48 size_t parallelism()
const override {
return 1; }
50 void batch_hash(std::span<std::span<uint8_t>> outputs,
51 std::span<std::span<const uint8_t>> inputs1,
52 std::span<std::span<const uint8_t>> inputs2)
override {
53 check_batch_args(outputs, inputs1, inputs2);
55 for(
size_t i = 0; i != inputs1.size(); ++i) {
56 m_hash->update(common_prefix());
57 m_hash->update(inputs1[i]);
58 if(!inputs2.empty()) {
59 m_hash->update(inputs2[i]);
61 m_hash->final(outputs[i].first(output_length()));
66 std::unique_ptr<HashFunction> m_hash;
69std::unique_ptr<Hash_Engine> make_base_engine(std::string_view hash_fn,
70 std::span<const uint8_t> common_prefix,
71 std::string_view provider) {
72#if defined(BOTAN_HAS_HASH_ENGINE_SHA2_32)
78#if defined(BOTAN_HAS_HASH_ENGINE_SHA2_64)
84#if defined(BOTAN_HAS_HASH_ENGINE_KECCAK)
90 if(provider.empty() || provider ==
"base") {
92 return std::make_unique<Base_Hash_Engine>(std::move(hash), common_prefix);
99#if defined(BOTAN_HAS_THREAD_UTILS)
101class Threaded_Hash_Engine final :
public Hash_Engine {
103 Threaded_Hash_Engine(std::string_view hash_fn,
104 std::unique_ptr<Hash_Engine> first_engine,
105 std::span<const uint8_t> common_prefix) :
106 Hash_Engine(common_prefix), m_hash_fn(hash_fn), m_pool(Thread_Pool::global_instance()) {
110 m_engines.push_back(std::move(first_engine));
113 std::string
name()
const override {
return m_engines[0]->name(); }
115 std::string provider()
const override {
return "threads"; }
117 size_t output_length()
const override {
return m_engines[0]->output_length(); }
119 size_t parallelism()
const override {
120 return std::max<size_t>(m_pool.worker_count(), 1) * m_engines[0]->parallelism();
123 size_t uncached_prefix_bytes()
const override {
return m_engines[0]->uncached_prefix_bytes(); }
125 void batch_hash(std::span<std::span<uint8_t>> outputs,
126 std::span<std::span<const uint8_t>> inputs1,
127 std::span<std::span<const uint8_t>> inputs2)
override {
128 check_batch_args(outputs, inputs1, inputs2);
130 const size_t count = inputs1.size();
138 const size_t per_hash_bytes = m_engines[0]->uncached_prefix_bytes() + inputs1[0].size() +
139 (inputs2.empty() ? 0 : inputs2[0].size()) + output_length() + 64;
143 constexpr size_t MIN_BYTES_PER_THREAD = 32 * 1024;
144 const size_t by_bytes = (count * per_hash_bytes) / MIN_BYTES_PER_THREAD;
146 if(count < 2 || by_bytes < 2) {
147 m_engines[0]->batch_hash(outputs, inputs1, inputs2);
154 const size_t lanes = m_engines[0]->parallelism();
155 const size_t groups = (count + lanes - 1) / lanes;
157 const size_t threads = [&]() {
158 const size_t t = std::min({m_pool.worker_count(), groups, by_bytes});
163 const size_t rounds = (groups + t - 1) / t;
164 return (groups + rounds - 1) / rounds;
169 m_engines[0]->batch_hash(outputs, inputs1, inputs2);
173 while(m_engines.size() < threads) {
174 auto eng = make_base_engine(m_hash_fn, common_prefix(),
"");
176 m_engines.push_back(std::move(eng));
179 dispatch(threads, count, [&](
size_t t,
size_t offset,
size_t n) {
180 const auto in2 = inputs2.empty() ? inputs2 : inputs2.subspan(offset, n);
181 m_engines[t]->batch_hash(outputs.subspan(offset, n), inputs1.subspan(offset, n), in2);
186 template <
typename F>
187 void dispatch(
size_t threads,
size_t count, F work_fn) {
188 const size_t lanes = m_engines[0]->parallelism();
190 const size_t chunk = lanes * std::max<size_t>(1,
ceil_division(count / (4 * threads), lanes));
192 std::atomic<size_t> next = 0;
194 const auto claim_chunks = [&](
size_t t) {
196 const size_t offset = next.fetch_add(chunk);
197 if(offset >= count) {
200 work_fn(t, offset, std::min(chunk, count - offset));
206 std::vector<Joining_Future<void>> futures;
207 futures.reserve(threads - 1);
209 for(
size_t t = 0; t != threads - 1; ++t) {
210 futures.push_back(m_pool.run(claim_chunks, t));
215 std::exception_ptr error;
219 claim_chunks(threads - 1);
221 error = std::current_exception();
224 for(
auto& f : futures) {
229 error = std::current_exception();
235 std::rethrow_exception(error);
239 std::string m_hash_fn;
241 std::vector<std::unique_ptr<Hash_Engine>> m_engines;
249 std::span<std::span<const uint8_t>> inputs1,
250 std::span<std::span<const uint8_t>> inputs2)
const {
252 "Hash_Engine::batch_hash requires same number of inputs and outputs");
254 "Hash_Engine::batch_hash second inputs must be empty or match first");
258 for(
size_t i = 0; i != inputs1.size(); ++i) {
259 BOTAN_ARG_CHECK(inputs1[i].size() == inputs1[0].size(),
"Hash_Engine::batch_hash inputs must be equal length");
260 BOTAN_ARG_CHECK(outputs[i].size() >= out_len,
"Hash_Engine::batch_hash output buffer too small");
263 for(
size_t i = 0; i != inputs2.size(); ++i) {
264 BOTAN_ARG_CHECK(inputs2[i].size() == inputs2[0].size(),
"Hash_Engine::batch_hash inputs must be equal length");
271#if defined(BOTAN_HAS_THREAD_UTILS)
280 if(
auto engine = make_base_engine(hash_fn,
common_prefix,
"")) {
281 return std::make_unique<Threaded_Hash_Engine>(hash_fn, std::move(engine),
common_prefix);
303 return {
"base",
"threads",
"neon",
"ssse3",
"avx2",
"avx512"};
#define BOTAN_ASSERT_NONNULL(ptr)
#define BOTAN_ARG_CHECK(expr, msg)
static std::unique_ptr< HashFunction > create(std::string_view algo_spec, std::string_view provider="")
void check_batch_args(std::span< std::span< uint8_t > > outputs, std::span< std::span< const uint8_t > > inputs1, std::span< std::span< const uint8_t > > inputs2) const
std::span< const uint8_t > common_prefix() const
static std::unique_ptr< Hash_Engine > create_or_throw(std::string_view hash_fn, std::span< const uint8_t > common_prefix={}, std::string_view provider="")
static std::vector< std::string > possible_providers(std::string_view hash_fn)
virtual size_t output_length() const =0
static std::unique_ptr< Hash_Engine > create_or_null(std::string_view hash_fn, std::span< const uint8_t > common_prefix={}, std::string_view provider="")
virtual std::string provider() const =0
static Thread_Pool & global_instance()
std::unique_ptr< Hash_Engine > create_sha2_32_mb_engine(std::string_view hash_fn, std::span< const uint8_t > common_prefix, std::string_view provider)
BOTAN_FORCE_INLINE constexpr T ceil_division(T a, T b)
std::unique_ptr< Hash_Engine > create_sha2_64_mb_engine(std::string_view hash_fn, std::span< const uint8_t > common_prefix, std::string_view provider)
std::unique_ptr< Hash_Engine > create_keccak_mb_engine(std::string_view hash_fn, std::span< const uint8_t > common_prefix, std::string_view provider)