internal: use a sync.Pool of msgpack.Decoder

The change helps to avoid 2 allocations per a response decoding.

You could check the change with the command:

$ go test -v . -bench Bench -run f -benchmem

Author: oleg-jukovec

CHANGELOG.md

@@ -10,6 +10,9 @@ Versioning](http://semver.org/spec/v2.0.0.html) except to the first release.
 
 ### Added
 
+- A usage of sync.Pool of msgpack.Decoder saves 2 object allocations per
+  a response decoding.
+
 ### Changed
 
 - Connect() now retry the connection if a failure occurs and opts.Reconnect > 0.

box_error.go

@@ -278,7 +278,9 @@ func (e *BoxError) UnmarshalMsgpack(b []byte) error {
 	}
 
 	buf := bytes.NewBuffer(b)
-	dec := msgpack.NewDecoder(buf)
+
+	dec := getDecoder(buf)
+	defer putDecoder(dec)
 
 	if val, err := decodeBoxError(dec); err != nil {
 		return err

connection.go

@@ -803,7 +803,9 @@ func (conn *Connection) writer(w writeFlusher, c Conn) {
 func readWatchEvent(reader io.Reader) (connWatchEvent, error) {
 	keyExist := false
 	event := connWatchEvent{}
-	d := msgpack.NewDecoder(reader)
+
+	d := getDecoder(reader)
+	defer putDecoder(d)
 
 	l, err := d.DecodeMapLen()
 	if err != nil {

decoder.go

@@ -0,0 +1,33 @@
+package tarantool
+
+import (
+	"io"
+	"sync"
+
+	"github.com/vmihailenco/msgpack/v5"
+)
+
+func untypedMapDecoder(dec *msgpack.Decoder) (interface{}, error) {
+	return dec.DecodeUntypedMap()
+}
+
+var decPool = sync.Pool{
+	New: func() interface{} {
+		d := msgpack.NewDecoder(nil)
+
+		return d
+	},
+}
+
+func getDecoder(r io.Reader) *msgpack.Decoder {
+	d := decPool.Get().(*msgpack.Decoder)
+
+	d.Reset(r)
+	d.SetMapDecoder(untypedMapDecoder)
+
+	return d
+}
+
+func putDecoder(dec *msgpack.Decoder) {
+	decPool.Put(dec)
+}

dial.go

@@ -547,7 +547,11 @@ func readResponse(r io.Reader, req Request) (Response, error) {
 	}
 
 	buf := smallBuf{b: respBytes}
-	header, _, err := decodeHeader(msgpack.NewDecoder(&smallBuf{}), &buf)
+
+	d := getDecoder(&buf)
+	defer putDecoder(d)
+
+	header, _, err := decodeHeader(d, &buf)
 	if err != nil {
 		return nil, fmt.Errorf("decode response header error: %w", err)
 	}

response.go

@@ -329,10 +329,8 @@ func (resp *baseResponse) Decode() ([]interface{}, error) {
 		var l int
 		info := &decodeInfo{}
 
-		d := msgpack.NewDecoder(&resp.buf)
-		d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {
-			return dec.DecodeUntypedMap()
-		})
+		d := getDecoder(&resp.buf)
+		defer putDecoder(d)
 
 		if l, err = d.DecodeMapLen(); err != nil {
 			resp.err = err
@@ -384,10 +382,8 @@ func (resp *SelectResponse) Decode() ([]interface{}, error) {
 		var l int
 		info := &decodeInfo{}
 
-		d := msgpack.NewDecoder(&resp.buf)
-		d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {
-			return dec.DecodeUntypedMap()
-		})
+		d := getDecoder(&resp.buf)
+		defer putDecoder(d)
 
 		if l, err = d.DecodeMapLen(); err != nil {
 			resp.err = err
@@ -447,10 +443,8 @@ func (resp *ExecuteResponse) Decode() ([]interface{}, error) {
 		var l int
 		info := &decodeInfo{}
 
-		d := msgpack.NewDecoder(&resp.buf)
-		d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {
-			return dec.DecodeUntypedMap()
-		})
+		d := getDecoder(&resp.buf)
+		defer putDecoder(d)
 
 		if l, err = d.DecodeMapLen(); err != nil {
 			resp.err = err
@@ -535,10 +529,8 @@ func (resp *baseResponse) DecodeTyped(res interface{}) error {
 		info := &decodeInfo{}
 		var l int
 
-		d := msgpack.NewDecoder(&resp.buf)
-		d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {
-			return dec.DecodeUntypedMap()
-		})
+		d := getDecoder(&resp.buf)
+		defer putDecoder(d)
 
 		if l, err = d.DecodeMapLen(); err != nil {
 			return err
@@ -576,10 +568,8 @@ func (resp *SelectResponse) DecodeTyped(res interface{}) error {
 		info := &decodeInfo{}
 		var l int
 
-		d := msgpack.NewDecoder(&resp.buf)
-		d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {
-			return dec.DecodeUntypedMap()
-		})
+		d := getDecoder(&resp.buf)
+		defer putDecoder(d)
 
 		if l, err = d.DecodeMapLen(); err != nil {
 			return err
@@ -624,10 +614,8 @@ func (resp *ExecuteResponse) DecodeTyped(res interface{}) error {
 		info := &decodeInfo{}
 		var l int
 
-		d := msgpack.NewDecoder(&resp.buf)
-		d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {
-			return dec.DecodeUntypedMap()
-		})
+		d := getDecoder(&resp.buf)
+		defer putDecoder(d)
 
 		if l, err = d.DecodeMapLen(); err != nil {
 			return err