vendor/github.com/lunixbochs/struc/bench_test.go

   1 package struc
   2
   3 import (
   4         "bytes"
   5         "encoding/binary"
   6         "testing"
   7 )
   8
   9 type BenchExample struct {
  10         Test    [5]byte
  11         A       int32
  12         B, C, D int16
  13         Test2   [4]byte
  14         Length  int32
  15 }
  16
  17 type BenchStrucExample struct {
  18         Test    [5]byte `struc:"[5]byte"`
  19         A       int     `struc:"int32"`
  20         B, C, D int     `struc:"int16"`
  21         Test2   [4]byte `struc:"[4]byte"`
  22         Length  int     `struc:"int32,sizeof=Data"`
  23         Data    []byte
  24 }
  25
  26 var benchRef = &BenchExample{
  27         [5]byte{1, 2, 3, 4, 5},
  28         1, 2, 3, 4,
  29         [4]byte{1, 2, 3, 4},
  30         8,
  31 }
  32
  33 var eightBytes = []byte("8bytestr")
  34
  35 var benchStrucRef = &BenchStrucExample{
  36         [5]byte{1, 2, 3, 4, 5},
  37         1, 2, 3, 4,
  38         [4]byte{1, 2, 3, 4},
  39         8, eightBytes,
  40 }
  41
  42 func BenchmarkEncode(b *testing.B) {
  43         for i := 0; i < b.N; i++ {
  44                 var buf bytes.Buffer
  45                 err := Pack(&buf, benchStrucRef)
  46                 if err != nil {
  47                         b.Fatal(err)
  48                 }
  49         }
  50 }
  51
  52 func BenchmarkStdlibEncode(b *testing.B) {
  53         for i := 0; i < b.N; i++ {
  54                 var buf bytes.Buffer
  55                 err := binary.Write(&buf, binary.BigEndian, benchRef)
  56                 if err != nil {
  57                         b.Fatal(err)
  58                 }
  59                 _, err = buf.Write(eightBytes)
  60                 if err != nil {
  61                         b.Fatal(err)
  62                 }
  63         }
  64 }
  65
  66 func BenchmarkManualEncode(b *testing.B) {
  67         order := binary.BigEndian
  68         s := benchStrucRef
  69         for i := 0; i < b.N; i++ {
  70                 var buf bytes.Buffer
  71                 tmp := make([]byte, 29)
  72                 copy(tmp[0:5], s.Test[:])
  73                 order.PutUint32(tmp[5:9], uint32(s.A))
  74                 order.PutUint16(tmp[9:11], uint16(s.B))
  75                 order.PutUint16(tmp[11:13], uint16(s.C))
  76                 order.PutUint16(tmp[13:15], uint16(s.D))
  77                 copy(tmp[15:19], s.Test2[:])
  78                 order.PutUint32(tmp[19:23], uint32(s.Length))
  79                 copy(tmp[23:], s.Data)
  80                 _, err := buf.Write(tmp)
  81                 if err != nil {
  82                         b.Fatal(err)
  83                 }
  84         }
  85 }
  86
  87 func BenchmarkDecode(b *testing.B) {
  88         var out BenchStrucExample
  89         var buf bytes.Buffer
  90         if err := Pack(&buf, benchStrucRef); err != nil {
  91                 b.Fatal(err)
  92         }
  93         bufBytes := buf.Bytes()
  94         for i := 0; i < b.N; i++ {
  95                 buf := bytes.NewReader(bufBytes)
  96                 err := Unpack(buf, &out)
  97                 if err != nil {
  98                         b.Fatal(err)
  99                 }
 100                 out.Data = nil
 101         }
 102 }
 103
 104 func BenchmarkStdlibDecode(b *testing.B) {
 105         var out BenchExample
 106         var buf bytes.Buffer
 107         binary.Write(&buf, binary.BigEndian, *benchRef)
 108         _, err := buf.Write(eightBytes)
 109         if err != nil {
 110                 b.Fatal(err)
 111         }
 112         bufBytes := buf.Bytes()
 113         for i := 0; i < b.N; i++ {
 114                 buf := bytes.NewReader(bufBytes)
 115                 err := binary.Read(buf, binary.BigEndian, &out)
 116                 if err != nil {
 117                         b.Fatal(err)
 118                 }
 119                 tmp := make([]byte, out.Length)
 120                 _, err = buf.Read(tmp)
 121                 if err != nil {
 122                         b.Fatal(err)
 123                 }
 124         }
 125 }
 126
 127 func BenchmarkManualDecode(b *testing.B) {
 128         var o BenchStrucExample
 129         var buf bytes.Buffer
 130         if err := Pack(&buf, benchStrucRef); err != nil {
 131                 b.Fatal(err)
 132         }
 133         tmp := buf.Bytes()
 134         order := binary.BigEndian
 135         for i := 0; i < b.N; i++ {
 136                 copy(o.Test[:], tmp[0:5])
 137                 o.A = int(order.Uint32(tmp[5:9]))
 138                 o.B = int(order.Uint16(tmp[9:11]))
 139                 o.C = int(order.Uint16(tmp[11:13]))
 140                 o.D = int(order.Uint16(tmp[13:15]))
 141                 copy(o.Test2[:], tmp[15:19])
 142                 o.Length = int(order.Uint32(tmp[19:23]))
 143                 o.Data = make([]byte, o.Length)
 144                 copy(o.Data, tmp[23:])
 145         }
 146 }
 147
 148 func BenchmarkFullEncode(b *testing.B) {
 149         for i := 0; i < b.N; i++ {
 150                 var buf bytes.Buffer
 151                 if err := Pack(&buf, reference); err != nil {
 152                         b.Fatal(err)
 153                 }
 154         }
 155 }
 156
 157 func BenchmarkFullDecode(b *testing.B) {
 158         var out Example
 159         for i := 0; i < b.N; i++ {
 160                 buf := bytes.NewBuffer(referenceBytes)
 161                 if err := Unpack(buf, &out); err != nil {
 162                         b.Fatal(err)
 163                 }
 164         }
 165 }