lib: added zeropool library

Signed-off-by: Anagh Kumar Baranwal <6824881+darthShadow@users.noreply.github.com>

Author: darthShadow

lib/zeropool/pool.go

@@ -0,0 +1,70 @@
+// Package zeropool provides a zero-allocation type-safe alternative for sync.Pool, used to workaround staticheck SA6002.
+// The contents of this package are brought from https://github.com/colega/zeropool because "little copying is better than little dependency".
+package zeropool
+
+import (
+	"sync"
+)
+
+// Pool is a type-safe pool of items that does not allocate pointers to items.
+// That is not entirely true, it does allocate sometimes, but not most of the time,
+// just like the usual sync.Pool pools items most of the time, except when they're evicted.
+// It does that by storing the allocated pointers in a secondary pool instead of letting them go,
+// so they can be used later to store the items again.
+//
+// Zero value of Pool[T] is valid, and it will return zero values of T if nothing is pooled.
+type Pool[T any] struct {
+	// items holds pointers to the pooled items, which are valid to be used.
+	items sync.Pool
+	// pointers holds just pointers to the pooled item types.
+	// The values referenced by pointers are not valid to be used (as they're used by some other caller)
+	// and it is safe to overwrite these pointers.
+	pointers sync.Pool
+}
+
+// New creates a new Pool[T] with the given function to create new items.
+// A Pool must not be copied after first use.
+func New[T any](item func() T) Pool[T] {
+	return Pool[T]{
+		items: sync.Pool{
+			New: func() interface{} {
+				val := item()
+				return &val
+			},
+		},
+	}
+}
+
+// Get returns an item from the pool, creating a new one if necessary.
+// Get may be called concurrently from multiple goroutines.
+func (p *Pool[T]) Get() T {
+	pooled := p.items.Get()
+	if pooled == nil {
+		// The only way this can happen is when someone is using the zero-value of zeropool.Pool, and items pool is empty.
+		// We don't have a pointer to store in p.pointers, so just return the empty value.
+		var zero T
+		return zero
+	}
+
+	ptr := pooled.(*T)
+	item := *ptr
+	var zero T
+	// We don't want to retain the value in p.pointers.
+	// If T holds a reference to something, we want that to be garbage-collected
+	// if for some reason caller does less Put() calls than Get() calls.
+	*ptr = zero
+	p.pointers.Put(ptr)
+	return item
+}
+
+// Put adds an item to the pool.
+func (p *Pool[T]) Put(item T) {
+	var ptr *T
+	if pooled := p.pointers.Get(); pooled != nil {
+		ptr = pooled.(*T)
+	} else {
+		ptr = new(T)
+	}
+	*ptr = item
+	p.items.Put(ptr)
+}

lib/zeropool/pool_test.go

@@ -0,0 +1,272 @@
+package zeropool_test
+
+import (
+	"math"
+	"reflect"
+	"sync"
+	"sync/atomic"
+	"testing"
+
+	"github.com/rclone/rclone/lib/zeropool"
+)
+
+func TestPool(t *testing.T) {
+	t.Run("provides correct values", func(t *testing.T) {
+		pool := zeropool.New(func() []byte { return make([]byte, 1024) })
+		item1 := pool.Get()
+		assertEqual(t, 1024, len(item1))
+
+		item2 := pool.Get()
+		assertEqual(t, 1024, len(item2))
+
+		pool.Put(item1)
+		pool.Put(item2)
+
+		item1 = pool.Get()
+		assertEqual(t, 1024, len(item1))
+
+		item2 = pool.Get()
+		assertEqual(t, 1024, len(item2))
+	})
+
+	t.Run("is not racy", func(t *testing.T) {
+		pool := zeropool.New(func() []byte { return make([]byte, 1024) })
+
+		const iterations = 1e6
+		const concurrency = math.MaxUint8
+		var counter atomic.Int64
+
+		do := make(chan struct{}, 1e6)
+		for i := 0; i < iterations; i++ {
+			do <- struct{}{}
+		}
+		close(do)
+
+		run := make(chan struct{})
+		done := sync.WaitGroup{}
+		done.Add(concurrency)
+		for i := 0; i < concurrency; i++ {
+			go func(worker int) {
+				<-run
+				for range do {
+					item := pool.Get()
+					item[0] = byte(worker)
+					counter.Add(1) // Counts and also adds some delay to add raciness.
+					if item[0] != byte(worker) {
+						panic("wrong value")
+					}
+					pool.Put(item)
+				}
+				done.Done()
+			}(i)
+		}
+		close(run)
+		done.Wait()
+		t.Logf("Done %d iterations", counter.Load())
+	})
+
+	t.Run("does not allocate", func(t *testing.T) {
+		pool := zeropool.New(func() []byte { return make([]byte, 1024) })
+		// Warm up, this will alloate one slice.
+		slice := pool.Get()
+		pool.Put(slice)
+
+		allocs := testing.AllocsPerRun(1000, func() {
+			slice := pool.Get()
+			pool.Put(slice)
+		})
+		assertEqualf(t, float64(0), allocs, "Should not allocate.")
+	})
+
+	t.Run("zero value is valid", func(t *testing.T) {
+		var pool zeropool.Pool[[]byte]
+		slice := pool.Get()
+		pool.Put(slice)
+
+		allocs := testing.AllocsPerRun(1000, func() {
+			slice := pool.Get()
+			pool.Put(slice)
+		})
+		assertEqualf(t, float64(0), allocs, "Should not allocate.")
+	})
+}
+
+func BenchmarkZeropoolPool(b *testing.B) {
+	b.Run("same goroutine", func(b *testing.B) {
+		pool := zeropool.New(func() []byte { return make([]byte, 1024) })
+
+		// Warmup
+		item := pool.Get()
+		pool.Put(item)
+
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			item := pool.Get()
+			pool.Put(item)
+		}
+	})
+
+	b.Run("different goroutines", func(b *testing.B) {
+		pool := zeropool.New(func() []byte { return make([]byte, 1024) })
+
+		ch := make(chan []byte)
+		go func() {
+			for item := range ch {
+				pool.Put(item)
+			}
+		}()
+		defer close(ch)
+
+		// Warmup.
+		ch <- pool.Get()
+
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			ch <- pool.Get()
+		}
+	})
+
+}
+
+// BenchmarkSyncPoolValue uses sync.Pool to store values, which makes an allocation on each Put call.
+func BenchmarkSyncPoolValue(b *testing.B) {
+	b.Run("same goroutine", func(b *testing.B) {
+		pool := sync.Pool{New: func() any {
+			return make([]byte, 1024)
+		}}
+
+		// Warmup.
+		item := pool.Get().([]byte)
+		pool.Put(item) //nolint:staticcheck // This allocates.
+
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			item := pool.Get().([]byte)
+			pool.Put(item) //nolint:staticcheck // This allocates.
+		}
+	})
+
+	b.Run("different goroutines", func(b *testing.B) {
+		pool := sync.Pool{New: func() any {
+			return make([]byte, 1024)
+		}}
+
+		ch := make(chan []byte)
+		go func() {
+			for item := range ch {
+				pool.Put(item) //nolint:staticcheck // This allocates.
+			}
+		}()
+		defer close(ch)
+
+		// Warmup
+		ch <- pool.Get().([]byte)
+
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			ch <- pool.Get().([]byte)
+		}
+	})
+}
+
+// BenchmarkSyncPoolNewPointer uses sync.Pool to store pointers, but it calls Put with a new pointer every time.
+func BenchmarkSyncPoolNewPointer(b *testing.B) {
+	b.Run("same goroutine", func(b *testing.B) {
+		pool := sync.Pool{New: func() any {
+			v := make([]byte, 1024)
+			return &v
+		}}
+
+		// Warmup
+		item := pool.Get().(*[]byte)
+		pool.Put(item)
+
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			item := pool.Get().(*[]byte)
+			buf := *item
+			pool.Put(&buf) //nolint:staticcheck  // New pointer.
+		}
+	})
+
+	b.Run("different goroutines", func(b *testing.B) {
+		pool := sync.Pool{New: func() any {
+			v := make([]byte, 1024)
+			return &v
+		}}
+		ch := make(chan []byte)
+		go func() {
+			for item := range ch {
+				pool.Put(&item) //nolint:staticcheck  // New pointer.
+			}
+		}()
+		defer close(ch)
+
+		// Warmup
+		ch <- *(pool.Get().(*[]byte))
+
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			ch <- *(pool.Get().(*[]byte))
+		}
+	})
+}
+
+// BenchmarkSyncPoolPointer illustrates the optimal usage of sync.Pool, not always possible.
+func BenchmarkSyncPoolPointer(b *testing.B) {
+	b.Run("same goroutine", func(b *testing.B) {
+		pool := sync.Pool{New: func() any {
+			v := make([]byte, 1024)
+			return &v
+		}}
+
+		// Warmup
+		item := pool.Get().(*[]byte)
+		pool.Put(item)
+
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			item := pool.Get().(*[]byte)
+			pool.Put(item)
+		}
+	})
+
+	b.Run("different goroutines", func(b *testing.B) {
+		pool := sync.Pool{New: func() any {
+			v := make([]byte, 1024)
+			return &v
+		}}
+
+		ch := make(chan *[]byte)
+		go func() {
+			for item := range ch {
+				pool.Put(item)
+			}
+		}()
+		defer close(ch)
+
+		// Warmup
+		ch <- pool.Get().(*[]byte)
+
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			ch <- pool.Get().(*[]byte)
+		}
+	})
+}
+
+func assertEqual(t *testing.T, expected, got interface{}) {
+	t.Helper()
+	if !reflect.DeepEqual(expected, got) {
+		t.Logf("Expected %v, got %v", expected, got)
+		t.Fail()
+	}
+}
+
+func assertEqualf(t *testing.T, expected, got interface{}, msg string, args ...any) {
+	t.Helper()
+	if !reflect.DeepEqual(expected, got) {
+		t.Logf("Expected %v, got %v", expected, got)
+		t.Errorf(msg, args...)
+	}
+}