Optimize connection pool

[ash2k]

Currently the pool uses a slice and appends and pops connections from the end of the slice (LIFO mode). There is also the FIFO mode, where the code copies the data just to pop an element from the beginning of the slice. Code:

go-redis/internal/pool/pool.go

Lines 326 to 348 in fcb3506

	func (p *ConnPool) popIdle() (*Conn, error) {
	if p.closed() {
	return nil, ErrClosed
	}
	n := len(p.idleConns)
	if n == 0 {
	return nil, nil
	}
	var cn *Conn
	if p.cfg.PoolFIFO {
	cn = p.idleConns[0]
	copy(p.idleConns, p.idleConns[1:])
	p.idleConns = p.idleConns[:n-1]
	} else {
	idx := n - 1
	cn = p.idleConns[idx]
	p.idleConns = p.idleConns[:idx]
	}
	p.idleConnsLen--
	p.checkMinIdleConns()
	return cn, nil
	}

This copying is not efficient, as documented:

go-redis/options.go

Lines 93 to 97 in fcb3506

	// Type of connection pool.
	// true for FIFO pool, false for LIFO pool.
	// Note that FIFO has slightly higher overhead compared to LIFO,
	// but it helps closing idle connections faster reducing the pool size.
	PoolFIFO bool

Why not use a doubly linked list?

The pool.Conn can be embedded into an element struct as is (not a pointer) and then we'd avoid extra allocations for the holder elements. All typical operations will be O(1) - append, prepend. Removal from the middle will be O(n) just like it is today, but only because of the list traversal - no copying will be necessary

WDYT?.