api: added future/response releasing methods.

Added method Release to Future and Response's interface,
that allows to free used data directly by calling.
Used to reduce allocations in `reader` function.

Closes #493

Author: ermyar

CHANGELOG.md

@@ -17,6 +17,8 @@ Versioning](http://semver.org/spec/v2.0.0.html) except to the first release.
 * Added Future.cond (sync.Cond) and Future.finished bool. Added Future.finish() marks Future as done (#496).
 * Added function String() for type datetime (#322).
 * New `Future` interface (#470).
+* Method `Release` for `Future` and `Response` interface that allows
+  to free used data directly by calling (#493).
 
 ### Changed
 

connection.go

@@ -39,6 +39,13 @@ var (
 		"to the current connection or connection pool")
 )
 
+var slicePool = &sync.Pool{
+	New: func() interface{} {
+		buf := make([]byte, 1024)
+		return &buf
+	},
+}
+
 const (
 	// Connected signals that connection is established or reestablished.
 	Connected ConnEventKind = iota + 1
@@ -373,7 +380,6 @@ func Connect(ctx context.Context, dialer Dialer, opts Opts) (conn *Connection, e
 	}
 
 	conn.cond = sync.NewCond(&conn.mutex)
-
 	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
@@ -844,12 +850,36 @@ func readWatchEvent(reader io.Reader) (connWatchEvent, error) {
 	return event, nil
 }
 
+func getSlice(length int) *[]byte {
+	bs, ok := slicePool.Get().(*[]byte)
+
+	if ok && cap(*bs) >= int(length) {
+		clear((*bs)[:cap(*bs)])
+		*bs = (*bs)[:length]
+		return bs
+	}
+
+	if ok {
+		slicePool.Put(bs)
+	}
+
+	b := make([]byte, length)
+
+	return &b
+}
+
+func putSlice(buf *[]byte) {
+	slicePool.Put(buf)
+}
+
 func (conn *Connection) reader(r io.Reader, c Conn) {
 	events := make(chan connWatchEvent, 1024)
 	defer close(events)
 
 	go conn.eventer(events)
 
+	buf := &smallBuf{}
+
 	for atomic.LoadUint32(&conn.state) != connClosed {
 		respBytes, err := read(r, conn.lenbuf[:])
 		if err != nil {
@@ -860,8 +890,12 @@ func (conn *Connection) reader(r io.Reader, c Conn) {
 			conn.reconnect(err, c)
 			return
 		}
-		buf := smallBuf{b: respBytes}
-		header, code, err := decodeHeader(conn.dec, &buf)
+
+		buf.b = *respBytes
+		buf.p = 0
+		buf.ptr = respBytes
+
+		header, code, err := decodeHeader(conn.dec, buf)
 		if err != nil {
 			err = ClientError{
 				ErrProtocolError,
@@ -873,7 +907,7 @@ func (conn *Connection) reader(r io.Reader, c Conn) {
 
 		var fut *future = nil
 		if code == iproto.IPROTO_EVENT {
-			if event, err := readWatchEvent(&buf); err == nil {
+			if event, err := readWatchEvent(buf); err == nil {
 				events <- event
 			} else {
 				err = ClientError{
@@ -887,7 +921,7 @@ func (conn *Connection) reader(r io.Reader, c Conn) {
 			conn.opts.Logger.Report(LogBoxSessionPushUnsupported, conn, header)
 		} else {
 			if fut = conn.fetchFuture(header.RequestId); fut != nil {
-				if err := fut.setResponse(header, &buf); err != nil {
+				if err := fut.setResponse(header, buf); err != nil {
 					fut.setError(fmt.Errorf("failed to set response: %w", err))
 				}
 				conn.markDone(fut)
@@ -1190,7 +1224,9 @@ func (conn *Connection) timeouts() {
 	}
 }
 
-func read(r io.Reader, lenbuf []byte) (response []byte, err error) {
+// read uses args to allocate slices for responses using sync.Pool.
+// data must be released later using Release.
+func read(r io.Reader, lenbuf []byte) (response *[]byte, err error) {
 	var length uint64
 
 	if _, err = io.ReadFull(r, lenbuf); err != nil {
@@ -1214,8 +1250,8 @@ func read(r io.Reader, lenbuf []byte) (response []byte, err error) {
 		return
 	}
 
-	response = make([]byte, length)
-	_, err = io.ReadFull(r, response)
+	response = getSlice(int(length))
+	_, err = io.ReadFull(r, *response)
 
 	return
 }

dial.go

@@ -481,6 +481,7 @@ func identify(ctx context.Context, conn Conn) (ProtocolInfo, error) {
 		}
 		return info, err
 	}
+	defer resp.Release()
 	data, err := resp.Decode()
 	if err != nil {
 		return info, err
@@ -536,6 +537,7 @@ func checkProtocolInfo(required ProtocolInfo, actual ProtocolInfo) error {
 func authenticate(ctx context.Context, c Conn, auth Auth, user, pass, salt string) error {
 	var req Request
 	var err error
+	var resp Response
 
 	switch auth {
 	case ChapSha1Auth:
@@ -552,9 +554,10 @@ func authenticate(ctx context.Context, c Conn, auth Auth, user, pass, salt strin
 	if err = writeRequest(ctx, c, req); err != nil {
 		return err
 	}
-	if _, err = readResponse(ctx, c, req); err != nil {
+	if resp, err = readResponse(ctx, c, req); err != nil {
 		return err
 	}
+	resp.Release()
 	return nil
 }
 
@@ -620,17 +623,17 @@ func readResponse(ctx context.Context, conn Conn, req Request) (Response, error)
 		return nil, fmt.Errorf("read error: %w", err)
 	}
 
-	buf := smallBuf{b: respBytes}
+	buf := &smallBuf{b: *respBytes, p: 0}
 
-	d := getDecoder(&buf)
+	d := getDecoder(buf)
 	defer putDecoder(d)
 
-	header, _, err := decodeHeader(d, &buf)
+	header, _, err := decodeHeader(d, buf)
 	if err != nil {
 		return nil, fmt.Errorf("decode response header error: %w", err)
 	}
 
-	resp, err := req.Response(header, &buf)
+	resp, err := req.Response(header, buf)
 	if err != nil {
 		return nil, fmt.Errorf("creating response error: %w", err)
 	}

example_test.go

@@ -1313,6 +1313,7 @@ func ExampleConnection_Do_failure() {
 
 	// We got a future, the request actually not performed yet.
 	future := conn.Do(req)
+	defer future.Release()
 
 	// When the future receives the response, the result of the Future is set
 	// and becomes available. We could wait for that moment with Future.Get(),

future.go

@@ -11,6 +11,7 @@ type Future interface {
 	Get() ([]interface{}, error)
 	GetTyped(result interface{}) error
 	GetResponse() (Response, error)
+	Release()
 	WaitChan() <-chan struct{}
 }
 
@@ -188,3 +189,11 @@ func (fut *future) WaitChan() <-chan struct{} {
 
 	return fut.done
 }
+
+// Release is freeing the Future resources.
+// After this, using this Future becomes invalid.
+func (fut *future) Release() {
+	if fut.resp != nil {
+		fut.resp.Release()
+	}
+}

future_test.go

@@ -55,6 +55,10 @@ func (resp *futureMockResponse) Header() Header {
 	return resp.header
 }
 
+func (resp *futureMockResponse) Release() {
+	// Nothing to do.
+}
+
 func (resp *futureMockResponse) Decode() ([]interface{}, error) {
 	resp.decodeCnt++
 
@@ -219,6 +223,10 @@ func (*futureMock) WaitChan() <-chan struct{} {
 	return nil
 }
 
+func (f *futureMock) Release() {
+	// Nothing to do.
+}
+
 func TestFuture(t *testing.T) {
 	fut := &futureMock{value: 5}
 

prepared.go

@@ -90,7 +90,7 @@ func (req *PrepareRequest) Response(header Header, body io.Reader) (Response, er
 	if err != nil {
 		return nil, err
 	}
-	return &PrepareResponse{baseResponse: baseResp}, nil
+	return &PrepareResponse{baseResponse: *baseResp}, nil
 }
 
 // UnprepareRequest helps you to create an unprepare request object for
@@ -204,5 +204,5 @@ func (req *ExecutePreparedRequest) Response(header Header, body io.Reader) (Resp
 	if err != nil {
 		return nil, err
 	}
-	return &ExecuteResponse{baseResponse: baseResp}, nil
+	return &ExecuteResponse{baseResponse: *baseResp}, nil
 }

request.go

@@ -620,11 +620,11 @@ func (req *SelectRequest) Context(ctx context.Context) *SelectRequest {
 
 // Response creates a response for the SelectRequest.
 func (req *SelectRequest) Response(header Header, body io.Reader) (Response, error) {
-	baseResp, err := createBaseResponse(header, body)
+	SelectResp, err := createSelectResponse(header, body)
 	if err != nil {
 		return nil, err
 	}
-	return &SelectResponse{baseResponse: baseResp}, nil
+	return SelectResp, nil
 }
 
 // InsertRequest helps you to create an insert request object for execution
@@ -1154,7 +1154,7 @@ func (req *ExecuteRequest) Response(header Header, body io.Reader) (Response, er
 	if err != nil {
 		return nil, err
 	}
-	return &ExecuteResponse{baseResponse: baseResp}, nil
+	return &ExecuteResponse{baseResponse: *baseResp}, nil
 }
 
 // WatchOnceRequest synchronously fetches the value currently associated with a

response.go

@@ -12,6 +12,8 @@ import (
 type Response interface {
 	// Header returns a response header.
 	Header() Header
+	// Release free responses data.
+	Release()
 	// Decode decodes a response.
 	Decode() ([]interface{}, error)
 	// DecodeTyped decodes a response into a given container res.
@@ -31,24 +33,39 @@ type baseResponse struct {
 	err          error
 }
 
-func createBaseResponse(header Header, body io.Reader) (baseResponse, error) {
+func createBaseResponse(header Header, body io.Reader) (*baseResponse, error) {
+	resp := &baseResponse{}
 	if body == nil {
-		return baseResponse{header: header}, nil
+		resp.header = header
+		return resp, nil
 	}
 	if buf, ok := body.(*smallBuf); ok {
-		return baseResponse{header: header, buf: *buf}, nil
+		resp.header = header
+		resp.buf.b = buf.b
+		resp.buf.p = buf.p
+		resp.buf.ptr = buf.ptr
+		return resp, nil
 	}
 	data, err := io.ReadAll(body)
 	if err != nil {
-		return baseResponse{}, err
+		return resp, err
 	}
-	return baseResponse{header: header, buf: smallBuf{b: data}}, nil
+	resp.header = header
+	resp.buf.b = data
+	return resp, nil
+}
+
+func (resp *baseResponse) Release() {
+	if resp.buf.ptr != nil {
+		putSlice(resp.buf.ptr)
+	}
+	*resp = baseResponse{}
 }
 
 // DecodeBaseResponse parse response header and body.
 func DecodeBaseResponse(header Header, body io.Reader) (Response, error) {
 	resp, err := createBaseResponse(header, body)
-	return &resp, err
+	return resp, err
 }
 
 // SelectResponse is used for the select requests.
@@ -670,6 +687,33 @@ func (resp *baseResponse) Header() Header {
 	return resp.header
 }
 
+func createSelectResponse(header Header, body io.Reader) (*SelectResponse, error) {
+	resp := &SelectResponse{}
+	if body == nil {
+		resp.header = header
+		return resp, nil
+	}
+	if buf, ok := body.(*smallBuf); ok {
+		resp.header = header
+		resp.buf.b = buf.b
+		resp.buf.p = buf.p
+		resp.buf.ptr = buf.ptr
+		return resp, nil
+	}
+	data, err := io.ReadAll(body)
+	if err != nil {
+		return resp, err
+	}
+	resp.header = header
+	resp.buf.b = data
+	return resp, nil
+}
+
+func (resp *SelectResponse) Release() {
+	resp.baseResponse.Release()
+	resp.pos = nil
+}
+
 // 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) {

smallbuf.go

@@ -6,8 +6,9 @@ import (
 )
 
 type smallBuf struct {
-	b []byte
-	p int
+	b   []byte
+	p   int
+	ptr *[]byte
 }
 
 func (s *smallBuf) Read(d []byte) (l int, err error) {