Debian Codegraph @

proto/decode_test.go

raw
1 // Go support for Protocol Buffers - Google's data interchange format
2 //
3 // Copyright 2010 The Go Authors. All rights reserved.
4 // https://github.com/golang/protobuf
5 //
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions are
8 // met:
9 //
10 // * Redistributions of source code must retain the above copyright
11 // notice, this list of conditions and the following disclaimer.
12 // * Redistributions in binary form must reproduce the above
13 // copyright notice, this list of conditions and the following disclaimer
14 // in the documentation and/or other materials provided with the
15 // distribution.
16 // * Neither the name of Google Inc. nor the names of its
17 // contributors may be used to endorse or promote products derived from
18 // this software without specific prior written permission.
19 //
20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31
32 // +build go1.7
33
34 package proto_test
35
36 import (
37 "testing"
38
39 "github.com/gogo/protobuf/proto"
40 tpb "github.com/gogo/protobuf/proto/proto3_proto"
41 )
42
43 var msgBlackhole = new(tpb.Message)
44
45 // Disabled this Benchmark because it is using features (b.Run) from go1.7 and gogoprotobuf still have compatibility with go1.5
46 // BenchmarkVarint32ArraySmall shows the performance on an array of small int32 fields (1 and
47 // 2 bytes long).
48 // func BenchmarkVarint32ArraySmall(b *testing.B) {
49 // for i := uint(1); i <= 10; i++ {
50 // dist := genInt32Dist([7]int{0, 3, 1}, 1<<i)
51 // raw, err := proto.Marshal(&tpb.Message{
52 // ShortKey: dist,
53 // })
54 // if err != nil {
55 // b.Error("wrong encode", err)
56 // }
57 // b.Run(fmt.Sprintf("Len%v", len(dist)), func(b *testing.B) {
58 // scratchBuf := proto.NewBuffer(nil)
59 // b.ResetTimer()
60 // for k := 0; k < b.N; k++ {
61 // scratchBuf.SetBuf(raw)
62 // msgBlackhole.Reset()
63 // if err := scratchBuf.Unmarshal(msgBlackhole); err != nil {
64 // b.Error("wrong decode", err)
65 // }
66 // }
67 // })
68 // }
69 // }
70
71 // Disabled this Benchmark because it is using features (b.Run) from go1.7 and gogoprotobuf still have compatibility with go1.5
72 // BenchmarkVarint32ArrayLarge shows the performance on an array of large int32 fields (3 and
73 // 4 bytes long, with a small number of 1, 2, 5 and 10 byte long versions).
74 // func BenchmarkVarint32ArrayLarge(b *testing.B) {
75 // for i := uint(1); i <= 10; i++ {
76 // dist := genInt32Dist([7]int{0, 1, 2, 4, 8, 1, 1}, 1<<i)
77 // raw, err := proto.Marshal(&tpb.Message{
78 // ShortKey: dist,
79 // })
80 // if err != nil {
81 // b.Error("wrong encode", err)
82 // }
83 // b.Run(fmt.Sprintf("Len%v", len(dist)), func(b *testing.B) {
84 // scratchBuf := proto.NewBuffer(nil)
85 // b.ResetTimer()
86 // for k := 0; k < b.N; k++ {
87 // scratchBuf.SetBuf(raw)
88 // msgBlackhole.Reset()
89 // if err := scratchBuf.Unmarshal(msgBlackhole); err != nil {
90 // b.Error("wrong decode", err)
91 // }
92 // }
93 // })
94 // }
95 // }
96
97 // Disabled this Benchmark because it is using features (b.Run) from go1.7 and gogoprotobuf still have compatibility with go1.5
98 // BenchmarkVarint64ArraySmall shows the performance on an array of small int64 fields (1 and
99 // 2 bytes long).
100 // func BenchmarkVarint64ArraySmall(b *testing.B) {
101 // for i := uint(1); i <= 10; i++ {
102 // dist := genUint64Dist([11]int{0, 3, 1}, 1<<i)
103 // raw, err := proto.Marshal(&tpb.Message{
104 // Key: dist,
105 // })
106 // if err != nil {
107 // b.Error("wrong encode", err)
108 // }
109 // b.Run(fmt.Sprintf("Len%v", len(dist)), func(b *testing.B) {
110 // scratchBuf := proto.NewBuffer(nil)
111 // b.ResetTimer()
112 // for k := 0; k < b.N; k++ {
113 // scratchBuf.SetBuf(raw)
114 // msgBlackhole.Reset()
115 // if err := scratchBuf.Unmarshal(msgBlackhole); err != nil {
116 // b.Error("wrong decode", err)
117 // }
118 // }
119 // })
120 // }
121 // }
122
123 // Disabled this Benchmark because it is using features (b.Run) from go1.7 and gogoprotobuf still have compatibility with go1.5
124 // BenchmarkVarint64ArrayLarge shows the performance on an array of large int64 fields (6, 7,
125 // and 8 bytes long with a small number of the other sizes).
126 // func BenchmarkVarint64ArrayLarge(b *testing.B) {
127 // for i := uint(1); i <= 10; i++ {
128 // dist := genUint64Dist([11]int{0, 1, 1, 2, 4, 8, 16, 32, 16, 1, 1}, 1<<i)
129 // raw, err := proto.Marshal(&tpb.Message{
130 // Key: dist,
131 // })
132 // if err != nil {
133 // b.Error("wrong encode", err)
134 // }
135 // b.Run(fmt.Sprintf("Len%v", len(dist)), func(b *testing.B) {
136 // scratchBuf := proto.NewBuffer(nil)
137 // b.ResetTimer()
138 // for k := 0; k < b.N; k++ {
139 // scratchBuf.SetBuf(raw)
140 // msgBlackhole.Reset()
141 // if err := scratchBuf.Unmarshal(msgBlackhole); err != nil {
142 // b.Error("wrong decode", err)
143 // }
144 // }
145 // })
146 // }
147 // }
148
149 // Disabled this Benchmark because it is using features (b.Run) from go1.7 and gogoprotobuf still have compatibility with go1.5
150 // BenchmarkVarint64ArrayMixed shows the performance of lots of small messages, each
151 // containing a small number of large (3, 4, and 5 byte) repeated int64s.
152 // func BenchmarkVarint64ArrayMixed(b *testing.B) {
153 // for i := uint(1); i <= 1<<5; i <<= 1 {
154 // dist := genUint64Dist([11]int{0, 0, 0, 4, 6, 4, 0, 0, 0, 0, 0}, int(i))
155 // // number of sub fields
156 // for k := uint(1); k <= 1<<10; k <<= 2 {
157 // msg := &tpb.Message{}
158 // for m := uint(0); m < k; m++ {
159 // msg.Children = append(msg.Children, &tpb.Message{
160 // Key: dist,
161 // })
162 // }
163 // raw, err := proto.Marshal(msg)
164 // if err != nil {
165 // b.Error("wrong encode", err)
166 // }
167 // b.Run(fmt.Sprintf("Fields%vLen%v", k, i), func(b *testing.B) {
168 // scratchBuf := proto.NewBuffer(nil)
169 // b.ResetTimer()
170 // for k := 0; k < b.N; k++ {
171 // scratchBuf.SetBuf(raw)
172 // msgBlackhole.Reset()
173 // if err := scratchBuf.Unmarshal(msgBlackhole); err != nil {
174 // b.Error("wrong decode", err)
175 // }
176 // }
177 // })
178 // }
179 // }
180 // }
181
182 // genInt32Dist generates a slice of ints that will match the size distribution of dist.
183 // A size of 6 corresponds to a max length varint32, which is 10 bytes. The distribution
184 // is 1-indexed. (i.e. the value at index 1 is how many 1 byte ints to create).
185 func genInt32Dist(dist [7]int, count int) (dest []int32) {
186 for i := 0; i < count; i++ {
187 for k := 0; k < len(dist); k++ {
188 var num int32
189 switch k {
190 case 1:
191 num = 1<<7 - 1
192 case 2:
193 num = 1<<14 - 1
194 case 3:
195 num = 1<<21 - 1
196 case 4:
197 num = 1<<28 - 1
198 case 5:
199 num = 1<<29 - 1
200 case 6:
201 num = -1
202 }
203 for m := 0; m < dist[k]; m++ {
204 dest = append(dest, num)
205 }
206 }
207 }
208 return
209 }
210
211 // genUint64Dist generates a slice of ints that will match the size distribution of dist.
212 // The distribution is 1-indexed. (i.e. the value at index 1 is how many 1 byte ints to create).
213 func genUint64Dist(dist [11]int, count int) (dest []uint64) {
214 for i := 0; i < count; i++ {
215 for k := 0; k < len(dist); k++ {
216 var num uint64
217 switch k {
218 case 1:
219 num = 1<<7 - 1
220 case 2:
221 num = 1<<14 - 1
222 case 3:
223 num = 1<<21 - 1
224 case 4:
225 num = 1<<28 - 1
226 case 5:
227 num = 1<<35 - 1
228 case 6:
229 num = 1<<42 - 1
230 case 7:
231 num = 1<<49 - 1
232 case 8:
233 num = 1<<56 - 1
234 case 9:
235 num = 1<<63 - 1
236 case 10:
237 num = 1<<64 - 1
238 }
239 for m := 0; m < dist[k]; m++ {
240 dest = append(dest, num)
241 }
242 }
243 }
244 return
245 }
246
247 // BenchmarkDecodeEmpty measures the overhead of doing the minimal possible decode.
248 func BenchmarkDecodeEmpty(b *testing.B) {
249 raw, err := proto.Marshal(&tpb.Message{})
250 if err != nil {
251 b.Error("wrong encode", err)
252 }
253 b.ResetTimer()
254 for i := 0; i < b.N; i++ {
255 if err := proto.Unmarshal(raw, msgBlackhole); err != nil {
256 b.Error("wrong decode", err)
257 }
258 }
259 }