In programming in general, and in Golang in particular, many roads lead to Rome. From time to time I ask myself which of these ways is the fastest. In Golang there is a wonderful solution, with `go test -bench` you can measure the speed very easily and quickly. In order for you to benefit from it too, I will publish such benchmarks in this repository in the future.
I published another repository where I show some Golang examples. If you're interested in new programming languages, you should definitely take a look at Golang:
Golang Version: go version devel +a6755fc0de Sat Nov 7 07:33:23 2020 +0000 windows/amd64
// Package base64 benchmarks some base64 functions.
// On all tested systems it's faster to decode a
// base64 encoded string instead of a check via regex.
package base64
import (
"encoding/base64"
"regexp"
"testing"
)
func base64decode(s string) bool {
_, err := base64.StdEncoding.DecodeString(s)
return err == nil
}
func base64regex(s string) bool {
matched, _ := regexp.MatchString(`^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$`, s)
return matched
}
func BenchmarkBase64decode(b *testing.B) {
isNotBase64 := `Invalid string`
isBase64 := `VmFsaWQgc3RyaW5nCg==`
for n := 0; n < b.N; n++ {
base64decode(isNotBase64)
base64decode(isBase64)
}
}
func BenchmarkBase64regex(b *testing.B) {
isNotBase64 := `Invalid string`
isBase64 := `VmFsaWQgc3RyaW5nCg==`
for n := 0; n < b.N; n++ {
base64regex(isNotBase64)
base64regex(isBase64)
}
}$ go test -bench . -benchmem
goos: windows
goarch: amd64
pkg: github.com/SimonWaldherr/golang-benchmarks/base64
cpu: AMD Ryzen 5 3500U with Radeon Vega Mobile Gfx
BenchmarkBase64decode-8 5367226 245.6 ns/op 32 B/op 2 allocs/op
BenchmarkBase64regex-8 30693 37875 ns/op 21444 B/op 198 allocs/op
PASS
ok github.com/SimonWaldherr/golang-benchmarks/base64 3.170s
// Package between compares the performance of checking
// if a number is between two other numbers via regex
// and by parsing the number as integers.
package between
import (
"regexp"
"simonwaldherr.de/go/golibs/as"
"simonwaldherr.de/go/ranger"
"testing"
)
func BenchmarkNumberRegEx(b *testing.B) {
re := ranger.Compile(89, 1001)
re = "^(" + re + ")$"
b.ResetTimer()
for n := 0; n < b.N; n++ {
matched, err := regexp.MatchString(re, "404")
if !matched || err != nil {
b.Log("Error in Benchmark")
}
matched, err = regexp.MatchString(re, "2000")
if matched || err != nil {
b.Log("Error in Benchmark")
}
}
}
func BenchmarkFulltextRegEx(b *testing.B) {
re := ranger.Compile(89, 1001)
re = " (" + re + ") "
b.ResetTimer()
for n := 0; n < b.N; n++ {
matched, err := regexp.MatchString(re, "lorem ipsum 404 dolor sit")
if !matched || err != nil {
b.Log("Error in Benchmark")
}
matched, err = regexp.MatchString(re, "lorem ipsum 2000 dolor sit")
if matched || err != nil {
b.Log("Error in Benchmark")
}
}
}
func BenchmarkNumberParse(b *testing.B) {
for n := 0; n < b.N; n++ {
i1 := as.Int("404")
i2 := as.Int("2000")
if i1 < 89 || i1 > 1001 {
b.Log("Error in Benchmark")
}
if !(i2 < 89 || i2 > 1001) {
b.Log("Error in Benchmark")
}
}
}
func BenchmarkFulltextParse(b *testing.B) {
re := regexp.MustCompile("[0-9]+")
b.ResetTimer()
for n := 0; n < b.N; n++ {
i1 := as.Int(re.FindString("lorem ipsum 404 dolor sit"))
i2 := as.Int(re.FindString("lorem ipsum 2000 dolor sit"))
if i1 < 89 || i1 > 1001 {
b.Log("Error in Benchmark")
}
if !(i2 < 89 || i2 > 1001) {
b.Log("Error in Benchmark")
}
}
}$ go test -bench . -benchmem
goos: windows
goarch: amd64
pkg: github.com/SimonWaldherr/golang-benchmarks/between
cpu: AMD Ryzen 5 3500U with Radeon Vega Mobile Gfx
BenchmarkNumberRegEx-8 45007 26404 ns/op 16139 B/op 142 allocs/op
BenchmarkFulltextRegEx-8 58605 21743 ns/op 11640 B/op 104 allocs/op
BenchmarkNumberParse-8 12766242 95.73 ns/op 0 B/op 0 allocs/op
BenchmarkFulltextParse-8 800138 1296 ns/op 32 B/op 2 allocs/op
PASS
ok github.com/SimonWaldherr/golang-benchmarks/between 5.382s
// Package concat benchmarks the performance of
// various string concatenation methods.
// Instead of just concatenating a string to another string
// it is also possible (and much faster) to use
// a bytes buffer.
package concat
import (
"bytes"
"strings"
"testing"
)
func BenchmarkConcatString(b *testing.B) {
var str string
for n := 0; n < b.N; n++ {
str += "x"
}
}
func BenchmarkConcatBuffer(b *testing.B) {
var buffer bytes.Buffer
for n := 0; n < b.N; n++ {
buffer.WriteString("x")
}
}
func BenchmarkConcatBuilder(b *testing.B) {
var builder strings.Builder
for n := 0; n < b.N; n++ {
builder.WriteString("x")
}
}$ go test -bench . -benchmem
goos: windows
goarch: amd64
pkg: github.com/SimonWaldherr/golang-benchmarks/concat
cpu: AMD Ryzen 5 3500U with Radeon Vega Mobile Gfx
BenchmarkConcatString-8 654996 64654 ns/op 331436 B/op 1 allocs/op
BenchmarkConcatBuffer-8 96764048 12.40 ns/op 2 B/op 0 allocs/op
BenchmarkConcatBuilder-8 290770929 4.316 ns/op 5 B/op 0 allocs/op
PASS
ok github.com/SimonWaldherr/golang-benchmarks/concat 45.428s
// Package contains tests various ways of checking
// if a string is contained in another string.
package contains
import (
"bytes"
"regexp"
"strings"
"testing"
)
// strings.Contains
func contains() bool {
return strings.Contains("Lorem Ipsum", "em Ip")
}
func containsNot() bool {
return strings.Contains("Lorem Ipsum", "Dolor")
}
func TestContains(t *testing.T) {
if contains() == false {
t.Error("ERROR: contains")
}
if containsNot() == true {
t.Error("ERROR: contains not")
}
}
func BenchmarkContains(b *testing.B) {
for n := 0; n < b.N; n++ {
contains()
}
}
func BenchmarkContainsNot(b *testing.B) {
for n := 0; n < b.N; n++ {
containsNot()
}
}
// bytes.Contains
func containsBytes() bool {
return bytes.Contains([]byte("Lorem Ipsum"), []byte("em Ip"))
}
func containsBytesNot() bool {
return bytes.Contains([]byte("Lorem Ipsum"), []byte("Dolor"))
}
func TestContainsBytes(t *testing.T) {
if containsBytes() == false {
t.Error("ERROR: bytes contains")
}
if containsBytesNot() == true {
t.Error("ERROR: bytes contains not")
}
}
func BenchmarkContainsBytes(b *testing.B) {
for n := 0; n < b.N; n++ {
containsBytes()
}
}
func BenchmarkContainsBytesNot(b *testing.B) {
for n := 0; n < b.N; n++ {
containsBytesNot()
}
}
// regexp.MustCompile + regexp.MatchString
func compileMatch(re *regexp.Regexp) bool {
matched := re.MatchString("Lorem Ipsum")
return matched
}
func compileMatchNot(re *regexp.Regexp) bool {
matched := re.MatchString("Lorem Ipsum")
return matched
}
func TestCompileMatch(t *testing.T) {
re1 := regexp.MustCompile("em Ip")
re2 := regexp.MustCompile("Dolor")
if compileMatch(re1) == false {
t.Error("ERROR: compile match")
}
if compileMatchNot(re2) == true {
t.Error("ERROR: compile match not")
}
}
func BenchmarkCompileMatch(b *testing.B) {
re := regexp.MustCompile("em Ip")
for n := 0; n < b.N; n++ {
compileMatch(re)
}
}
func BenchmarkCompileMatchNot(b *testing.B) {
re := regexp.MustCompile("Dolor")
for n := 0; n < b.N; n++ {
compileMatchNot(re)
}
}
// regexp.MatchString
func match() bool {
matched, _ := regexp.MatchString("em Ip", "Lorem Ipsum")
return matched
}
func matchNot() bool {
matched, _ := regexp.MatchString("Dolor", "Lorem Ipsum")
return matched
}
func TestMatch(t *testing.T) {
if match() == false {
t.Error("ERROR: match")
}
if matchNot() == true {
t.Error("ERROR: match not")
}
}
func BenchmarkMatch(b *testing.B) {
for n := 0; n < b.N; n++ {
match()
}
}
func BenchmarkMatchNot(b *testing.B) {
for n := 0; n < b.N; n++ {
matchNot()
}
}$ go test -bench . -benchmem
goos: windows
goarch: amd64
pkg: github.com/SimonWaldherr/golang-benchmarks/contains
cpu: AMD Ryzen 5 3500U with Radeon Vega Mobile Gfx
BenchmarkContains-8 100000000 10.06 ns/op 0 B/op 0 allocs/op
BenchmarkContainsNot-8 124361080 9.478 ns/op 0 B/op 0 allocs/op
BenchmarkContainsBytes-8 111913422 10.52 ns/op 0 B/op 0 allocs/op
BenchmarkContainsBytesNot-8 113837294 11.18 ns/op 0 B/op 0 allocs/op
BenchmarkCompileMatch-8 6798404 166.2 ns/op 0 B/op 0 allocs/op
BenchmarkCompileMatchNot-8 18461878 65.58 ns/op 0 B/op 0 allocs/op
BenchmarkMatch-8 387135 2618 ns/op 1367 B/op 17 allocs/op
BenchmarkMatchNot-8 480118 2550 ns/op 1368 B/op 17 allocs/op
PASS
ok github.com/SimonWaldherr/golang-benchmarks/contains 12.542s
// Package foreach benchmarks ranging over slices and maps.
package foreach
import (
"testing"
)
var amap map[int]string
var aslice []string
func init() {
amap = map[int]string{
0: "lorem",
1: "ipsum",
2: "dolor",
3: "sit",
4: "amet",
}
aslice = []string{
"lorem",
"ipsum",
"dolor",
"sit",
"amet",
}
}
func forMap() {
for i := 0; i < len(amap); i++ {
_ = amap[i]
}
}
func rangeMap() {
for _, v := range amap {
_ = v
}
}
func rangeSlice() {
for _, v := range aslice {
_ = v
}
}
func rangeSliceKey() {
for k := range aslice {
_ = aslice[k]
}
}
func BenchmarkForMap(b *testing.B) {
for n := 0; n < b.N; n++ {
forMap()
}
}
func BenchmarkRangeMap(b *testing.B) {
for n := 0; n < b.N; n++ {
rangeMap()
}
}
func BenchmarkRangeSlice(b *testing.B) {
for n := 0; n < b.N; n++ {
rangeSlice()
}
}
func BenchmarkRangeSliceKey(b *testing.B) {
for n := 0; n < b.N; n++ {
rangeSliceKey()
}
}$ go test -bench . -benchmem
goos: windows
goarch: amd64
pkg: github.com/SimonWaldherr/golang-benchmarks/foreach
cpu: AMD Ryzen 5 3500U with Radeon Vega Mobile Gfx
BenchmarkForMap-8 41428023 30.76 ns/op 0 B/op 0 allocs/op
BenchmarkRangeMap-8 13371783 95.48 ns/op 0 B/op 0 allocs/op
BenchmarkRangeSlice-8 312989208 3.537 ns/op 0 B/op 0 allocs/op
BenchmarkRangeSliceKey-8 307276144 4.235 ns/op 0 B/op 0 allocs/op
PASS
ok github.com/SimonWaldherr/golang-benchmarks/foreach 5.941s
// Package hash benchmarks various hashing algorithms.
// Especially with hashing algorithms, faster is not always better.
// One should always decide on the basis of the respective requirements.
package hash
import (
"crypto/md5"
"crypto/sha1"
"crypto/sha256"
"crypto/sha512"
"hash"
"hash/adler32"
"hash/crc32"
"hash/fnv"
"math/rand"
"testing"
"github.com/jzelinskie/whirlpool"
"github.com/reusee/mmh3"
"github.com/zeebo/blake3"
"golang.org/x/crypto/blake2b"
"golang.org/x/crypto/sha3"
)
func benchmarkHashAlgo(b *testing.B, h hash.Hash) {
data := make([]byte, 2048)
rand.Read(data)
b.ResetTimer()
for n := 0; n < b.N; n++ {
h.Write(data)
h.Sum(nil)
}
}
func BenchmarkAdler32(b *testing.B) {
benchmarkHashAlgo(b, adler32.New())
}
func BenchmarkBlake2b256(b *testing.B) {
h, err := blake2b.New256(nil)
if err != nil {
b.Fatal(err)
}
benchmarkHashAlgo(b, h)
}
func BenchmarkBlake2b512(b *testing.B) {
h, err := blake2b.New512(nil)
if err != nil {
b.Fatal(err)
}
benchmarkHashAlgo(b, h)
}
func BenchmarkBlake3256(b *testing.B) {
benchmarkHashAlgo(b, blake3.New())
}
func BenchmarkMMH3(b *testing.B) {
benchmarkHashAlgo(b, mmh3.New128())
}
func BenchmarkCRC32(b *testing.B) {
benchmarkHashAlgo(b, crc32.NewIEEE())
}
func BenchmarkFnv128(b *testing.B) {
benchmarkHashAlgo(b, fnv.New128())
}
func BenchmarkMD5(b *testing.B) {
benchmarkHashAlgo(b, md5.New())
}
func BenchmarkSHA1(b *testing.B) {
benchmarkHashAlgo(b, sha1.New())
}
func BenchmarkSHA256(b *testing.B) {
benchmarkHashAlgo(b, sha256.New())
}
func BenchmarkSHA512(b *testing.B) {
benchmarkHashAlgo(b, sha512.New())
}
func BenchmarkSHA3256(b *testing.B) {
benchmarkHashAlgo(b, sha3.New256())
}
func BenchmarkSHA3512(b *testing.B) {
benchmarkHashAlgo(b, sha3.New512())
}
func BenchmarkWhirlpool(b *testing.B) {
benchmarkHashAlgo(b, whirlpool.New())
}$ go test -bench . -benchmem
goos: windows
goarch: amd64
pkg: github.com/SimonWaldherr/golang-benchmarks/hash
cpu: AMD Ryzen 5 3500U with Radeon Vega Mobile Gfx
BenchmarkAdler32-8 1286498 863.3 ns/op 8 B/op 1 allocs/op
BenchmarkBlake2b256-8 532658 2478 ns/op 32 B/op 1 allocs/op
BenchmarkBlake2b512-8 480070 2402 ns/op 64 B/op 1 allocs/op
BenchmarkBlake3256-8 255342 4927 ns/op 64 B/op 2 allocs/op
BenchmarkMMH3-8 3088189 428.1 ns/op 16 B/op 1 allocs/op
BenchmarkCRC32-8 5754514 213.8 ns/op 8 B/op 1 allocs/op
BenchmarkFnv128-8 144576 7388 ns/op 16 B/op 1 allocs/op
BenchmarkMD5-8 307717 3447 ns/op 16 B/op 1 allocs/op
BenchmarkSHA1-8 464949 2606 ns/op 24 B/op 1 allocs/op
BenchmarkSHA256-8 166674 6193 ns/op 32 B/op 1 allocs/op
BenchmarkSHA512-8 206931 6695 ns/op 64 B/op 1 allocs/op
BenchmarkSHA3256-8 139539 7776 ns/op 512 B/op 3 allocs/op
BenchmarkSHA3512-8 69549 14832 ns/op 576 B/op 3 allocs/op
BenchmarkWhirlpool-8 17632 65506 ns/op 64 B/op 1 allocs/op
PASS
ok github.com/SimonWaldherr/golang-benchmarks/hash 20.398s
// Package index benchmarks access on maps with various data types as keys.
package index
import (
"math/rand"
"strconv"
"testing"
)
var NumItems int = 1000000
var ms map[string]string
var ks []string
var mi map[int]string
var ki []int
func initMapStringIndex() {
ms = make(map[string]string)
ks = make([]string, 0)
for i := 0; i < NumItems; i++ {
key := strconv.Itoa(rand.Intn(NumItems))
ms[key] = "value" + strconv.Itoa(i)
ks = append(ks, key)
}
}
func initMapIntIndex() {
mi = make(map[int]string)
ki = make([]int, 0)
for i := 0; i < NumItems; i++ {
key := rand.Intn(NumItems)
mi[key] = "value" + strconv.Itoa(i)
ki = append(ki, key)
}
}
func init() {
initMapStringIndex()
initMapIntIndex()
}
func BenchmarkMapStringKeys(b *testing.B) {
i := 0
for n := 0; n < b.N; n++ {
if _, ok := ms[ks[i]]; ok {
}
i++
if i >= NumItems {
i = 0
}
}
}
func BenchmarkMapIntKeys(b *testing.B) {
i := 0
for n := 0; n < b.N; n++ {
if _, ok := mi[ki[i]]; ok {
}
i++
if i >= NumItems {
i = 0
}
}
}$ go test -bench . -benchmem
goos: windows
goarch: amd64
pkg: github.com/SimonWaldherr/golang-benchmarks/index
cpu: AMD Ryzen 5 3500U with Radeon Vega Mobile Gfx
BenchmarkMapStringKeys-8 8609346 142.5 ns/op 0 B/op 0 allocs/op
BenchmarkMapIntKeys-8 9610347 124.4 ns/op 0 B/op 0 allocs/op
PASS
ok github.com/SimonWaldherr/golang-benchmarks/index 4.545s
package json
import (
"encoding/json"
"math"
"math/big"
"testing"
"time"
)
type Data struct {
String string
Time time.Time
Int int
Int8 int8
Int16 int16
Int32 int32
Int64 int64
Boolean bool
Float32 float32
Float64 float64
BigInt big.Int
BigFloat big.Float
}
func BenchmarkJsonMarshal(b *testing.B) {
for n := 0; n < b.N; n++ {
var d = Data{
String: "",
Time: time.Now(),
Int: math.MaxInt32,
Int8: math.MaxInt8,
Int16: math.MaxInt16,
Int32: math.MaxInt32,
Int64: math.MaxInt64,
Boolean: false,
Float32: math.MaxFloat32,
Float64: math.MaxFloat64,
BigInt: *big.NewInt(math.MaxInt64),
BigFloat: *big.NewFloat(math.MaxFloat64),
}
_, err := json.Marshal(d)
if err != nil {
b.Error(err)
b.Fail()
return
}
}
}
func BenchmarkJsonUnmarshal(b *testing.B) {
str := `
{
"String": "",
"Time": "2019-10-30T16:41:29.853426+07:00",
"Int": 2147483647,
"Int8": 127,
"Int16": 32767,
"Int32": 2147483647,
"Int64": 9223372036854775807,
"Boolean": false,
"Float32": 3.4028235e+38,
"Float64": 1.7976931348623157e+308,
"BigInt": 9999999999999999999,
"BigFloat": "2.7976931348623157e+308"
}
`
for n := 0; n < b.N; n++ {
var d Data
err := json.Unmarshal([]byte(str), &d)
if err != nil {
b.Error(err)
b.Fail()
return
}
}
}$ go test -bench . -benchmem
goos: windows
goarch: amd64
pkg: github.com/SimonWaldherr/golang-benchmarks/json
cpu: AMD Ryzen 5 3500U with Radeon Vega Mobile Gfx
BenchmarkJsonMarshal-8 411422 2951 ns/op 480 B/op 5 allocs/op
BenchmarkJsonUnmarshal-8 96012 13334 ns/op 2120 B/op 38 allocs/op
PASS
ok github.com/SimonWaldherr/golang-benchmarks/json 3.390s
// Package math compares the speed of various mathematical operations.
package math
import (
"sync"
"sync/atomic"
"testing"
)
func BenchmarkMathInt8(b *testing.B) {
var intVal int8
for n := 0; n < b.N; n++ {
intVal = intVal + 2
}
}
func BenchmarkMathInt32(b *testing.B) {
var intVal int32
for n := 0; n < b.N; n++ {
intVal = intVal + 2
}
}
func BenchmarkMathInt64(b *testing.B) {
var intVal int64
for n := 0; n < b.N; n++ {
intVal = intVal + 2
}
}
func BenchmarkMathAtomicInt32(b *testing.B) {
var intVal int32
for n := 0; n < b.N; n++ {
atomic.AddInt32(&intVal, 2)
}
}
func BenchmarkMathAtomicInt64(b *testing.B) {
var intVal int64
for n := 0; n < b.N; n++ {
atomic.AddInt64(&intVal, 2)
}
}
type IntMutex struct {
v int64
mux sync.Mutex
}
func BenchmarkMathMutexInt(b *testing.B) {
var m IntMutex
for n := 0; n < b.N; n++ {
m.mux.Lock()
m.v = m.v + 2
m.mux.Unlock()
}
}
func BenchmarkMathFloat32(b *testing.B) {
var floatVal float32
for n := 0; n < b.N; n++ {
floatVal = floatVal + 2
}
}
func BenchmarkMathFloat64(b *testing.B) {
var floatVal float64
for n := 0; n < b.N; n++ {
floatVal = floatVal + 2
}
}$ go test -bench . -benchmem
goos: windows
goarch: amd64
pkg: github.com/SimonWaldherr/golang-benchmarks/math
cpu: AMD Ryzen 5 3500U with Radeon Vega Mobile Gfx
BenchmarkMathInt8-8 1000000000 0.3302 ns/op 0 B/op 0 allocs/op
BenchmarkMathInt32-8 1000000000 0.3290 ns/op 0 B/op 0 allocs/op
BenchmarkMathInt64-8 1000000000 0.3397 ns/op 0 B/op 0 allocs/op
BenchmarkMathAtomicInt32-8 131834130 9.002 ns/op 0 B/op 0 allocs/op
BenchmarkMathAtomicInt64-8 138517504 9.437 ns/op 0 B/op 0 allocs/op
BenchmarkMathMutexInt-8 63160886 18.73 ns/op 0 B/op 0 allocs/op
BenchmarkMathFloat32-8 1000000000 0.3210 ns/op 0 B/op 0 allocs/op
BenchmarkMathFloat64-8 1000000000 0.3560 ns/op 0 B/op 0 allocs/op
PASS
ok github.com/SimonWaldherr/golang-benchmarks/math 7.463s
// Package parse benchmarks parsing.
package parse
import (
"strconv"
"testing"
)
func BenchmarkParseBool(b *testing.B) {
for n := 0; n < b.N; n++ {
_, err := strconv.ParseBool("true")
if err != nil {
panic(err)
}
}
}
func BenchmarkParseInt(b *testing.B) {
for n := 0; n < b.N; n++ {
_, err := strconv.ParseInt("1337", 10, 64)
if err != nil {
panic(err)
}
}
}
func BenchmarkParseFloat(b *testing.B) {
for n := 0; n < b.N; n++ {
_, err := strconv.ParseFloat("3.141592653589793238462643383", 64)
if err != nil {
panic(err)
}
}
}$ go test -bench . -benchmem
goos: windows
goarch: amd64
pkg: github.com/SimonWaldherr/golang-benchmarks/parse
cpu: AMD Ryzen 5 3500U with Radeon Vega Mobile Gfx
BenchmarkParseBool-8 1000000000 0.6245 ns/op 0 B/op 0 allocs/op
BenchmarkParseInt-8 54551900 18.86 ns/op 0 B/op 0 allocs/op
BenchmarkParseFloat-8 10073257 122.2 ns/op 0 B/op 0 allocs/op
PASS
ok github.com/SimonWaldherr/golang-benchmarks/parse 3.160s
// Package random compares math/rand with crypto/rand.
// math/rand is much faster than crypto/rand, but it
// returns only a pseudo random number.
package random
import (
crand "crypto/rand"
"encoding/base64"
"math/big"
mrand "math/rand"
"testing"
)
func BenchmarkMathRand(b *testing.B) {
for n := 0; n < b.N; n++ {
mrand.Int63n(0xFFFF)
}
}
func BenchmarkCryptoRand(b *testing.B) {
for n := 0; n < b.N; n++ {
_, err := crand.Int(crand.Reader, big.NewInt(0xFFFF))
if err != nil {
panic(err)
}
}
}
func BenchmarkCryptoRandString(b *testing.B) {
for n := 0; n < b.N; n++ {
_, err := GenerateRandomString(32)
if err != nil {
panic(err)
}
}
}
func GenerateRandomBytes(n int) ([]byte, error) {
b := make([]byte, n)
_, err := mrand.Read(b)
if err != nil {
return nil, err
}
return b, nil
}
func GenerateRandomString(s int) (string, error) {
b, err := GenerateRandomBytes(s)
return base64.URLEncoding.EncodeToString(b), err
}$ go test -bench . -benchmem
goos: windows
goarch: amd64
pkg: github.com/SimonWaldherr/golang-benchmarks/random
cpu: AMD Ryzen 5 3500U with Radeon Vega Mobile Gfx
BenchmarkMathRand-8 51076435 22.53 ns/op 0 B/op 0 allocs/op
BenchmarkCryptoRand-8 3178332 374.1 ns/op 56 B/op 4 allocs/op
BenchmarkCryptoRandString-8 4236312 288.6 ns/op 128 B/op 3 allocs/op
PASS
ok github.com/SimonWaldherr/golang-benchmarks/random 4.331s
// Package regexp benchmarks the performance of a pre-compiled regexp match
// a non-pre-compiled match and JIT-cached-compilation via golibs: https://simonwaldherr.de/go/golibs
package regexp
import (
"regexp"
"testing"
"simonwaldherr.de/go/golibs/regex"
)
var regexpStr string = `^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,9}$`
func BenchmarkMatchString(b *testing.B) {
for n := 0; n < b.N; n++ {
_, err := regexp.MatchString(regexpStr, "[email protected]")
if err != nil {
panic(err)
}
}
}
func BenchmarkMatchStringCompiled(b *testing.B) {
r, err := regexp.Compile(regexpStr)
if err != nil {
panic(err)
}
b.ResetTimer()
for n := 0; n < b.N; n++ {
r.MatchString("[email protected]")
}
}
func BenchmarkMatchStringGolibs(b *testing.B) {
for n := 0; n < b.N; n++ {
_, err := regex.MatchString("[email protected]", regexpStr)
if err != nil {
panic(err)
}
}
}$ go test -bench . -benchmem
goos: windows
goarch: amd64
pkg: github.com/SimonWaldherr/golang-benchmarks/regexp
cpu: AMD Ryzen 5 3500U with Radeon Vega Mobile Gfx
BenchmarkMatchString-8 71940 15527 ns/op 9969 B/op 86 allocs/op
BenchmarkMatchStringCompiled-8 1611652 803.6 ns/op 0 B/op 0 allocs/op
BenchmarkMatchStringGolibs-8 1000000 1011 ns/op 0 B/op 0 allocs/op
PASS
ok github.com/SimonWaldherr/golang-benchmarks/regexp 4.432s