api: updated response/future methods

Added Response's interface method Buffer.
Connection now contains sync.Pool that was used to
reduce allocations.

Fixes #493

Author: ermyar

CHANGELOG.md

@@ -12,6 +12,7 @@ Versioning](http://semver.org/spec/v2.0.0.html) except to the first release.
 
 * New types for MessagePack extensions compatible with go-option (#459).
 * Added `box.MustNew` wrapper for `box.New` without an error (#448).
+* Method `Buffer` for `Response` interface(#493).
 
 ### Changed
 

connection.go

@@ -175,11 +175,12 @@ func (d defaultLogger) Report(event ConnLogKind, conn *Connection, v ...interfac
 // More on graceful shutdown:
 // https://www.tarantool.io/en/doc/latest/dev_guide/internals/iproto/graceful_shutdown/
 type Connection struct {
-	addr   net.Addr
-	dialer Dialer
-	c      Conn
-	mutex  sync.Mutex
-	cond   *sync.Cond
+	addr      net.Addr
+	dialer    Dialer
+	c         Conn
+	mutex     sync.Mutex
+	cond      *sync.Cond
+	slicePool *sync.Pool
 	// schemaResolver contains a SchemaResolver implementation.
 	schemaResolver SchemaResolver
 	// requestId contains the last request ID for requests with nil context.
@@ -373,7 +374,12 @@ func Connect(ctx context.Context, dialer Dialer, opts Opts) (conn *Connection, e
 	}
 
 	conn.cond = sync.NewCond(&conn.mutex)
-
+	conn.slicePool = &sync.Pool{
+		New: func() any {
+			buf := make([]byte, 0, 512)
+			return &buf
+		},
+	}
 	if conn.opts.Reconnect > 0 {
 		// We don't need these mutex.Lock()/mutex.Unlock() here, but
 		// runReconnects() expects mutex.Lock() to be set, so it's
@@ -848,8 +854,9 @@ func (conn *Connection) reader(r io.Reader, c Conn) {
 
 	go conn.eventer(events)
 
+	buf := smallBuf{}
 	for atomic.LoadUint32(&conn.state) != connClosed {
-		respBytes, err := read(r, conn.lenbuf[:])
+		respBytes, err := read(r, conn.lenbuf[:], conn)
 		if err != nil {
 			err = ClientError{
 				ErrIoError,
@@ -858,7 +865,7 @@ func (conn *Connection) reader(r io.Reader, c Conn) {
 			conn.reconnect(err, c)
 			return
 		}
-		buf := smallBuf{b: respBytes}
+		buf.b, buf.p = respBytes, 0
 		header, code, err := decodeHeader(conn.dec, &buf)
 		if err != nil {
 			err = ClientError{
@@ -925,7 +932,7 @@ func (conn *Connection) eventer(events <-chan connWatchEvent) {
 
 func (conn *Connection) newFuture(req Request) (fut *Future) {
 	ctx := req.Ctx()
-	fut = NewFuture(req)
+	fut = NewFuture(req, conn)
 	if conn.rlimit != nil && conn.opts.RLimitAction == RLimitDrop {
 		select {
 		case conn.rlimit <- struct{}{}:
@@ -1187,7 +1194,7 @@ func (conn *Connection) timeouts() {
 	}
 }
 
-func read(r io.Reader, lenbuf []byte) (response []byte, err error) {
+func read(r io.Reader, lenbuf []byte, conn ...*Connection) (response []byte, err error) {
 	var length uint64
 
 	if _, err = io.ReadFull(r, lenbuf); err != nil {
@@ -1211,7 +1218,15 @@ func read(r io.Reader, lenbuf []byte) (response []byte, err error) {
 		return
 	}
 
-	response = make([]byte, length)
+	if len(conn) == 0 {
+		response = make([]byte, length)
+	} else {
+		response = *conn[0].slicePool.Get().(*[]byte)
+		if cap(response) < int(length) {
+			response = make([]byte, length)
+		}
+		response = response[:length]
+	}
 	_, err = io.ReadFull(r, response)
 
 	return
@@ -1232,7 +1247,7 @@ func (conn *Connection) nextRequestId(context bool) (requestId uint32) {
 func (conn *Connection) Do(req Request) *Future {
 	if connectedReq, ok := req.(ConnectedRequest); ok {
 		if connectedReq.Conn() != conn {
-			fut := NewFuture(req)
+			fut := NewFuture(req, conn)
 			fut.SetError(errUnknownRequest)
 			return fut
 		}

future.go

@@ -12,6 +12,7 @@ type Future struct {
 	req       Request
 	next      *Future
 	timeout   time.Duration
+	pool      *sync.Pool
 	mutex     sync.Mutex
 	resp      Response
 	err       error
@@ -38,10 +39,15 @@ func (fut *Future) isDone() bool {
 }
 
 // NewFuture creates a new empty Future for a given Request.
-func NewFuture(req Request) (fut *Future) {
+func NewFuture(req Request, conn ...*Connection) (fut *Future) {
 	fut = &Future{}
 	fut.done = make(chan struct{})
 	fut.req = req
+	if len(conn) == 0 {
+		fut.pool = nil
+	} else {
+		fut.pool = conn[0].slicePool
+	}
 	return fut
 }
 
@@ -61,6 +67,7 @@ func (fut *Future) SetResponse(header Header, body io.Reader) error {
 	fut.resp = resp
 
 	close(fut.done)
+	fut.release()
 	return nil
 }
 
@@ -75,6 +82,7 @@ func (fut *Future) SetError(err error) {
 	fut.err = err
 
 	close(fut.done)
+	fut.release()
 }
 
 // GetResponse waits for Future to be filled and returns Response and error.
@@ -127,3 +135,9 @@ func (fut *Future) WaitChan() <-chan struct{} {
 	}
 	return fut.done
 }
+
+func (fut *Future) release() {
+	if fut.pool != nil && fut.resp != nil {
+		fut.pool.Put(fut.resp.Buffer())
+	}
+}

future_test.go

@@ -53,6 +53,10 @@ func (resp *futureMockResponse) Header() Header {
 	return resp.header
 }
 
+func (resp *futureMockResponse) Buffer() *[]byte {
+	return &resp.data
+}
+
 func (resp *futureMockResponse) Decode() ([]interface{}, error) {
 	resp.decodeCnt++
 

response.go

@@ -12,6 +12,8 @@ import (
 type Response interface {
 	// Header returns a response header.
 	Header() Header
+	// Buffer returns a response buffer.
+	Buffer() *[]byte
 	// Decode decodes a response.
 	Decode() ([]interface{}, error)
 	// DecodeTyped decodes a response into a given container res.
@@ -657,6 +659,10 @@ func (resp *baseResponse) Header() Header {
 	return resp.header
 }
 
+func (resp *baseResponse) Buffer() *[]byte {
+	return &resp.buf.b
+}
+
 // Pos returns a position descriptor of the last selected tuple for the SelectResponse.
 // If the response was not decoded, this method will call Decode().
 func (resp *SelectResponse) Pos() ([]byte, error) {

test_helpers/response.go

@@ -54,6 +54,10 @@ func (resp *MockResponse) Header() tarantool.Header {
 	return resp.header
 }
 
+func (resp *MockResponse) Buffer() *[]byte {
+	return &resp.data
+}
+
 // Decode returns the result of decoding the response data as slice.
 func (resp *MockResponse) Decode() ([]interface{}, error) {
 	if resp.data == nil {