1 package redis_test
2
3 import (
4 "bytes"
5 "fmt"
6 "strings"
7 "testing"
8 "time"
9
10 "github.com/go-redis/redis"
11 )
12
13 func benchmarkRedisClient(poolSize int) *redis.Client {
14 client := redis.NewClient(&redis.Options{
15 Addr: ":6379",
16 DialTimeout: time.Second,
17 ReadTimeout: time.Second,
18 WriteTimeout: time.Second,
19 PoolSize: poolSize,
20 })
21 if err := client.FlushDB().Err(); err != nil {
22 panic(err)
23 }
24 return client
25 }
26
27 func BenchmarkRedisPing(b *testing.B) {
28 client := benchmarkRedisClient(10)
29 defer client.Close()
30
31 b.ResetTimer()
32
33 b.RunParallel(func(pb *testing.PB) {
34 for pb.Next() {
35 if err := client.Ping().Err(); err != nil {
36 b.Fatal(err)
37 }
38 }
39 })
40 }
41
42 func BenchmarkRedisGetNil(b *testing.B) {
43 client := benchmarkRedisClient(10)
44 defer client.Close()
45
46 b.ResetTimer()
47
48 b.RunParallel(func(pb *testing.PB) {
49 for pb.Next() {
50 if err := client.Get("key").Err(); err != redis.Nil {
51 b.Fatal(err)
52 }
53 }
54 })
55 }
56
57 type setStringBenchmark struct {
58 poolSize int
59 valueSize int
60 }
61
62 func (bm setStringBenchmark) String() string {
63 return fmt.Sprintf("pool=%d value=%d", bm.poolSize, bm.valueSize)
64 }
65
66 func BenchmarkRedisSetString(b *testing.B) {
67 benchmarks := []setStringBenchmark{
68 {10, 64},
69 {10, 1024},
70 {10, 64 * 1024},
71 {10, 1024 * 1024},
72 {10, 10 * 1024 * 1024},
73
74 {100, 64},
75 {100, 1024},
76 {100, 64 * 1024},
77 {100, 1024 * 1024},
78 {100, 10 * 1024 * 1024},
79 }
80 for _, bm := range benchmarks {
81 b.Run(bm.String(), func(b *testing.B) {
82 client := benchmarkRedisClient(bm.poolSize)
83 defer client.Close()
84
85 value := strings.Repeat("1", bm.valueSize)
86
87 b.ResetTimer()
88
89 b.RunParallel(func(pb *testing.PB) {
90 for pb.Next() {
91 err := client.Set("key", value, 0).Err()
92 if err != nil {
93 b.Fatal(err)
94 }
95 }
96 })
97 })
98 }
99 }
100
101 func BenchmarkRedisSetGetBytes(b *testing.B) {
102 client := benchmarkRedisClient(10)
103 defer client.Close()
104
105 value := bytes.Repeat([]byte{'1'}, 10000)
106
107 b.ResetTimer()
108
109 b.RunParallel(func(pb *testing.PB) {
110 for pb.Next() {
111 if err := client.Set("key", value, 0).Err(); err != nil {
112 b.Fatal(err)
113 }
114
115 got, err := client.Get("key").Bytes()
116 if err != nil {
117 b.Fatal(err)
118 }
119 if !bytes.Equal(got, value) {
120 b.Fatalf("got != value")
121 }
122 }
123 })
124 }
125
126 func BenchmarkRedisMGet(b *testing.B) {
127 client := benchmarkRedisClient(10)
128 defer client.Close()
129
130 if err := client.MSet("key1", "hello1", "key2", "hello2").Err(); err != nil {
131 b.Fatal(err)
132 }
133
134 b.ResetTimer()
135
136 b.RunParallel(func(pb *testing.PB) {
137 for pb.Next() {
138 if err := client.MGet("key1", "key2").Err(); err != nil {
139 b.Fatal(err)
140 }
141 }
142 })
143 }
144
145 func BenchmarkSetExpire(b *testing.B) {
146 client := benchmarkRedisClient(10)
147 defer client.Close()
148
149 b.ResetTimer()
150
151 b.RunParallel(func(pb *testing.PB) {
152 for pb.Next() {
153 if err := client.Set("key", "hello", 0).Err(); err != nil {
154 b.Fatal(err)
155 }
156 if err := client.Expire("key", time.Second).Err(); err != nil {
157 b.Fatal(err)
158 }
159 }
160 })
161 }
162
163 func BenchmarkPipeline(b *testing.B) {
164 client := benchmarkRedisClient(10)
165 defer client.Close()
166
167 b.ResetTimer()
168
169 b.RunParallel(func(pb *testing.PB) {
170 for pb.Next() {
171 _, err := client.Pipelined(func(pipe redis.Pipeliner) error {
172 pipe.Set("key", "hello", 0)
173 pipe.Expire("key", time.Second)
174 return nil
175 })
176 if err != nil {
177 b.Fatal(err)
178 }
179 }
180 })
181 }
182
183 func BenchmarkZAdd(b *testing.B) {
184 client := benchmarkRedisClient(10)
185 defer client.Close()
186
187 b.ResetTimer()
188
189 b.RunParallel(func(pb *testing.PB) {
190 for pb.Next() {
191 err := client.ZAdd("key", redis.Z{
192 Score: float64(1),
193 Member: "hello",
194 }).Err()
195 if err != nil {
196 b.Fatal(err)
197 }
198 }
199 })
200 }
201
View as plain text