test: benchmark different prngs

Author: lehugueni

ring/ring_benchmark_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/stretchr/testify/require"
 	"github.com/tuneinsight/lattigo/v6/utils/bignum"
+	"github.com/tuneinsight/lattigo/v6/utils/sampling"
 )
 
 func BenchmarkRing(b *testing.B) {
@@ -88,6 +89,108 @@ func benchSampling(tc *testParams, b *testing.B) {
 			sampler.Read(pol)
 		}
 	})
+	b.Run(testString("Sampling/ThreadSafePRNGNaive/Gaussian", tc.ringQ), func(b *testing.B) {
+
+		prng := &sampling.ThreadSafePRNGNaive{}
+		sampler, err := NewSampler(prng, tc.ringQ, DiscreteGaussian{Sigma: DefaultSigma, Bound: DefaultBound}, false)
+		require.NoError(b, err)
+
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				sampler.Read(pol)
+			}
+		})
+	})
+	b.Run(testString("Sampling/ThreadSafeShallowCopy/Gaussian", tc.ringQ), func(b *testing.B) {
+
+		b.RunParallel(func(pb *testing.PB) {
+			prng, _ := sampling.NewPRNG()
+			sampler, _ := NewSampler(prng, tc.ringQ, DiscreteGaussian{Sigma: DefaultSigma, Bound: DefaultBound}, false)
+			for pb.Next() {
+				sampler.Read(pol)
+			}
+		})
+	})
+	b.Run(testString("Sampling/ThreadSafePRNG/Gaussian", tc.ringQ), func(b *testing.B) {
+
+		prng, err := sampling.NewThreadSafePRNG()
+		sampler, err := NewSampler(prng, tc.ringQ, DiscreteGaussian{Sigma: DefaultSigma, Bound: DefaultBound}, false)
+		require.NoError(b, err)
+
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				sampler.Read(pol)
+			}
+		})
+	})
+	b.Run(testString("Sampling/ThreadSafePRNGNaive/Uniform", tc.ringQ), func(b *testing.B) {
+
+		prng := &sampling.ThreadSafePRNGNaive{}
+		sampler, err := NewSampler(prng, tc.ringQ, Uniform{}, true)
+		require.NoError(b, err)
+
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				sampler.Read(pol)
+			}
+		})
+	})
+	b.Run(testString("Sampling/ThreadSafeShallowCopy/Uniform", tc.ringQ), func(b *testing.B) {
+
+		b.RunParallel(func(pb *testing.PB) {
+			prng, _ := sampling.NewPRNG()
+			sampler, _ := NewSampler(prng, tc.ringQ, Uniform{}, true)
+			for pb.Next() {
+				sampler.Read(pol)
+			}
+		})
+	})
+	b.Run(testString("Sampling/ThreadSafePRNG/Uniform", tc.ringQ), func(b *testing.B) {
+
+		prng, err := sampling.NewThreadSafePRNG()
+		sampler, err := NewSampler(prng, tc.ringQ, Uniform{}, true)
+		require.NoError(b, err)
+
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				sampler.Read(pol)
+			}
+		})
+	})
+	b.Run(testString("Sampling/ThreadSafePRNGNaive/Ternary/0.3", tc.ringQ), func(b *testing.B) {
+
+		prng := &sampling.ThreadSafePRNGNaive{}
+		sampler, err := NewSampler(prng, tc.ringQ, Ternary{P: 1.0 / 3}, true)
+		require.NoError(b, err)
+
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				sampler.Read(pol)
+			}
+		})
+	})
+	b.Run(testString("Sampling/ThreadSafeShallowCopy/Ternary/0.3", tc.ringQ), func(b *testing.B) {
+
+		b.RunParallel(func(pb *testing.PB) {
+			prng, _ := sampling.NewPRNG()
+			sampler, _ := NewSampler(prng, tc.ringQ, Ternary{P: 1.0 / 3}, true)
+			for pb.Next() {
+				sampler.Read(pol)
+			}
+		})
+	})
+	b.Run(testString("Sampling/ThreadSafePRNG/Ternary/0.3", tc.ringQ), func(b *testing.B) {
+
+		prng, err := sampling.NewThreadSafePRNG()
+		sampler, err := NewSampler(prng, tc.ringQ, Ternary{P: 1.0 / 3}, true)
+		require.NoError(b, err)
+
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				sampler.Read(pol)
+			}
+		})
+	})
 
 	b.Run(testString("Sampling/Ternary/0.3", tc.ringQ), func(b *testing.B) {
 

ring/sampler_uniform.go

@@ -45,14 +45,14 @@ func (u *UniformSampler) read(pol Poly, f func(a, b, c uint64) uint64) {
 	level := u.baseRing.Level()
 
 	var randomUint, mask, qi uint64
-	var buffer [1024]byte
+	buffer := make([]byte, 1024)
 
 	prng := u.prng
 	N := u.baseRing.N()
 	byteArrayLength := len(buffer)
 
 	var ptr int
-	if _, err := prng.Read(buffer[:]); err != nil {
+	if _, err := prng.Read(buffer); err != nil {
 		// Sanity check, this error should not happen.
 		panic(err)
 	}
@@ -74,7 +74,7 @@ func (u *UniformSampler) read(pol Poly, f func(a, b, c uint64) uint64) {
 
 				// Refills the buff if it runs empty
 				if ptr == byteArrayLength {
-					if _, err := u.prng.Read(buffer[:]); err != nil {
+					if _, err := u.prng.Read(buffer); err != nil {
 						// Sanity check, this error should not happen.
 						panic(err)
 					}

utils/sampling/prng.go

@@ -25,6 +25,26 @@ type KeyedPRNG struct {
 	xof blake2b.XOF
 }
 
+type ThreadSafePRNGNaive struct {
+}
+
+func NewThreadSafePRNGNaive() (*ThreadSafePRNGNaive, error) {
+	return &ThreadSafePRNGNaive{}, nil
+}
+
+func (prng *ThreadSafePRNGNaive) Read(sum []byte) (n int, err error) {
+	key := make([]byte, 64)
+	if _, err := rand.Read(key); err != nil {
+		return 0, fmt.Errorf("crypto rand error: %w", err)
+	}
+	tmpPRNG := sha3.NewShake256()
+	_, err = tmpPRNG.Write(key)
+	if err != nil {
+		return 0, fmt.Errorf("crypto rand error: %w", err)
+	}
+	return tmpPRNG.Read(sum)
+}
+
 type ThreadSafePRNG struct {
 	xof       sha3.ShakeHash
 	atomicCnt atomic.Uint64