Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Rework the pre-computed table generation and load.
This commit reworks the way that the pre-computed table which is used to accelerate scalar base multiple is generated and loaded to make use of the go generate infrastructure and greatly reduce the memory needed to compile as well as speed up the compile. Previously, the table was being generated using the in-memory representation directly written into the file. Since the table has a very large number of entries, the Go compiler was taking up to nearly 1GB to compile. It also took a comparatively long period of time to compile. Instead, this commit modifies the generated table to be a serialized, compressed, and base64-encoded byte slice. At init time, this process is reversed to create the in-memory representation. This approach provides fast compile times with much lower memory needed to compile (16MB versus 1GB). In addition, the init time cost is extremely low, especially as compared to computing the entire table. Finally, the automatic generation wasn't really automatic. It is now fully automatic with 'go generate'.
- Loading branch information
Showing
5 changed files
with
171 additions
and
41,054 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,54 @@ | ||
| // Copyright 2015 Conformal Systems LLC. All rights reserved. | ||
| // Use of this source code is governed by a BSD-style | ||
| // license that can be found in the LICENSE file. | ||
|
|
||
| // This file is ignored during the regular build due to the following build tag. | ||
| // It is called by go generate and used to automatically generate pre-computed | ||
| // tables used to accelerate operations. | ||
| // +build ignore | ||
|
|
||
| package main | ||
|
|
||
| import ( | ||
| "bytes" | ||
| "compress/zlib" | ||
| "encoding/base64" | ||
| "fmt" | ||
| "log" | ||
| "os" | ||
|
|
||
| "github.com/btcsuite/btcec" | ||
| ) | ||
|
|
||
| func main() { | ||
| fi, err := os.Create("secp256k1.go") | ||
| if err != nil { | ||
| log.Fatal(err) | ||
| } | ||
| defer fi.Close() | ||
|
|
||
| // Compress the serialized byte points. | ||
| serialized := btcec.S256().SerializedBytePoints() | ||
| var compressed bytes.Buffer | ||
| w := zlib.NewWriter(&compressed) | ||
| if _, err := w.Write(serialized); err != nil { | ||
| fmt.Println(err) | ||
| os.Exit(1) | ||
| } | ||
| w.Close() | ||
|
|
||
| // Encode the compressed byte points with base64. | ||
| encoded := make([]byte, base64.StdEncoding.EncodedLen(compressed.Len())) | ||
| base64.StdEncoding.Encode(encoded, compressed.Bytes()) | ||
|
|
||
| fmt.Fprintln(fi, "// Copyright (c) 2015 Conformal Systems LLC.") | ||
| fmt.Fprintln(fi, "// Use of this source code is governed by an ISC") | ||
| fmt.Fprintln(fi, "// license that can be found in the LICENSE file.") | ||
| fmt.Fprintln(fi) | ||
| fmt.Fprintln(fi, "package btcec") | ||
| fmt.Fprintln(fi) | ||
| fmt.Fprintln(fi, "// Auto-generated file (see genprecomps.go)") | ||
| fmt.Fprintln(fi, "// DO NOT EDIT") | ||
| fmt.Fprintln(fi) | ||
| fmt.Fprintf(fi, "var secp256k1BytePoints = []byte(%q)\n", encoded) | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,71 @@ | ||
| // Copyright 2015 Conformal Systems LLC. All rights reserved. | ||
| // Use of this source code is governed by a BSD-style | ||
| // license that can be found in the LICENSE file. | ||
|
|
||
| package btcec | ||
|
|
||
| import ( | ||
| "bytes" | ||
| "compress/zlib" | ||
| "encoding/base64" | ||
| "encoding/binary" | ||
| "io/ioutil" | ||
| ) | ||
|
|
||
| //go:generate go run -tags gensecp256k1 genprecomps.go | ||
|
|
||
| // loadS256BytePoints decompresses and deserializes the pre-computed byte points | ||
| // used to accelerate scalar base multiplication for the secp256k1 curve. This | ||
| // approach is used since it allows the compile to use significantly less ram | ||
| // and be performed much faster than it is with hard-coding the final in-memory | ||
| // data structure. At the same time, it is quite fast to generate the in-memory | ||
| // data structure at init time with this approach versus computing the table. | ||
| func loadS256BytePoints() error { | ||
| // There will be no byte points to load when generating them. | ||
| bp := secp256k1BytePoints | ||
| if len(secp256k1BytePoints) == 0 { | ||
| return nil | ||
| } | ||
|
|
||
| // Decompress the pre-computed table used to accelerate scalar base | ||
| // multiplication. | ||
| decoded := make([]byte, base64.StdEncoding.DecodedLen(len(bp))) | ||
| if _, err := base64.StdEncoding.Decode(decoded, bp); err != nil { | ||
| return err | ||
| } | ||
| r, err := zlib.NewReader(bytes.NewReader(decoded)) | ||
| if err != nil { | ||
| return err | ||
| } | ||
| serialized, err := ioutil.ReadAll(r) | ||
| if err != nil { | ||
| return err | ||
| } | ||
|
|
||
| // Deserialize the precomputed byte points and set the curve to them. | ||
| offset := 0 | ||
| var bytePoints [32][256][3]fieldVal | ||
| for byteNum := 0; byteNum < 32; byteNum++ { | ||
| // All points in this window. | ||
| for i := 0; i < 256; i++ { | ||
| px, py, pz := new(fieldVal), new(fieldVal), new(fieldVal) | ||
| for i := 0; i < 10; i++ { | ||
| px.n[i] = binary.LittleEndian.Uint32(serialized[offset:]) | ||
| offset += 4 | ||
| } | ||
| for i := 0; i < 10; i++ { | ||
| py.n[i] = binary.LittleEndian.Uint32(serialized[offset:]) | ||
| offset += 4 | ||
| } | ||
| for i := 0; i < 10; i++ { | ||
| pz.n[i] = binary.LittleEndian.Uint32(serialized[offset:]) | ||
| offset += 4 | ||
| } | ||
| bytePoints[byteNum][i][0] = *px | ||
| bytePoints[byteNum][i][1] = *py | ||
| bytePoints[byteNum][i][2] = *pz | ||
| } | ||
| } | ||
| secp256k1.bytePoints = &bytePoints | ||
| return nil | ||
| } |
Oops, something went wrong.