hash_accel.hpp

Go to the documentation of this file.

#ifndef SECP256K1_HASH_ACCEL_HPP
#define SECP256K1_HASH_ACCEL_HPP
#pragma once
 
// ============================================================================
// Accelerated Hashing -- SHA-256 / RIPEMD-160 / Hash160
// ============================================================================
//
// ## Three tiers of acceleration (runtime-detected):
//
//   Tier 0: SCALAR   -- Portable C++ (baseline, always available)
//   Tier 1: ARM SHA2 -- ARMv8 SHA-256 instructions (single-message HW accel)
//   Tier 2: SHA-NI   -- Intel SHA Extensions (single-message HW accel, ~3-5x)
//   Tier 3: AVX2     -- 4-way multi-buffer SHA-256 (interleaved, ~8-12x)
//                       + optimized RIPEMD-160 with BMI/BMI2
//   Tier 4: AVX-512  -- 8-way multi-buffer SHA-256 (if available, ~16x)
//
// ## Hot-path API for search pipeline:
//
//   Compressed pubkey (33 bytes) -> SHA-256 -> RIPEMD-160 = Hash160 (20 bytes)
//
//   - hash160_single():       single pubkey -> 20 bytes
//   - hash160_batch():        N pubkeys -> Nx20 bytes (multi-buffer SIMD)
//   - sha256_33():            SHA-256 of exactly 33 bytes (pubkey-optimized)
//   - ripemd160_32():         RIPEMD-160 of exactly 32 bytes (SHA output)
//
// ## Pubkey-specific optimization:
//
//   SHA-256(33 bytes) always produces exactly 1 block (33 + 1 + 22 + 8 = 64).
//   The padding is constant and can be precomputed. This eliminates all
//   branching, length encoding, and buffer management from the hot path.
//
// ============================================================================
 
#include <array>
#include <cstdint>
#include <cstddef>
 
// Architecture detection (must match hash_accel.cpp)
#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
    #ifndef SECP256K1_X86_TARGET
        #define SECP256K1_X86_TARGET 1
    #endif
#endif
 
namespace secp256k1::hash {
 
// -- Feature Detection --------------------------------------------------------
 
enum class HashTier : int {
    SCALAR  = 0,
    ARM_SHA2 = 1, // ARMv8 SHA-256 instructions
    SHA_NI  = 2,  // Intel SHA Extensions
    AVX2    = 3,  // 4-way multi-buffer
    AVX512  = 4,  // 8-way multi-buffer
};
 
HashTier detect_hash_tier() noexcept;
 
const char* hash_tier_name(HashTier tier) noexcept;
 
bool sha_ni_available() noexcept;
bool avx2_available() noexcept;
bool avx512_available() noexcept;
 
// -- Single-message SHA-256 ---------------------------------------------------
 
std::array<std::uint8_t, 32> sha256(const void* data, std::size_t len) noexcept;
 
void sha256_33(const std::uint8_t* pubkey33, std::uint8_t* out32) noexcept;
 
void sha256_32(const std::uint8_t* in32, std::uint8_t* out32) noexcept;
 
std::array<std::uint8_t, 32> sha256d(const void* data, std::size_t len) noexcept;
 
// -- Single-message RIPEMD-160 ------------------------------------------------
 
std::array<std::uint8_t, 20> ripemd160(const void* data, std::size_t len) noexcept;
 
void ripemd160_32(const std::uint8_t* in32, std::uint8_t* out20) noexcept;
 
// -- Hash160 -- RIPEMD160(SHA256(data)) ----------------------------------------
 
std::array<std::uint8_t, 20> hash160(const void* data, std::size_t len) noexcept;
 
void hash160_33(const std::uint8_t* pubkey33, std::uint8_t* out20) noexcept;
 
// -- Batch operations (multi-buffer SIMD) -------------------------------------
//
// Process multiple independent messages simultaneously using SIMD lanes.
// AVX2: 4 messages per cycle, AVX-512: 8 messages per cycle.
// Falls back to sequential scalar/SHA-NI when SIMD unavailable.
//
// All batch functions expect contiguous arrays:
//   - Input:  pubkeys[count * 33] (packed, no gaps)
//   - Output: hashes[count * output_size] (packed, no gaps)
//
// Hot-path contract: No heap allocation if scratch is pre-sized.
 
void sha256_33_batch(
    const std::uint8_t* pubkeys,    // count x 33 bytes (packed)
    std::uint8_t* out32s,           // count x 32 bytes output
    std::size_t count) noexcept;
 
void ripemd160_32_batch(
    const std::uint8_t* in32s,      // count x 32 bytes
    std::uint8_t* out20s,           // count x 20 bytes output
    std::size_t count) noexcept;
 
void hash160_33_batch(
    const std::uint8_t* pubkeys,    // count x 33 bytes (packed)
    std::uint8_t* out20s,           // count x 20 bytes output
    std::size_t count) noexcept;
 
// -- Implementation selectors (for benchmarking / testing) --------------------
// These bypass auto-detection to force a specific tier.
 
namespace scalar {
    void sha256_compress(const std::uint8_t block[64], std::uint32_t state[8]) noexcept;
    void sha256_33(const std::uint8_t* pubkey33, std::uint8_t* out32) noexcept;
    void sha256_32(const std::uint8_t* in32, std::uint8_t* out32) noexcept;
    void ripemd160_compress(const std::uint8_t block[64], std::uint32_t state[5]) noexcept;
    void ripemd160_32(const std::uint8_t* in32, std::uint8_t* out20) noexcept;
    void hash160_33(const std::uint8_t* pubkey33, std::uint8_t* out20) noexcept;
}
 
#ifdef SECP256K1_X86_TARGET
namespace shani {
    void sha256_compress(const std::uint8_t block[64], std::uint32_t state[8]) noexcept;
    void sha256_33(const std::uint8_t* pubkey33, std::uint8_t* out32) noexcept;
    void sha256_32(const std::uint8_t* in32, std::uint8_t* out32) noexcept;
    void hash160_33(const std::uint8_t* pubkey33, std::uint8_t* out20) noexcept;
}
#endif
 
} // namespace secp256k1::hash
 
#endif // SECP256K1_HASH_ACCEL_HPP