kythe.io@v0.0.68-0.20240422202219-7225dbc01741/kythe/go/util/riegeli/riegeli_bench_test.go (about) 1 /* 2 * Copyright 2018 The Kythe Authors. All rights reserved. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package riegeli 18 19 import ( 20 "bytes" 21 "encoding/binary" 22 "io" 23 "io/ioutil" 24 "math/rand" 25 "testing" 26 ) 27 28 var nullRecord = bytes.Repeat([]byte{0}, maxRandRecordSize) 29 30 func genNulls(size int) [][]byte { 31 recs := make([][]byte, size) 32 for i := 0; i < size; i++ { 33 recs[i] = nullRecord 34 } 35 return recs 36 } 37 38 const maxRandRecordSize = 1024 * 1024 * 8 39 40 func genRand(seed int64) func(int) [][]byte { 41 return func(size int) [][]byte { 42 rand := rand.New(rand.NewSource(seed)) 43 recs := make([][]byte, 0, size) 44 buf := make([]byte, size*maxRandRecordSize+8) 45 for n := 0; n < size; n++ { 46 l := rand.Int() % maxRandRecordSize 47 for i := 0; i < l; i += 8 { 48 binary.LittleEndian.PutUint64(buf[i:], rand.Uint64()) 49 } 50 recs = append(recs, buf[:l]) 51 buf = buf[l:] 52 } 53 return recs 54 } 55 } 56 57 func benchWrite(b *testing.B, out io.Writer, pos int, opts *WriterOptions, gen func(int) [][]byte) { 58 recs := gen(b.N) 59 b.ResetTimer() 60 w := NewWriterAt(out, pos, opts) 61 for _, rec := range recs { 62 if err := w.Put(rec); err != nil { 63 b.Fatal(err) 64 } 65 b.SetBytes(int64(len(rec))) 66 } 67 if err := w.Flush(); err != nil { 68 b.Fatal(err) 69 } 70 } 71 72 var benchOptions = []string{ 73 "default", 74 75 "uncompressed", 76 "brotli", 77 "snappy", 78 "zstd", 79 80 "uncompressed,transpose", 81 "brotli,transpose", 82 "snappy,transpose", 83 "zstd,transpose", 84 } 85 86 func BenchmarkWriteNull(b *testing.B) { 87 for _, test := range benchOptions { 88 opts, err := ParseOptions(test) 89 if err != nil { 90 b.Fatal(err) 91 } 92 b.Run(test, func(b *testing.B) { benchWrite(b, ioutil.Discard, 0, opts, genNulls) }) 93 } 94 } 95 func BenchmarkWriteRand(b *testing.B) { 96 for _, test := range benchOptions { 97 opts, err := ParseOptions(test) 98 if err != nil { 99 b.Fatal(err) 100 } 101 b.Run(test, func(b *testing.B) { benchWrite(b, ioutil.Discard, 0, opts, genRand(0)) }) 102 } 103 } 104 105 func benchRead(b *testing.B, opts *WriterOptions, gen func(int) [][]byte) { 106 buf := bytes.NewBuffer(nil) 107 benchWrite(b, buf, 0, opts, gen) 108 b.ResetTimer() 109 110 r := NewReader(buf) 111 for i := 0; i < b.N; i++ { 112 rec, err := r.Next() 113 if err != nil { 114 b.Fatal(err) 115 } 116 b.SetBytes(int64(len(rec))) 117 } 118 } 119 120 func BenchmarkReadNull(b *testing.B) { 121 for _, test := range benchOptions { 122 opts, err := ParseOptions(test) 123 if err != nil { 124 b.Fatal(err) 125 } 126 b.Run(test, func(b *testing.B) { benchRead(b, opts, genNulls) }) 127 } 128 } 129 func BenchmarkReadRand(b *testing.B) { 130 for _, test := range benchOptions { 131 opts, err := ParseOptions(test) 132 if err != nil { 133 b.Fatal(err) 134 } 135 b.Run(test, func(b *testing.B) { benchRead(b, opts, genRand(0)) }) 136 } 137 }