net/http: pool transport gzip readers

name              old time/op    new time/op    delta
GzipReaderInit-8    8.97µs ± 6%    2.61µs ± 7%  -70.87%  (p=0.000 n=10+9)

name              old alloc/op   new alloc/op   delta
GzipReaderInit-8    45.5kB ± 0%     4.4kB ± 0%  -90.36%  (p=0.000 n=10+10)

name              old allocs/op  new allocs/op  delta
GzipReaderInit-8      10.0 ± 0%       6.0 ± 0%  -40.00%  (p=0.000 n=10+10)

Allocation saving comes from absent compress/flate.(*dictDecoder).init

Fixes #61353

Author: AlexanderYastrebov

src/net/http/transport.go

@@ -11,6 +11,7 @@ package http
 
 import (
 	"bufio"
+	"compress/flate"
 	"compress/gzip"
 	"container/list"
 	"context"
@@ -2844,37 +2845,84 @@ func (es *bodyEOFSignal) condfn(err error) error {
 }
 
 // gzipReader wraps a response body so it can lazily
-// call gzip.NewReader on the first call to Read
+// get gzip.Reader from the pool on the first call to Read.
+// After Close is called it puts gzip.Reader to the pool immediately
+// if there is no Read in progress or later when Read completes.
 type gzipReader struct {
 	_    incomparable
 	body *bodyEOFSignal // underlying HTTP/1 response body framing
-	zr   *gzip.Reader   // lazily-initialized gzip reader
-	zerr error          // any error from gzip.NewReader; sticky
+
+	mu      sync.Mutex
+	zr      *gzip.Reader // lazily-initialized gzip reader
+	zerr    error        // any error from gzip.Reader.Reset; sticky
+	reading bool         // true if Read() is in progress
+	closed  bool         // true if Close() was called
 }
 
-func (gz *gzipReader) Read(p []byte) (n int, err error) {
-	if gz.zr == nil {
-		if gz.zerr == nil {
-			gz.zr, gz.zerr = gzip.NewReader(gz.body)
-		}
-		if gz.zerr != nil {
-			return 0, gz.zerr
-		}
-	}
+type eofReader struct{}
+
+func (eofReader) Read([]byte) (int, error) { return 0, io.EOF }
+func (eofReader) ReadByte() (byte, error)  { return 0, io.EOF }
 
-	gz.body.mu.Lock()
-	if gz.body.closed {
+var (
+	gzipPool = sync.Pool{New: func() any { return new(gzip.Reader) }}
+
+	// parkedReader used to reset gzip.Reader before returning into the gzipPool as
+	// gzip.Reader.Reset(flate.Reader) avoids calling bufio.NewReader
+	parkedReader flate.Reader = eofReader{}
+)
+
+func gzipPoolPut(zr *gzip.Reader) {
+	_ = zr.Reset(parkedReader)
+	gzipPool.Put(zr)
+}
+
+func (gz *gzipReader) Read(p []byte) (n int, err error) {
+	gz.mu.Lock()
+	if gz.closed {
 		err = errReadOnClosedResBody
+	} else {
+		if gz.zr == nil {
+			if gz.zerr == nil {
+				zr := gzipPool.Get().(*gzip.Reader)
+				if gz.zerr = zr.Reset(gz.body); gz.zerr == nil {
+					gz.zr = zr
+				} else {
+					gzipPoolPut(zr)
+				}
+			}
+			err = gz.zerr
+		}
 	}
-	gz.body.mu.Unlock()
+	gz.reading = err == nil
+	gz.mu.Unlock()
 
 	if err != nil {
 		return 0, err
 	}
-	return gz.zr.Read(p)
+
+	n, err = gz.zr.Read(p)
+
+	gz.mu.Lock()
+	if gz.closed {
+		gzipPoolPut(gz.zr)
+		gz.zr = nil
+	}
+	gz.reading = false
+	gz.mu.Unlock()
+
+	return
 }
 
 func (gz *gzipReader) Close() error {
+	gz.mu.Lock()
+	if !gz.closed && !gz.reading && gz.zr != nil {
+		gzipPoolPut(gz.zr)
+		gz.zr = nil
+	}
+	gz.closed = true
+	gz.mu.Unlock()
+
 	return gz.body.Close()
 }