mirror/gmsm
1
0
Fork 0
mirror of https://github.com/emmansun/gmsm.git synced 2025-04-26 20:26:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

sm9/bn256: gfp2MulU1

Browse Source
This commit is contained in:
Sun Yimin 2023-07-27 15:59:52 +08:00 committed by GitHub
parent e3d14fb41a
commit 0ee8177079
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 117 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
sm9/bn256/g1_test.go
View File

@ -44,6 +44,7 @@ func TestCurvePointDouble(t *testing.T) {
}
func TestCurvePointDobuleComplete(t *testing.T) {
t.Parallel()
t.Run("normal case", func(t *testing.T) {
p2 := &curvePoint{}
p2.DoubleComplete(curveGen)
@ -71,6 +72,7 @@ func TestCurvePointDobuleComplete(t *testing.T) {
}
func TestCurvePointAddComplete(t *testing.T) {
t.Parallel()
t.Run("normal case", func(t *testing.T) {
p1 := &curvePoint{}
curvePointDouble(p1, curveGen)
@ -737,4 +739,5 @@ func BenchmarkDoublePoint(b *testing.B) {
curvePointDouble(p2, curveGen)
}
})
}

1
sm9/bn256/gfp12_test.go
View File

@ -28,6 +28,7 @@ func TestGfp12BasicOperations(t *testing.T) {
*(&gfP4{}).SetZero(),
}
t.Parallel()
t.Run("Add", func(t *testing.T) {
expectedAdd := "(((6a6225e56e1acd7c5ae45b0f1b63733de799936987c8f38dd16bcddc6b500bcf, 0db9e03175ebe2b21be74db56d03e143dbd835729d7291fa6694b22536746fa1), (4d8891878c3113b4665011d7b24f278d4c1b54a22ec093840a00c030b5c239f9, 21092bc181ec5d9c488aac3c5feef9b725f7568b42b4794f807e271f22e38494)), ((6a6225e56e1acd7c5ae45b0f1b63733de799936987c8f38dd16bcddc6b500bcf, 0db9e03175ebe2b21be74db56d03e143dbd835729d7291fa6694b22536746fa1), (4d8891878c3113b4665011d7b24f278d4c1b54a22ec093840a00c030b5c239f9, 21092bc181ec5d9c488aac3c5feef9b725f7568b42b4794f807e271f22e38494)), ((0000000000000000000000000000000000000000000000000000000000000000, 0000000000000000000000000000000000000000000000000000000000000000), (0000000000000000000000000000000000000000000000000000000000000000, 49bffffffd5c590e29fc54b00a7138bade0d6cb4e58511241a9064d81caeba83)))"
got := &gfP12{}

7
sm9/bn256/gfp2.go
View File

@ -135,12 +135,7 @@ func (e *gfP2) MulU(a, b *gfP2) *gfP2 {
// c1 = a0
// c0 = -2a1
func (e *gfP2) MulU1(a *gfP2) *gfP2 {
t := &gfP{}
gfpDouble(t, &a.x)
gfpNeg(t, t)
gfpCopy(&e.x, &a.y)
gfpCopy(&e.y, t)
gfp2MulU1(e, a)
return e
}

29
sm9/bn256/gfp2_g1_amd64.s
View File

@ -1197,6 +1197,35 @@ TEXT ·gfp2MulU(SB),NOSPLIT,$256-24
#undef cxout
#undef rptr
TEXT ·gfp2MulU1(SB),NOSPLIT,$0-16
// Move input to stack in order to free registers
MOVQ res+0(FP), mul1
MOVQ in1+8(FP), AX
//LDacc (axin)
MOVOU (16*2)(AX), X2
MOVOU (16*3)(AX), X3
MOVQ (16*0 + 8*0)(AX), acc4
MOVQ (16*0 + 8*1)(AX), acc5
MOVQ (16*0 + 8*2)(AX), acc6
MOVQ (16*0 + 8*3)(AX), acc7
gfpMulBy2Inline
XORQ acc4, acc4
XORQ acc5, acc5
XORQ acc6, acc6
XORQ acc7, acc7
CALL gfpSubInternal(SB)
MOVOU X2, (16*0)(mul1)
MOVOU X3, (16*1)(mul1)
MOVQ acc4, (16*2 + 8*0)(mul1)
MOVQ acc5, (16*2 + 8*1)(mul1)
MOVQ acc6, (16*2 + 8*2)(mul1)
MOVQ acc7, (16*2 + 8*3)(mul1)
RET
#define axin(off) (32*0 + off)(SP)
#define ayin(off) (32*1 + off)(SP)
#define cxout(off) (32*2 + off)(SP)

23
sm9/bn256/gfp2_g1_arm64.s
View File

@ -619,6 +619,29 @@ TEXT ·gfp2MulU(SB),NOSPLIT,$104-24
RET
// func gfp2MulU1(c, a *gfP2)
TEXT ·gfp2MulU1(SB),NOSPLIT,$0-16
MOVD res+0(FP), b_ptr
MOVD in1+8(FP), a_ptr
LDP ·p2+0x00(SB), (const0, const1)
LDP ·p2+0x10(SB), (const2, const3)
LDy (x1in)
gfpMulBy2Inline
MOVD $0, y0
MOVD $0, y1
MOVD $0, y2
MOVD $0, y3
CALL gfpSubInternal(SB)
ADD $32, a_ptr, a_ptr
VLD1 32(a_ptr), [V0.B16, V1.B16]
VST1 [V0.B16, V1.B16], 32(b_ptr)
STx (y2in)
RET
// func gfp2Square(c, a *gfP2)
TEXT ·gfp2Square(SB),NOSPLIT,$72-16
MOVD res+0(FP), b_ptr

5
sm9/bn256/gfp2_g1_decl.go
View File

@ -13,6 +13,11 @@ func gfp2Mul(c, a, b *gfP2)
//go:noescape
func gfp2MulU(c, a, b *gfP2)
// gfP2 multiplication. c = a*u
//
//go:noescape
func gfp2MulU1(c, a *gfP2)
// gfP2 square.
//
//go:noescape

9
sm9/bn256/gfp2_g1_generic.go
View File

@ -48,6 +48,15 @@ func gfp2MulU(c, a, b *gfP2) {
gfp2Copy(c, tmp)
}
func gfp2MulU1(c, a *gfP2) {
t := &gfP{}
gfpDouble(t, &a.x)
gfpNeg(t, t)
gfpCopy(&c.x, &a.y)
gfpCopy(&c.y, t)
}
func gfp2Square(c, a *gfP2) {
tmp := &gfP2{}
tx := &tmp.x

43
sm9/bn256/gfp2_test.go
View File

@ -18,6 +18,8 @@ func TestGfp2BasicOperations(t *testing.T) {
expectedSub := "(0e6cca2ef0f4dce3fa4a249bb48a25d84dbf1f63ac843004e3b586d5dac6e8eb, 51785a37fb519603d4b026648151d768ebe9b9193a9c83c365c31316fb711845)"
expectedMul := "(7f98a04cf83164be0fdc4763a7c6f24c2901191f2917eb71037cd5221cf002bb, 75a09ee1aa1b04ccdb24e629529a18492f378aa3034f63d3cd1b8b9f0d338b3a)"
expectedMulU := "(75a09ee1aa1b04ccdb24e629529a18492f378aa3034f63d3cd1b8b9f0d338b3a, 6d4ebf6614e484678c4ec7d89b8fa9f1f1e2f457e2c606d5c3e58c0b8cc28584)"
t.Parallel()
t.Run("Add", func(t *testing.T) {
ret := &gfP2{}
ret.Add(x, y)
@ -240,6 +242,34 @@ func BenchmarkGfP2Mul(b *testing.B) {
}
}
func BenchmarkGfP2MulScalar(b *testing.B) {
x := &gfP2{
*fromBigInt(bigFromHex("85AEF3D078640C98597B6027B441A01FF1DD2C190F5E93C454806C11D8806141")),
*fromBigInt(bigFromHex("3722755292130B08D2AAB97FD34EC120EE265948D19C17ABF9B7213BAF82D65B")),
}
t := &gfP2{}
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
t.MulScalar(x, &x.x)
}
}
func BenchmarkGfP2MulU1(b *testing.B) {
x := &gfP2{
*fromBigInt(bigFromHex("85AEF3D078640C98597B6027B441A01FF1DD2C190F5E93C454806C11D8806141")),
*fromBigInt(bigFromHex("3722755292130B08D2AAB97FD34EC120EE265948D19C17ABF9B7213BAF82D65B")),
}
t := &gfP2{}
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
t.MulU1(x)
}
}
func BenchmarkGfP2MulU(b *testing.B) {
x := &gfP2{
*fromBigInt(bigFromHex("85AEF3D078640C98597B6027B441A01FF1DD2C190F5E93C454806C11D8806141")),
@ -282,6 +312,19 @@ func BenchmarkGfP2SquareU(b *testing.B) {
}
}
func BenchmarkGfP2Invert(b *testing.B) {
x := &gfP2{
*fromBigInt(bigFromHex("85AEF3D078640C98597B6027B441A01FF1DD2C190F5E93C454806C11D8806141")),
*fromBigInt(bigFromHex("3722755292130B08D2AAB97FD34EC120EE265948D19C17ABF9B7213BAF82D65B")),
}
t := &gfP2{}
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
t.Invert(x)
}
}
func BenchmarkGfP2Neg(b *testing.B) {
x := &gfP2{
*fromBigInt(bigFromHex("85AEF3D078640C98597B6027B441A01FF1DD2C190F5E93C454806C11D8806141")),

3
sm9/bn256/gfp4_test.go
View File

@ -25,6 +25,7 @@ func TestGfp4BasicOperations(t *testing.T) {
expectedMul := "((5f318c234b817377df2179ff82a0759c6b926330853e5abd919e45a6a93e658e, 3c9db0f3bbdb89a9a407dfec4f8f4d6b8ef35b2a3f05e7bcc9bb6a956876faf7), (3ef93f2e9fa8c29914fd823d04d243503646107711ec6068eb28c59946d24878, 2caf5e47bc5be242917002b1f89afaf5ff27ebafcb9a7bcdab917c82b6a4cb41))"
expectedMulV := "((3ef93f2e9fa8c29914fd823d04d243503646107711ec6068eb28c59946d24878, 2caf5e47bc5be242917002b1f89afaf5ff27ebafcb9a7bcdab917c82b6a4cb41), (3c9db0f3bbdb89a9a407dfec4f8f4d6b8ef35b2a3f05e7bcc9bb6a956876faf7, ae1ce7b96e4466f3edc462a0e5dca3516cc060352a79283ca7a2ab027425bfde))"
t.Parallel()
t.Run("Add", func(t *testing.T) {
got := &gfP4{}
got.Set(x)
@ -306,10 +307,10 @@ func BenchmarkGfP4Mul(b *testing.B) {
*fromBigInt(bigFromHex("3722755292130B08D2AAB97FD34EC120EE265948D19C17ABF9B7213BAF82D65B")),
},
}
t := &gfP4{}
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
t := &gfP4{}
t.Mul(x, y)
}
}

1
sm9/bn256/gfp_test.go
View File

@ -16,6 +16,7 @@ func TestGfpBasicOperations(t *testing.T) {
expectedMul := fromBigInt(bigFromHex("3d08bbad376584e4f74bd31f78f716372b96ba8c3f939c12b8d54e79b6489e76"))
expectedMul2 := fromBigInt(bigFromHex("1df94a9e05a559ff38e0ab50cece734dc058d33738ceacaa15986a67cbff1ef6"))
t.Parallel()
t.Run("add", func(t *testing.T) {
ret := &gfP{}
gfpAdd(ret, x, y)