Skip to content

Commit aae2e1c

Browse files
ale-linuxale-linux
committed
Parallel benchmarks and microbenchmarks
Signed-off-by: Alessandro Sorniotti <aso@zurich.ibm.com>
1 parent 1d83015 commit aae2e1c

File tree

1 file changed

+172
-46
lines changed

1 file changed

+172
-46
lines changed

‎perf_test.go‎

Lines changed: 172 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -27,35 +27,27 @@ func newRandZr(rng io.Reader, m *big.Int) *big.Int {
2727
return bi
2828
}
2929

30-
func blsInit(b *testing.B, curve *Curve) (*G1, *G2, *Zr, error) {
30+
func blsInit(b *testing.B, curve *Curve) (*G2, *Zr, error) {
3131
rng, err := curve.Rand()
3232
if err != nil {
33-
return nil, nil, nil, err
33+
return nil, nil, err
3434
}
3535

3636
g := curve.GenG2.Mul(curve.NewRandomZr(rng))
37-
g = curve.GenG2.Mul(curve.NewZrFromInt(35))
38-
h := curve.GenG1.Mul(curve.NewRandomZr(rng))
39-
h = curve.GenG1.Mul(curve.NewZrFromInt(135))
4037
x := curve.NewRandomZr(rng)
41-
x = curve.NewZrFromInt(20)
4238

43-
return h, g, x, nil
39+
return g, x, nil
4440
}
4541

46-
func blsInitGurvy(b *testing.B) (*bls12381.G1Affine, *bls12381.G2Affine, *big.Int) {
42+
func blsInitGurvy(b *testing.B) (*bls12381.G2Affine, *big.Int) {
4743
rng := rand.Reader
4844

49-
_, _, g1, g2 := bls12381.Generators()
45+
_, _, _, g2 := bls12381.Generators()
5046

51-
// g := g2.ScalarMultiplication(&g2, newRandZr(rng, fr.Modulus()))
52-
g := g2.ScalarMultiplication(&g2, big.NewInt(35))
53-
// h := g1.ScalarMultiplication(&g1, newRandZr(rng, fr.Modulus()))
54-
h := g1.ScalarMultiplication(&g1, big.NewInt(135))
47+
g := g2.ScalarMultiplication(&g2, newRandZr(rng, fr.Modulus()))
5548
x := newRandZr(rng, fr.Modulus())
56-
x = big.NewInt(20)
5749

58-
return h, g, x
50+
return g, x
5951
}
6052

6153
func pokPedersenCommittmentInit(b *testing.B, curve *Curve) (io.Reader, *G1, *G1, *Zr, error) {
@@ -221,59 +213,193 @@ func Benchmark_PedersenCommitmentPoK(b *testing.B) {
221213
}
222214

223215
func Benchmark_BLSGurvy(b *testing.B) {
224-
h, g, x := blsInitGurvy(b)
216+
g, x := blsInitGurvy(b)
217+
pk := new(bls12381.G2Affine).ScalarMultiplication(g, x)
225218

226219
b.ResetTimer()
227220

228-
b.Run("curve BLS12_381_GURVY (direct)", func(b *testing.B) {
229-
230-
for i := 0; i < b.N; i++ {
231-
pk := new(bls12381.G2Affine).ScalarMultiplication(g, x)
232-
sig := new(bls12381.G1Affine).ScalarMultiplication(h, x)
233-
234-
sig.Neg(sig)
221+
var sig *bls12381.G1Affine
222+
223+
for _, parallelism := range []int{1, 2, 4, 8, 16, 32, 96} {
224+
b.Run(fmt.Sprintf("sign curve BLS12_381_GURVY (direct)-p%d", parallelism), func(b *testing.B) {
225+
b.RunParallel(func(pb *testing.PB) {
226+
for pb.Next() {
227+
h, err := bls12381.HashToG1([]byte("msg"), []byte("context"))
228+
if err != nil {
229+
panic(err)
230+
}
231+
sig = new(bls12381.G1Affine).ScalarMultiplication(&h, x)
232+
}
233+
})
234+
})
235+
}
235236

236-
t, err := bls12381.MillerLoop([]bls12381.G1Affine{*sig, *h}, []bls12381.G2Affine{*g, *pk})
237-
if err != nil {
238-
panic(err)
239-
}
237+
sig.Neg(sig)
240238

241-
t1 := bls12381.FinalExponentiation(&t)
239+
b.ResetTimer()
242240

243-
unity := &bls12381.GT{}
244-
unity.SetOne()
245-
if !unity.Equal(&t1) {
246-
panic("invalid signature")
247-
}
248-
}
249-
})
241+
for _, parallelism := range []int{1, 2, 4, 8, 16, 32, 96} {
242+
b.Run(fmt.Sprintf("verify curve BLS12_381_GURVY (direct)-p%d", parallelism), func(b *testing.B) {
243+
b.RunParallel(func(pb *testing.PB) {
244+
for pb.Next() {
245+
h, err := bls12381.HashToG1([]byte("msg"), []byte("context"))
246+
if err != nil {
247+
panic(err)
248+
}
249+
250+
t, err := bls12381.MillerLoop([]bls12381.G1Affine{*sig, h}, []bls12381.G2Affine{*g, *pk})
251+
if err != nil {
252+
panic(err)
253+
}
254+
255+
t1 := bls12381.FinalExponentiation(&t)
256+
257+
unity := &bls12381.GT{}
258+
unity.SetOne()
259+
if !unity.Equal(&t1) {
260+
panic("invalid signature")
261+
}
262+
}
263+
})
264+
})
265+
}
250266
}
251267

252268
func Benchmark_BLS(b *testing.B) {
253269

254270
for _, curve := range Curves {
255-
h, g, x, err := blsInit(b, curve)
271+
g, x, err := blsInit(b, curve)
256272
if err != nil {
257273
panic(err)
258274
}
259275

276+
pk := g.Mul(x)
277+
260278
b.ResetTimer()
261279

262-
b.Run(fmt.Sprintf("curve %s", CurveIDToString(curve.curveID)), func(b *testing.B) {
280+
var sig *G1
281+
282+
for _, parallelism := range []int{1, 2, 4, 8, 16, 32, 96} {
283+
b.Run(fmt.Sprintf("sign curve %s-p%d", CurveIDToString(curve.curveID), parallelism), func(b *testing.B) {
284+
b.RunParallel(func(pb *testing.PB) {
285+
for pb.Next() {
286+
for i := 0; i < b.N; i++ {
287+
h := curve.HashToG1WithDomain([]byte("msg"), []byte("context"))
288+
sig = h.Mul(x)
289+
}
290+
}
291+
})
292+
})
293+
}
263294

264-
for i := 0; i < b.N; i++ {
265-
pk := g.Mul(x)
266-
sig := h.Mul(x)
295+
sig.Neg()
296+
297+
for _, parallelism := range []int{1, 2, 4, 8, 16, 32, 96} {
298+
b.Run(fmt.Sprintf("verify curve %s-p%d", CurveIDToString(curve.curveID), parallelism), func(b *testing.B) {
299+
b.RunParallel(func(pb *testing.PB) {
300+
for pb.Next() {
301+
for i := 0; i < b.N; i++ {
302+
h := curve.HashToG1WithDomain([]byte("msg"), []byte("context"))
303+
304+
p := curve.Pairing2(g, sig, pk, h)
305+
306+
p = curve.FExp(p)
307+
if !p.IsUnity() {
308+
panic("invalid signature")
309+
}
310+
}
311+
}
312+
})
313+
})
314+
}
315+
}
316+
}
317+
318+
func Benchmark_IndividualOps(b *testing.B) {
319+
curve := Curves[BLS12_381_GURVY]
320+
g_gurv, x_gurv := blsInitGurvy(b)
321+
g_math, x_math, err := blsInit(b, curve)
322+
if err != nil {
323+
panic(err)
324+
}
267325

268-
sig.Neg()
326+
pk_gurv := new(bls12381.G2Affine).ScalarMultiplication(g_gurv, x_gurv)
327+
pk_math := g_math.Mul(x_math)
269328

270-
p := curve.Pairing2(g, sig, pk, h)
329+
var h_gurv bls12381.G1Affine
330+
var h_math *G1
271331

272-
p = curve.FExp(p)
273-
if !p.IsUnity() {
274-
panic("invalid signature")
332+
var sig_gurv *bls12381.G1Affine
333+
var sig_math *G1
334+
335+
var t_gurv bls12381.GT
336+
var t_math *Gt
337+
338+
for _, parallelism := range []int{1, 2, 4, 8, 16, 32, 96} {
339+
b.Run(fmt.Sprintf("hash/gurvy-p%d", parallelism), func(b *testing.B) {
340+
b.RunParallel(func(pb *testing.PB) {
341+
for pb.Next() {
342+
h_gurv, _ = bls12381.HashToG1([]byte("msg"), []byte("context"))
275343
}
276-
}
344+
})
345+
})
346+
}
347+
348+
for _, parallelism := range []int{1, 2, 4, 8, 16, 32, 96} {
349+
b.Run(fmt.Sprintf("hash/mathlib-p%d", parallelism), func(b *testing.B) {
350+
b.RunParallel(func(pb *testing.PB) {
351+
for pb.Next() {
352+
h_math = curve.HashToG1WithDomain([]byte("msg"), []byte("context"))
353+
}
354+
})
355+
})
356+
}
357+
358+
for _, parallelism := range []int{1, 2, 4, 8, 16, 32, 96} {
359+
b.Run(fmt.Sprintf("sign/gurvy-p%d", parallelism), func(b *testing.B) {
360+
b.RunParallel(func(pb *testing.PB) {
361+
for pb.Next() {
362+
sig_gurv = new(bls12381.G1Affine).ScalarMultiplication(&h_gurv, x_gurv)
363+
}
364+
})
365+
})
366+
}
367+
368+
for _, parallelism := range []int{1, 2, 4, 8, 16, 32, 96} {
369+
b.Run(fmt.Sprintf("sign/mathlib-p%d", parallelism), func(b *testing.B) {
370+
b.RunParallel(func(pb *testing.PB) {
371+
for pb.Next() {
372+
sig_math = h_math.Mul(x_math)
373+
}
374+
})
375+
})
376+
}
377+
378+
for _, parallelism := range []int{1, 2, 4, 8, 16, 32, 96} {
379+
b.Run(fmt.Sprintf("pairing2/gurvy-p%d", parallelism), func(b *testing.B) {
380+
b.RunParallel(func(pb *testing.PB) {
381+
for pb.Next() {
382+
383+
t_gurv, err = bls12381.MillerLoop([]bls12381.G1Affine{*sig_gurv, h_gurv}, []bls12381.G2Affine{*g_gurv, *pk_gurv})
384+
if err != nil {
385+
panic(err)
386+
}
387+
388+
t_gurv = bls12381.FinalExponentiation(&t_gurv)
389+
}
390+
})
391+
})
392+
}
393+
394+
for _, parallelism := range []int{1, 2, 4, 8, 16, 32, 96} {
395+
b.Run(fmt.Sprintf("pairing2/mathlib-p%d", parallelism), func(b *testing.B) {
396+
b.RunParallel(func(pb *testing.PB) {
397+
for pb.Next() {
398+
t_math = curve.Pairing2(g_math, sig_math, pk_math, h_math)
399+
400+
t_math = curve.FExp(t_math)
401+
}
402+
})
277403
})
278404
}
279405
}

0 commit comments

Comments
 (0)