perf(zkatdlog): add UnboundedExecutor and WorkerPoolExecutor with constructor injection (#1497)

Signed-off-by: Ankit Basu <ankitbasu14@gmail.com>

Author: neetance

token/core/zkatdlog/nogh/v1/crypto/rp/bulletproof/ipa.go

@@ -12,7 +12,7 @@ import (
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/common/encoding/asn1"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/crypto/common"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/crypto/math"
-	"github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/crypto/rp"
+	rp "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/crypto/rp/executor"
 )
 
 // IPA contains the proof for the inner product argument.
@@ -111,9 +111,14 @@ type ipaProver struct {
 	NumberOfRounds uint64
 	// Curve is the mathematical curve.
 	Curve *mathlib.Curve
+	// Provider creates a fresh Executor for each Prove call.
+	// If nil, DefaultProvider (SerialProvider) is used.
+	Provider rp.ExecutorProvider
 }
 
 // NewIPAProver returns a new ipaProver instance.
+// exec controls how generator reduction is parallelised; pass nil
+// to use SerialExecutor (equivalent to the previous behaviour).
 func NewIPAProver(
 	innerProduct *mathlib.Zr,
 	leftVector, rightVector []*mathlib.Zr,
@@ -122,7 +127,12 @@ func NewIPAProver(
 	Commitment *mathlib.G1,
 	rounds uint64,
 	c *mathlib.Curve,
+	provider rp.ExecutorProvider,
 ) *ipaProver {
+	if provider == nil {
+		provider = rp.DefaultProvider
+	}
+
 	return &ipaProver{
 		InnerProduct:    innerProduct,
 		rightVector:     rightVector,
@@ -133,6 +143,7 @@ func NewIPAProver(
 		NumberOfRounds:  rounds,
 		Commitment:      Commitment,
 		Q:               Q,
+		Provider:        provider,
 	}
 }
 
@@ -206,7 +217,7 @@ func (p *ipaProver) reduce(X, com *mathlib.G1) (*mathlib.Zr, *mathlib.Zr, []*mat
 		xInv.InvModOrder()
 
 		// reduce the generators by 1/2, as a function of the old generators and x and 1/x
-		leftGen, rightGen = reduceGenerators(leftGen, rightGen, x, xInv)
+		leftGen, rightGen = reduceGenerators(leftGen, rightGen, x, xInv, p.Provider)
 
 		// reduce the vectors by 1/2, a function of the old vectors and x and 1/x
 		left, right = reduceVectors(left, right, x, xInv, p.Curve)
@@ -241,17 +252,27 @@ type ipaVerifier struct {
 	NumberOfRounds uint64
 	// Curve is the mathematical curve.
 	Curve *mathlib.Curve
+	// Provider creates a fresh Executor for each Prove call.
+	// If nil, DefaultProvider (SerialProvider) is used.
+	Provider rp.ExecutorProvider
 }
 
 // NewIPAVerifier returns an ipaVerifier instance.
+// exec controls how generator reduction is parallelised; pass nil
+// to use SerialExecutor (equivalent to the previous behaviour).
 func NewIPAVerifier(
 	innerProduct *mathlib.Zr,
 	Q *mathlib.G1,
 	leftGens, rightGens []*mathlib.G1,
 	Commitment *mathlib.G1,
 	rounds uint64,
 	c *mathlib.Curve,
+	provider rp.ExecutorProvider,
 ) *ipaVerifier {
+	if provider == nil {
+		provider = rp.DefaultProvider
+	}
+
 	return &ipaVerifier{
 		InnerProduct:    innerProduct,
 		RightGenerators: rightGens,
@@ -260,6 +281,7 @@ func NewIPAVerifier(
 		NumberOfRounds:  rounds,
 		Commitment:      Commitment,
 		Q:               Q,
+		Provider:        provider,
 	}
 }
 
@@ -384,22 +406,21 @@ func reduceVectors(left, right []*mathlib.Zr, x, xInv *mathlib.Zr, c *mathlib.Cu
 
 // reduceGenerators reduces the number of generators passed in the parameters by 1/2,
 // as a function of the old generators,  x and 1/x
-func reduceGenerators(leftGen, rightGen []*mathlib.G1, x, xInv *mathlib.Zr) ([]*mathlib.G1, []*mathlib.G1) {
+func reduceGenerators(leftGen, rightGen []*mathlib.G1, x, xInv *mathlib.Zr, provider rp.ExecutorProvider) ([]*mathlib.G1, []*mathlib.G1) {
 	l := len(leftGen) / 2
 	// Use the Executor abstraction so that the execution strategy can be
 	// swapped without changing this function. SerialExecutor runs each task
 	// immediately with no locks or goroutine overhead.
-	executor := rp.NewSerialExecutor()
-
+	exec := provider.New()
 	for i := range l {
-		executor.Submit(func() {
+		exec.Submit(func() {
 			// G_i = G_i^{x_inv} * G_{i+l}^x
 			leftGen[i].Mul2InPlace(xInv, leftGen[i+l], x)
 			// H_i = H_i^x * H_{i+l}^{x_inv}
 			rightGen[i].Mul2InPlace(x, rightGen[i+l], xInv)
 		})
 	}
-	executor.Wait()
+	exec.Wait()
 
 	return leftGen[:l], rightGen[:l]
 }

token/core/zkatdlog/nogh/v1/crypto/rp/bulletproof/ipa_test.go

@@ -83,6 +83,7 @@ func TestIPAProofVerify(t *testing.T) {
 		setup.com,
 		setup.nr,
 		setup.curve,
+		nil,
 	)
 	proof, err := prover.Prove()
 	require.NoError(t, err)
@@ -96,6 +97,7 @@ func TestIPAProofVerify(t *testing.T) {
 		setup.com,
 		setup.nr,
 		setup.curve,
+		nil,
 	)
 	err = verifier.Verify(proof)
 	require.NoError(t, err)
@@ -126,6 +128,7 @@ func BenchmarkIPAProver(b *testing.B) {
 				setup.com,
 				setup.nr,
 				setup.curve,
+				nil,
 			)
 			proof, err := prover.Prove()
 			require.NoError(b, err)
@@ -154,6 +157,7 @@ func TestParallelIPAProver(t *testing.T) {
 				setup.com,
 				setup.nr,
 				setup.curve,
+				nil,
 			)
 			_, err := prover.Prove()
 

token/core/zkatdlog/nogh/v1/crypto/rp/bulletproof/rangecorrectness.go

@@ -10,7 +10,7 @@ import (
 	math "github.com/IBM/mathlib"
 	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/common/encoding/asn1"
-	"github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/crypto/rp"
+	rp "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/crypto/rp/executor"
 )
 
 // RangeCorrectness contains a set of range proofs for multiple commitments.
@@ -85,9 +85,14 @@ type RangeCorrectnessProver struct {
 	Q *math.G1
 	// Curve is the mathematical curve.
 	Curve *math.Curve
+	// Provider creates a fresh Executor for each Prove call.
+	// If nil, DefaultProvider (SerialProvider) is used.
+	Provider rp.ExecutorProvider
 }
 
-// NewRangeCorrectnessProver returns a new RangeCorrectnessProver instance.
+// NewRangeCorrectnessProver returns a new RangeCorrectnessProver.
+// exec controls how independent range proofs are executed; pass nil
+// to use SerialExecutor (equivalent to the previous behaviour).
 func NewRangeCorrectnessProver(
 	coms []*math.G1,
 	values []uint64,
@@ -96,7 +101,12 @@ func NewRangeCorrectnessProver(
 	P, Q *math.G1,
 	bitLength, rounds uint64,
 	c *math.Curve,
+	provider rp.ExecutorProvider,
 ) *RangeCorrectnessProver {
+	if provider == nil {
+		provider = rp.DefaultProvider
+	}
+
 	return &RangeCorrectnessProver{
 		Commitments:        coms,
 		Values:             values,
@@ -109,6 +119,7 @@ func NewRangeCorrectnessProver(
 		BitLength:          bitLength,
 		NumberOfRounds:     rounds,
 		Curve:              c,
+		Provider:           provider,
 	}
 }
 
@@ -120,8 +131,8 @@ func (p *RangeCorrectnessProver) Prove() (*RangeCorrectness, error) {
 		Proofs: make([]*RangeProof, n),
 	}
 
-	// SerialExecutor runs tasks immediately with no overhead
-	executor := rp.NewSerialExecutor()
+	// Executor controls execution strategy (serial or parallel)
+	executor := p.Provider.New()
 	errs := make([]error, n)
 
 	for i := range n {
@@ -138,6 +149,7 @@ func (p *RangeCorrectnessProver) Prove() (*RangeCorrectness, error) {
 				p.NumberOfRounds,
 				p.BitLength,
 				p.Curve,
+				p.Provider,
 			)
 			rc.Proofs[i], errs[i] = bp.Prove()
 		})
@@ -174,15 +186,25 @@ type RangeCorrectnessVerifier struct {
 	Q *math.G1
 	// Curve is the mathematical curve.
 	Curve *math.Curve
+	// Provider creates a fresh Executor for each Prove call.
+	// If nil, DefaultProvider (SerialProvider) is used.
+	Provider rp.ExecutorProvider
 }
 
-// NewRangeCorrectnessVerifier returns a new RangeCorrectnessVerifier instance.
+// NewRangeCorrectnessVerifier returns a new RangeCorrectnessVerifier.
+// exec controls how independent range proofs are verified; pass nil
+// to use SerialExecutor (equivalent to the previous behaviour).
 func NewRangeCorrectnessVerifier(
 	pedersenParameters, leftGenerators, rightGenerators []*math.G1,
 	P, Q *math.G1,
 	bitLength, rounds uint64,
 	curve *math.Curve,
+	provider rp.ExecutorProvider,
 ) *RangeCorrectnessVerifier {
+	if provider == nil {
+		provider = rp.DefaultProvider
+	}
+
 	return &RangeCorrectnessVerifier{
 		PedersenParameters: pedersenParameters,
 		LeftGenerators:     leftGenerators,
@@ -192,6 +214,7 @@ func NewRangeCorrectnessVerifier(
 		BitLength:          bitLength,
 		NumberOfRounds:     rounds,
 		Curve:              curve,
+		Provider:           provider,
 	}
 }
 
@@ -202,7 +225,7 @@ func (v *RangeCorrectnessVerifier) Verify(rc *RangeCorrectness) error {
 	}
 
 	n := len(rc.Proofs)
-	executor := rp.NewSerialExecutor()
+	executor := v.Provider.New()
 	errs := make([]error, n)
 
 	for i := range n {
@@ -223,6 +246,7 @@ func (v *RangeCorrectnessVerifier) Verify(rc *RangeCorrectness) error {
 				v.NumberOfRounds,
 				v.BitLength,
 				v.Curve,
+				v.Provider,
 			)
 
 			errs[i] = bv.Verify(rc.Proofs[i])

token/core/zkatdlog/nogh/v1/crypto/rp/bulletproof/rangecorrectness_test.go

@@ -51,6 +51,7 @@ func TestRangeCorrectness(t *testing.T) {
 		bitLength,
 		rounds,
 		curve,
+		nil,
 	)
 
 	rc, err := prover.Prove()
@@ -80,6 +81,7 @@ func TestRangeCorrectness(t *testing.T) {
 		bitLength,
 		rounds,
 		curve,
+		nil,
 	)
 	// We need to manually set commitments because NewRangeCorrectnessVerifier doesn't take them
 	verifier.Commitments = commitments

token/core/zkatdlog/nogh/v1/crypto/rp/bulletproof/rp.go

@@ -12,6 +12,7 @@ import (
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/common/encoding/asn1"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/crypto/common"
 	math2 "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/crypto/math"
+	rp "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/crypto/rp/executor"
 )
 
 // RangeProofData contains the elements of a Bulletproof-style range proof.
@@ -199,6 +200,9 @@ type rangeProver struct {
 	BitLength uint64
 	// Curve is the mathematical curve.
 	Curve *math.Curve
+	// Provider creates a fresh Executor for each Prove call.
+	// If nil, DefaultProvider (SerialProvider) is used.
+	Provider rp.ExecutorProvider
 }
 
 // NewRangeProver returns a rangeProver based on  the passed arguments
@@ -212,6 +216,7 @@ func NewRangeProver(
 	P, Q *math.G1,
 	numberOfRounds, bitLength uint64,
 	curve *math.Curve,
+	provider rp.ExecutorProvider,
 ) *rangeProver {
 	return &rangeProver{
 		Commitment:           com,
@@ -225,6 +230,7 @@ func NewRangeProver(
 		NumberOfRounds:       numberOfRounds,
 		BitLength:            bitLength,
 		Curve:                curve,
+		Provider:             provider,
 	}
 }
 
@@ -263,6 +269,7 @@ func (p *rangeProver) Prove() (*RangeProof, error) {
 		com,
 		p.NumberOfRounds,
 		p.Curve,
+		p.Provider,
 	)
 	rp.IPA, err = ipp.Prove()
 	if err != nil {
@@ -442,6 +449,9 @@ type rangeVerifier struct {
 	BitLength uint64
 	// Curve is the mathematical curve.
 	Curve *math.Curve
+	// Provider creates a fresh Executor for each Prove call.
+	// If nil, DefaultProvider (SerialProvider) is used.
+	Provider rp.ExecutorProvider
 }
 
 // NewRangeVerifier returns a rangeVerifier based on the passed arguments
@@ -453,6 +463,7 @@ func NewRangeVerifier(
 	P, Q *math.G1,
 	numberOfRounds, bitLength uint64,
 	curve *math.Curve,
+	provider rp.ExecutorProvider,
 ) *rangeVerifier {
 	return &rangeVerifier{
 		Commitment:           com,
@@ -464,6 +475,7 @@ func NewRangeVerifier(
 		NumberOfRounds:       numberOfRounds,
 		BitLength:            bitLength,
 		Curve:                curve,
+		Provider:             provider,
 	}
 }
 
@@ -619,6 +631,7 @@ func (v *rangeVerifier) verifyIPA(rp *RangeProof, x *math.Zr, yPow []*math.Zr, z
 		com,
 		v.NumberOfRounds,
 		v.Curve,
+		v.Provider,
 	)
 
 	return ipv.Verify(rp.IPA)

token/core/zkatdlog/nogh/v1/crypto/rp/bulletproof/rp_internal_test.go

@@ -196,7 +196,7 @@ func TestRangeProofDeserializeError(t *testing.T) {
 
 func TestRangeVerifier_VerifyError(t *testing.T) {
 	curve := math.Curves[math.BN254]
-	verifier := NewRangeVerifier(curve.GenG1, []*math.G1{curve.GenG1}, nil, nil, curve.GenG1, curve.GenG1, 1, 1, curve)
+	verifier := NewRangeVerifier(curve.GenG1, []*math.G1{curve.GenG1}, nil, nil, curve.GenG1, curve.GenG1, 1, 1, curve, nil)
 
 	proof := &RangeProof{
 		Data: &RangeProofData{},