mirror of
https://github.com/protocolbuffers/protobuf-go.git
synced 2024-12-29 12:17:48 +00:00
492a476312
The use of math/rand in serialization is to provide some form of instability to the output to provide a clear signal to the user that the should not depend on the the property of stability. However, it is reasonable that users expect the output for these to be deterministic. As such, add a detrand package that provides deterministic, yet unstable randomization functionality. Since this package hashes the binary, it does impose a small initialization cost: Benchmark 100000 20712 ns/op 480 B/op 6 allocs/op Change-Id: I232d0fea1789a4278079837a67ee2f63474a4364 Reviewed-on: https://go-review.googlesource.com/c/151340 Reviewed-by: Herbie Ong <herbie@google.com>
64 lines
1.4 KiB
Go
64 lines
1.4 KiB
Go
// Copyright 2018 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Package detrand provides deterministically random functionality.
|
|
//
|
|
// The pseudo-randomness of these functions is seeded by the program binary
|
|
// itself and guarantees that the output does not change within a program,
|
|
// while ensuring that the output is unstable across different builds.
|
|
package detrand
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"hash/fnv"
|
|
"os"
|
|
)
|
|
|
|
// Bool returns a deterministically random boolean.
|
|
func Bool() bool {
|
|
return binHash%2 == 0
|
|
}
|
|
|
|
// Intn returns a deterministically random integer within [0,n).
|
|
func Intn(n int) int {
|
|
if n <= 0 {
|
|
panic("invalid argument to Intn")
|
|
}
|
|
return int(binHash % uint64(n))
|
|
}
|
|
|
|
// binHash is a best-effort at an approximate hash of the Go binary.
|
|
var binHash = binaryHash()
|
|
|
|
func binaryHash() uint64 {
|
|
// Open the Go binary.
|
|
s, err := os.Executable()
|
|
if err != nil {
|
|
return 0
|
|
}
|
|
f, err := os.Open(s)
|
|
if err != nil {
|
|
return 0
|
|
}
|
|
defer f.Close()
|
|
|
|
// Hash the size and several samples of the Go binary.
|
|
const numSamples = 8
|
|
var buf [64]byte
|
|
h := fnv.New64()
|
|
fi, err := f.Stat()
|
|
if err != nil {
|
|
return 0
|
|
}
|
|
binary.LittleEndian.PutUint64(buf[:8], uint64(fi.Size()))
|
|
h.Write(buf[:8])
|
|
for i := int64(0); i < numSamples; i++ {
|
|
if _, err := f.ReadAt(buf[:], i*fi.Size()/numSamples); err != nil {
|
|
return 0
|
|
}
|
|
h.Write(buf[:])
|
|
}
|
|
return h.Sum64()
|
|
}
|