bitsToInt optimization

[hollowness-inside]

Creating a new bytes reader with each function call is inefficient as it requires a lot of allocations and performs a lot of operations. The needed numeric types can be retrieved simply by utilizing bitwise operations. This approach is good in performance and the code looks simpler and cleaner.

I ran benchmarks on the Bits24ToIntReader function and the provided optimized. Here are my results:

goos: windows
goarch: amd64
pkg: bitsToInt
cpu: 12th Gen Intel(R) Core(TM) i7-12650H
BenchmarkReader-16       2183080               522.5 ns/op           576 B/op         36 allocs/op
BenchmarkBitwise-16     430430271                2.823 ns/op           0 B/op          0 allocs/op
BenchmarkCast-16        450972691                2.645 ns/op           0 B/op          0 allocs/op

And here are the functions that I benchmarked:

• Original, with the use of bytes.NewReader

  func Bits24ToIntReader(b []byte) int {
  if len(b) != 3 {
      panic("Expected size 3!")
  }
  // add some padding to turn a 24-bit integer into a 32-bit integer
  b = append([]byte{0x00}, b...)
  var payload int32
  buf := bytes.NewReader(b)
  err := binary.Read(buf, binary.LittleEndian, &payload)
  if err != nil {
      // TODO: make safe
      panic(err)
  }
  return int(payload) // easier to work with ints
  }

• Bitwise operations, shift and or

  func Bits24ToIntBitwise(b []byte) int {
  _ = b[2]
  out := (int32(b[2]) << 24) | (int32(b[1]) << 16) | (int32(b[0]) << 8)
  return int(out)
  }

• Unsafe cast (but should be safe since we check whether the sufficient number of elements is present, right?)

  func Bits24ToIntCast(b []byte) int {
  _ = b[2]
  out := *(*uint32)(unsafe.Pointer(&b[0])) << 8
  return int(out)
  }