chore: revert prover to goroutine path

Author: acud

pkg/bmt/bmt.go

@@ -7,7 +7,6 @@ package bmt
 import (
 	"encoding/binary"
 	"hash"
-	"sync/atomic"
 
 	"github.com/ethersphere/bee/v2/pkg/swarm"
 )
@@ -17,18 +16,12 @@ var (
 	zerosection = make([]byte, 64)
 )
 
-// simdOptIn controls whether NewPool and friends return a SIMD-backed BMT pool.
-// Default is false; cmd/bee flips it on startup after parsing --use-simd-hashing.
-// Accessed via SIMDOptIn / SetSIMDOptIn so concurrent reads during startup are
-// race-free.
-var simdOptIn atomic.Bool
-
 // SIMDOptIn reports whether the SIMD hasher has been opted into.
-func SIMDOptIn() bool { return simdOptIn.Load() }
+var SIMDOptIn func() bool = func() bool { return false }
 
 // SetSIMDOptIn sets the SIMD opt-in flag. Intended to be called once during
 // startup before the first NewPool call (cmd/bee calls it after flag parsing).
-func SetSIMDOptIn(b bool) { simdOptIn.Store(b) }
+func SetSIMDOptIn(b bool) { SIMDOptIn = func() bool { return b } }
 
 // LengthToSpan creates a binary data span size representation.
 // It is required for calculating the BMT hash.

pkg/bmt/hasher_goroutine.go

@@ -108,17 +108,6 @@ func (h *goroutineHasher) Hash(b []byte) ([]byte, error) {
 	}
 }
 
-// HashPadded zero-pads any unwritten sections then computes the BMT root.
-// Required for inclusion-proof generation so the tree is fully populated.
-func (h *goroutineHasher) HashPadded(b []byte) ([]byte, error) {
-	for i := h.size; i < h.maxSize; i += len(zerosection) {
-		if _, err := h.Write(zerosection); err != nil {
-			return nil, err
-		}
-	}
-	return h.Hash(b)
-}
-
 // Reset prepares the Hasher for reuse.
 func (h *goroutineHasher) Reset() {
 	h.pos = 0

pkg/bmt/hasher_simd.go

@@ -116,12 +116,6 @@ func (h *simdHasher) Hash(b []byte) ([]byte, error) {
 	return doHash(h.baseHasher(), h.span, rootHash)
 }
 
-// HashPadded is equivalent to Hash for the SIMD hasher since Hash already
-// zero-fills the buffer. Exposed so the Hasher interface contract is satisfied.
-func (h *simdHasher) HashPadded(b []byte) ([]byte, error) {
-	return h.Hash(b)
-}
-
 // Reset prepares the Hasher for reuse. The internal data buffer is not zeroed;
 // any stale bytes past h.size are overwritten on the next Write and zero-filled
 // on demand by Hash, so post-Reset inspection of the buffer may still see
@@ -130,90 +124,3 @@ func (h *simdHasher) Reset() {
 	h.size = 0
 	copy(h.span, zerospan)
 }
-
-// Proof returns the inclusion proof of the i-th data segment.
-func (h *simdHasher) Proof(i int) Proof {
-	// keep the original (segment-level) index around: callers identify the
-	// segment by its 0..127 position; we divide down to a leaf-node (section)
-	// index below for tree navigation.
-	index := i
-	if i < 0 || i > 127 {
-		panic("segment index can only lie between 0-127")
-	}
-	// two segments share one leaf section (32B + 32B hashed together),
-	// so the leaf-node index is i/2.
-	i = i / 2
-	n := h.bmt.leaves[i]
-	isLeft := n.isLeft
-	// walk from the leaf's parent to the root, collecting the sister hash
-	// at each level along the way.
-	var sisters [][]byte
-	for n = n.parent; n != nil; n = n.parent {
-		sisters = append(sisters, n.getSister(isLeft))
-		isLeft = n.isLeft
-	}
-
-	// copy out the two segments that live in this leaf section. One is the
-	// segment being proven, the other is its immediate sister (the very first
-	// entry in the proof path, below the leaf level).
-	secsize := 2 * h.segmentSize
-	offset := i * secsize
-	section := make([]byte, secsize)
-	copy(section, h.bmt.buffer[offset:offset+secsize])
-	segment, firstSegmentSister := section[:h.segmentSize], section[h.segmentSize:]
-	// if the original index is odd, the proven segment sits on the right,
-	// so swap which half is the segment and which is the sister.
-	if index%2 != 0 {
-		segment, firstSegmentSister = firstSegmentSister, segment
-	}
-	// prepend the in-section sister so the proof list reads leaf-up: the
-	// first hop combines segment with firstSegmentSister, then walks upward.
-	sisters = append([][]byte{firstSegmentSister}, sisters...)
-	return Proof{segment, sisters, h.span, index}
-}
-
-// Verify reconstructs the BMT root from a proof for the i-th segment.
-func (h *simdHasher) Verify(i int, proof Proof) (root []byte, err error) {
-	// rebuild the leaf section (two 32B segments concatenated) in the same
-	// order they were originally hashed. Even index → proven segment on the
-	// left, odd index → proven segment on the right.
-	var section []byte
-	if i%2 == 0 {
-		section = append(append(section, proof.ProveSegment...), proof.ProofSegments[0]...)
-	} else {
-		section = append(append(section, proof.ProofSegments[0]...), proof.ProveSegment...)
-	}
-	// derive the leaf-node index from the segment index, mirroring Proof.
-	i = i / 2
-	n := h.bmt.leaves[i]
-	hasher := h.baseHasher()
-	isLeft := n.isLeft
-	// start by hashing the reconstructed section: this is the leaf-level
-	// hash that the proof path will lift up to the root.
-	root, err = doHash(hasher, section)
-	if err != nil {
-		return nil, err
-	}
-	n = n.parent
-
-	// climb level by level, pairing the running hash with the sister from
-	// the proof. Orientation alternates based on whether we arrived at this
-	// node from its left or right child.
-	for _, sister := range proof.ProofSegments[1:] {
-		if isLeft {
-			root, err = doHash(hasher, root, sister)
-		} else {
-			root, err = doHash(hasher, sister, root)
-		}
-		if err != nil {
-			return nil, err
-		}
-		// advance to the next level; record which side we came from so the
-		// next hash pairs the operands in the correct order.
-		isLeft = n.isLeft
-		n = n.parent
-	}
-	// finally mix in the span to produce the chunk address, matching what
-	// Hash does at the top of the tree.
-	return doHash(hasher, proof.Span, root)
-}

pkg/bmt/interface.go

@@ -16,6 +16,10 @@ const (
 //
 // Any implementation should make it possible to generate a BMT hash using the hash.Hash interface only.
 // However, the limitation will be that the Span of the BMT hash always must be limited to the amount of bytes actually written.
+//
+// Inclusion-proof generation (Proof / Verify / zero-padded Hash) is NOT part of
+// this interface — it lives on the Prover type, which is always goroutine-backed
+// regardless of SIMDOptIn. See pkg/bmt/proof.go.
 type Hasher interface {
 	hash.Hash
 
@@ -30,15 +34,4 @@ type Hasher interface {
 
 	// Capacity returns the maximum amount of bytes that will be processed by the implementation.
 	Capacity() int
-
-	// HashPadded calculates the BMT hash after zero-padding any unwritten sections so
-	// the tree is fully populated. Required for inclusion-proof generation.
-	HashPadded([]byte) ([]byte, error)
-
-	// Proof returns an inclusion proof for the i-th data segment of the last hashed chunk.
-	Proof(i int) Proof
-
-	// Verify reconstructs the BMT root from a proof for the i-th segment. Returns the
-	// computed root hash (caller compares to the expected chunk address).
-	Verify(i int, proof Proof) ([]byte, error)
 }

pkg/bmt/pool_goroutine.go

@@ -106,6 +106,45 @@ func (p *goroutinePool) Put(h Hasher) {
 	p.c <- gh.bmt
 }
 
+// goroutineProverPool is a pool of goroutine-backed Provers. Trees are reused
+// via a channel; the hasher shell is reallocated per GetProver (cheap relative
+// to a tree).
+type goroutineProverPool struct {
+	c chan *goroutineTree
+	*goroutineConf
+}
+
+func newGoroutineProverPool(c *Conf) *goroutineProverPool {
+	gc := newGoroutineConf(c.Prefix, c.SegmentCount, c.Capacity)
+	p := &goroutineProverPool{
+		goroutineConf: gc,
+		c:             make(chan *goroutineTree, gc.capacity),
+	}
+	for i := 0; i < gc.capacity; i++ {
+		p.c <- newGoroutineTree(gc.maxSize, gc.depth, gc.hasherFunc)
+	}
+	return p
+}
+
+// GetProver returns a goroutine-backed Prover, reusing a tree from the pool.
+func (p *goroutineProverPool) GetProver() *Prover {
+	t := <-p.c
+	return &Prover{
+		goroutineHasher: &goroutineHasher{
+			goroutineConf: p.goroutineConf,
+			result:        make(chan []byte),
+			errc:          make(chan error, 1),
+			span:          make([]byte, SpanSize),
+			bmt:           t,
+		},
+	}
+}
+
+// PutProver returns a Prover's tree to the pool for reuse.
+func (p *goroutineProverPool) PutProver(pr *Prover) {
+	p.c <- pr.goroutineHasher.bmt
+}
+
 // goroutineTree is the tree structure used by the goroutine hasher.
 type goroutineTree struct {
 	leaves []*goroutineNode

pkg/bmt/pool_simd.go

@@ -169,15 +169,3 @@ func newSIMDTree(maxsize, depth int, hashfunc func() hash.Hash, prefix []byte) *
 	}
 }
 
-// getSister returns a copy of the sibling section on the opposite side.
-func (n *simdNode) getSister(isLeft bool) []byte {
-	var src []byte
-	if isLeft {
-		src = n.right
-	} else {
-		src = n.left
-	}
-	buf := make([]byte, len(src))
-	copy(buf, src)
-	return buf
-}

pkg/bmt/proof.go

@@ -4,26 +4,68 @@
 
 package bmt
 
-// Prover wraps a BMT Hasher to add Merkle-proof convenience methods.
+// Prover adds Merkle-proof generation and verification on top of a BMT hasher.
 //
 // Proof generation requires the tree to be fully populated, so Prover.Hash
-// zero-pads any unwritten sections before hashing (unlike the bare Hash method
-// on the underlying hasher). Proof and Verify are promoted from the embedded
-// Hasher.
+// zero-pads any unwritten sections before hashing. Prover is always backed by
+// the goroutine BMT implementation, independent of the SIMD opt-in flag:
+// proofs are produced on a rare, redistribution-only code path where the
+// well-tested goroutine implementation is preferred over the SIMD speedup.
+//
+// The embedded *goroutineHasher is package-private, so callers outside
+// pkg/bmt cannot bypass Hash/Sum to skip padding.
 type Prover struct {
-	Hasher
+	*goroutineHasher
 }
 
-// Proof represents a Merkle proof of segment
+// Proof represents a Merkle proof of segment.
 type Proof struct {
 	ProveSegment  []byte
 	ProofSegments [][]byte
 	Span          []byte
 	Index         int
 }
 
-// Hash computes the BMT root with zero-padding, so the proof tree is fully populated.
-// It shadows the embedded Hasher.Hash to preserve the existing Prover API.
-func (p Prover) Hash(b []byte) ([]byte, error) {
-	return p.HashPadded(b)
+// Hash zero-pads any unwritten sections (so every leaf section in the BMT is
+// populated and Proof paths are reconstructible), then computes the BMT root.
+// Shadows the promoted goroutineHasher.Hash.
+func (p *Prover) Hash(b []byte) ([]byte, error) {
+	for i := p.size; i < p.maxSize; i += len(zerosection) {
+		if _, err := p.Write(zerosection); err != nil {
+			return nil, err
+		}
+	}
+	return p.goroutineHasher.Hash(b)
+}
+
+// Sum shadows the promoted goroutineHasher.Sum so Prover used as a hash.Hash
+// also pads. Without this override Sum would call the unpadded Hash and
+// produce a different digest than Prover.Hash.
+func (p *Prover) Sum(b []byte) []byte {
+	s, _ := p.Hash(b)
+	return s
+}
+
+// NewProver returns a Prover backed by a freshly allocated goroutine-based
+// BMT hasher, independent of the SIMD opt-in flag.
+func NewProver() *Prover {
+	return &Prover{goroutineHasher: newGoroutineHasher()}
+}
+
+// NewPrefixProver is NewProver with an optional keccak prefix prepended to every
+// BMT node hash. Also goroutine-backed regardless of SIMDOptIn.
+func NewPrefixProver(prefix []byte) *Prover {
+	return &Prover{goroutineHasher: newGoroutinePrefixHasher(prefix)}
+}
+
+// ProverPool is a pool of goroutine-backed Provers. Ignores SIMDOptIn by design.
+type ProverPool interface {
+	GetProver() *Prover
+	PutProver(*Prover)
+}
+
+// NewProverPool returns a pool of goroutine-backed Provers, independent of
+// SIMDOptIn. See Prover for the rationale.
+func NewProverPool(c *Conf) ProverPool {
+	return newGoroutineProverPool(c)
 }