Skip to content

Commit

Permalink
fix: Change subbenchmark format
Browse files Browse the repository at this point in the history
  • Loading branch information
@sp301415
sp301415 committed Jun 14, 2024
1 parent fe68729 commit dc72b79
Show file tree
Hide file tree
Showing 5 changed files with 233 additions and 215 deletions.
12 changes: 6 additions & 6 deletions math/poly/poly_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,19 +28,19 @@ func BenchmarkFourierOps(b *testing.B) {
fp1.Coeffs[i] = (2*rand.Float64() - 1.0) * math.Exp(63)
}

b.Run(fmt.Sprintf("Add/%v", N), func(b *testing.B) {
b.Run(fmt.Sprintf("op=Add/N=%v", N), func(b *testing.B) {
for i := 0; i < b.N; i++ {
fft.AddAssign(fp0, fp1, fpOut)
}
})

b.Run(fmt.Sprintf("Sub/%v", N), func(b *testing.B) {
b.Run(fmt.Sprintf("op=Sub/N=%v", N), func(b *testing.B) {
for i := 0; i < b.N; i++ {
fft.SubAssign(fp0, fp1, fpOut)
}
})

b.Run(fmt.Sprintf("Mul/%v", N), func(b *testing.B) {
b.Run(fmt.Sprintf("op=Mul/N=%v", N), func(b *testing.B) {
for i := 0; i < b.N; i++ {
fft.MulAssign(fp0, fp1, fpOut)
}
Expand All @@ -61,20 +61,20 @@ func BenchmarkFourierTransform(b *testing.B) {
p.Coeffs[i] = rand.Uint64()
}

b.Run(fmt.Sprintf("ToFourierPoly/%v", N), func(b *testing.B) {
b.Run(fmt.Sprintf("op=ToFourierPoly/N=%v", N), func(b *testing.B) {
for i := 0; i < b.N; i++ {
fft.ToFourierPolyAssign(p, fp)
}
})

x := N / 3
b.Run(fmt.Sprintf("MonomialToFourierPoly/%v", N), func(b *testing.B) {
b.Run(fmt.Sprintf("op=MonomialToFourierPoly/N=%v", N), func(b *testing.B) {
for i := 0; i < b.N; i++ {
fft.MonomialToFourierPolyAssign(x, fp)
}
})

b.Run(fmt.Sprintf("ToPoly/%v", N), func(b *testing.B) {
b.Run(fmt.Sprintf("op=ToPoly/N=%v", N), func(b *testing.B) {
for i := 0; i < b.N; i++ {
fft.ToPolyAssignUnsafe(fp, p)
}
Expand Down
78 changes: 39 additions & 39 deletions mktfhe/binary_mktfhe_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9,18 +9,18 @@ import (
)

var (
testBinaryParams = mktfhe.ParamsBinaryParty4.Compile()
testBinaryEncryptors = []*mktfhe.BinaryEncryptor[uint64]{
mktfhe.NewBinaryEncryptor(testBinaryParams, 0, nil),
mktfhe.NewBinaryEncryptor(testBinaryParams, 1, nil),
paramsBinary = mktfhe.ParamsBinaryParty4.Compile()
encBinary = []*mktfhe.BinaryEncryptor[uint64]{
mktfhe.NewBinaryEncryptor(paramsBinary, 0, nil),
mktfhe.NewBinaryEncryptor(paramsBinary, 1, nil),
}
testBinaryEvaluator = mktfhe.NewBinaryEvaluator(testBinaryParams, map[int]mktfhe.EvaluationKey[uint64]{
0: testBinaryEncryptors[0].GenEvaluationKeyParallel(),
1: testBinaryEncryptors[1].GenEvaluationKeyParallel(),
evalBinary = mktfhe.NewBinaryEvaluator(paramsBinary, map[int]mktfhe.EvaluationKey[uint64]{
0: encBinary[0].GenEvaluationKeyParallel(),
1: encBinary[1].GenEvaluationKeyParallel(),
})
testBinaryDecryptor = mktfhe.NewBinaryDecryptor(testBinaryParams, map[int]tfhe.SecretKey[uint64]{
0: testBinaryEncryptors[0].BaseEncryptor.SecretKey,
1: testBinaryEncryptors[1].BaseEncryptor.SecretKey,
decBinary = mktfhe.NewBinaryDecryptor(paramsBinary, map[int]tfhe.SecretKey[uint64]{
0: encBinary[0].BaseEncryptor.SecretKey,
1: encBinary[1].BaseEncryptor.SecretKey,
})
)

Expand Down Expand Up @@ -53,116 +53,116 @@ func TestBinaryEvaluator(t *testing.T) {
ct0 mktfhe.LWECiphertext[uint64]
ct1 mktfhe.LWECiphertext[uint64]
}{
{true, true, testBinaryEncryptors[0].EncryptLWEBool(true), testBinaryEncryptors[1].EncryptLWEBool(true)},
{true, false, testBinaryEncryptors[0].EncryptLWEBool(true), testBinaryEncryptors[1].EncryptLWEBool(false)},
{false, true, testBinaryEncryptors[0].EncryptLWEBool(false), testBinaryEncryptors[1].EncryptLWEBool(true)},
{false, false, testBinaryEncryptors[0].EncryptLWEBool(false), testBinaryEncryptors[1].EncryptLWEBool(false)},
{true, true, encBinary[0].EncryptLWEBool(true), encBinary[1].EncryptLWEBool(true)},
{true, false, encBinary[0].EncryptLWEBool(true), encBinary[1].EncryptLWEBool(false)},
{false, true, encBinary[0].EncryptLWEBool(false), encBinary[1].EncryptLWEBool(true)},
{false, false, encBinary[0].EncryptLWEBool(false), encBinary[1].EncryptLWEBool(false)},
}

t.Run("AND", func(t *testing.T) {
for _, tc := range tests {
assert.Equal(t, tc.pt0 && tc.pt1, testBinaryDecryptor.DecryptLWEBool(testBinaryEvaluator.AND(tc.ct0, tc.ct1)))
assert.Equal(t, tc.pt0 && tc.pt1, decBinary.DecryptLWEBool(evalBinary.AND(tc.ct0, tc.ct1)))
}
})

t.Run("ANDParallel", func(t *testing.T) {
for _, tc := range tests {
assert.Equal(t, tc.pt0 && tc.pt1, testBinaryDecryptor.DecryptLWEBool(testBinaryEvaluator.ANDParallel(tc.ct0, tc.ct1)))
assert.Equal(t, tc.pt0 && tc.pt1, decBinary.DecryptLWEBool(evalBinary.ANDParallel(tc.ct0, tc.ct1)))
}
})

t.Run("NAND", func(t *testing.T) {
for _, tc := range tests {
assert.Equal(t, !(tc.pt0 && tc.pt1), testBinaryDecryptor.DecryptLWEBool(testBinaryEvaluator.NAND(tc.ct0, tc.ct1)))
assert.Equal(t, !(tc.pt0 && tc.pt1), decBinary.DecryptLWEBool(evalBinary.NAND(tc.ct0, tc.ct1)))
}
})

t.Run("NANDParallel", func(t *testing.T) {
for _, tc := range tests {
assert.Equal(t, !(tc.pt0 && tc.pt1), testBinaryDecryptor.DecryptLWEBool(testBinaryEvaluator.NANDParallel(tc.ct0, tc.ct1)))
assert.Equal(t, !(tc.pt0 && tc.pt1), decBinary.DecryptLWEBool(evalBinary.NANDParallel(tc.ct0, tc.ct1)))
}
})

t.Run("OR", func(t *testing.T) {
for _, tc := range tests {
assert.Equal(t, tc.pt0 || tc.pt1, testBinaryDecryptor.DecryptLWEBool(testBinaryEvaluator.OR(tc.ct0, tc.ct1)))
assert.Equal(t, tc.pt0 || tc.pt1, decBinary.DecryptLWEBool(evalBinary.OR(tc.ct0, tc.ct1)))
}
})

t.Run("ORParallel", func(t *testing.T) {
for _, tc := range tests {
assert.Equal(t, tc.pt0 || tc.pt1, testBinaryDecryptor.DecryptLWEBool(testBinaryEvaluator.ORParallel(tc.ct0, tc.ct1)))
assert.Equal(t, tc.pt0 || tc.pt1, decBinary.DecryptLWEBool(evalBinary.ORParallel(tc.ct0, tc.ct1)))
}
})

t.Run("NOR", func(t *testing.T) {
for _, tc := range tests {
assert.Equal(t, !(tc.pt0 || tc.pt1), testBinaryDecryptor.DecryptLWEBool(testBinaryEvaluator.NOR(tc.ct0, tc.ct1)))
assert.Equal(t, !(tc.pt0 || tc.pt1), decBinary.DecryptLWEBool(evalBinary.NOR(tc.ct0, tc.ct1)))
}
})

t.Run("NORParallel", func(t *testing.T) {
for _, tc := range tests {
assert.Equal(t, !(tc.pt0 || tc.pt1), testBinaryDecryptor.DecryptLWEBool(testBinaryEvaluator.NORParallel(tc.ct0, tc.ct1)))
assert.Equal(t, !(tc.pt0 || tc.pt1), decBinary.DecryptLWEBool(evalBinary.NORParallel(tc.ct0, tc.ct1)))
}
})

t.Run("XOR", func(t *testing.T) {
for _, tc := range tests {
assert.Equal(t, tc.pt0 != tc.pt1, testBinaryDecryptor.DecryptLWEBool(testBinaryEvaluator.XOR(tc.ct0, tc.ct1)))
assert.Equal(t, tc.pt0 != tc.pt1, decBinary.DecryptLWEBool(evalBinary.XOR(tc.ct0, tc.ct1)))
}
})

t.Run("XORParallel", func(t *testing.T) {
for _, tc := range tests {
assert.Equal(t, tc.pt0 != tc.pt1, testBinaryDecryptor.DecryptLWEBool(testBinaryEvaluator.XORParallel(tc.ct0, tc.ct1)))
assert.Equal(t, tc.pt0 != tc.pt1, decBinary.DecryptLWEBool(evalBinary.XORParallel(tc.ct0, tc.ct1)))
}
})

t.Run("XNOR", func(t *testing.T) {
for _, tc := range tests {
assert.Equal(t, tc.pt0 == tc.pt1, testBinaryDecryptor.DecryptLWEBool(testBinaryEvaluator.XNOR(tc.ct0, tc.ct1)))
assert.Equal(t, tc.pt0 == tc.pt1, decBinary.DecryptLWEBool(evalBinary.XNOR(tc.ct0, tc.ct1)))
}
})

t.Run("XNORParallel", func(t *testing.T) {
for _, tc := range tests {
assert.Equal(t, tc.pt0 == tc.pt1, testBinaryDecryptor.DecryptLWEBool(testBinaryEvaluator.XNORParallel(tc.ct0, tc.ct1)))
assert.Equal(t, tc.pt0 == tc.pt1, decBinary.DecryptLWEBool(evalBinary.XNORParallel(tc.ct0, tc.ct1)))
}
})

t.Run("Bits", func(t *testing.T) {
msg0, msg1 := 0b01, 0b10
ct0 := testBinaryEncryptors[0].EncryptLWEBits(msg0, 4)
ct1 := testBinaryEncryptors[1].EncryptLWEBits(msg1, 4)
ct0 := encBinary[0].EncryptLWEBits(msg0, 4)
ct1 := encBinary[1].EncryptLWEBits(msg1, 4)

ctOut := testBinaryEncryptors[0].EncryptLWEBits(0, 4)
ctOut := encBinary[0].EncryptLWEBits(0, 4)
for i := range ctOut {
testBinaryEvaluator.XORAssign(ct0[i], ct1[i], ctOut[i])
evalBinary.XORAssign(ct0[i], ct1[i], ctOut[i])
}

assert.Equal(t, testBinaryDecryptor.DecryptLWEBits(ctOut), msg0^msg1)
assert.Equal(t, decBinary.DecryptLWEBits(ctOut), msg0^msg1)
})
}

func BenchmarkGateBootstrap(b *testing.B) {
ct0 := testBinaryEncryptors[0].EncryptLWEBool(true)
ct1 := testBinaryEncryptors[1].EncryptLWEBool(false)
ctOut := mktfhe.NewLWECiphertext(testBinaryParams)
ct0 := encBinary[0].EncryptLWEBool(true)
ct1 := encBinary[1].EncryptLWEBool(false)
ctOut := mktfhe.NewLWECiphertext(paramsBinary)
b.ResetTimer()

for i := 0; i < b.N; i++ {
testBinaryEvaluator.ANDAssign(ct0, ct1, ctOut)
evalBinary.ANDAssign(ct0, ct1, ctOut)
}
}

func BenchmarkGateBootstrapParallel(b *testing.B) {
ct0 := testBinaryEncryptors[0].EncryptLWEBool(true)
ct1 := testBinaryEncryptors[1].EncryptLWEBool(false)
ctOut := mktfhe.NewLWECiphertext(testBinaryParams)
ct0 := encBinary[0].EncryptLWEBool(true)
ct1 := encBinary[1].EncryptLWEBool(false)
ctOut := mktfhe.NewLWECiphertext(paramsBinary)
b.ResetTimer()

for i := 0; i < b.N; i++ {
testBinaryEvaluator.ANDParallelAssign(ct0, ct1, ctOut)
evalBinary.ANDParallelAssign(ct0, ct1, ctOut)
}
}
Loading

0 comments on commit dc72b79

Please sign in to comment.