Optimize Batch with double-buffering and slice pooling

- Add overflow buffer for improved batching when pending is full
- Add slice pooling (acquireSlice/releaseSlice) to reduce allocations
- Fix deadlock: promote pending when current=nil to prevent orphaned batches
- Add comprehensive tests and benchmarks for Batch
- Consolidate Makefile test target with race detector

Benchmarks show 0 allocs/op for parallel operations and 1 alloc/op for
sequential (down from 2).

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: MagicalTux

Makefile

@@ -2,7 +2,7 @@
 GOROOT:=$(shell PATH="/pkg/main/dev-lang.go.dev/bin:$$PATH" go env GOROOT)
 GOPATH:=$(shell $(GOROOT)/bin/go env GOPATH)
 
-.PHONY: test deps race
+.PHONY: test deps
 
 all:
 	$(GOPATH)/bin/goimports -w -l .
@@ -12,7 +12,4 @@ deps:
 	$(GOROOT)/bin/go get -v -t .
 
 test:
-	$(GOROOT)/bin/go test -v
-
-race:
-	$(GOROOT)/bin/go test -v -race
+	$(GOROOT)/bin/go test -v -race ./...

batch.go

@@ -1,6 +1,7 @@
 package unison
 
 import (
+	"runtime"
 	"runtime/debug"
 	"sync"
 )
@@ -17,11 +18,13 @@ type batchCall[T any] struct {
 // Any calls that arrive while execution is in progress are collected and processed
 // together in the next batch once the current execution completes.
 type Batch[T any] struct {
-	mu      sync.Mutex
-	fn      func([]T) error
-	current *batchCall[T]
-	pending *batchCall[T]
-	MaxSize int // Maximum batch size, 0 means unlimited
+	mu         sync.Mutex
+	fn         func([]T) error
+	current    *batchCall[T]
+	pending    *batchCall[T]
+	overflow   *batchCall[T] // second buffer when pending is full
+	spareSlice []T           // pooled slice for reuse
+	MaxSize    int           // Maximum batch size, 0 means unlimited
 }
 
 // NewBatch creates a new Batch with the given processing function.
@@ -30,6 +33,28 @@ func NewBatch[T any](fn func([]T) error) *Batch[T] {
 	return &Batch[T]{fn: fn}
 }
 
+// acquireSlice gets a slice from the pool or returns nil.
+// Must be called with b.mu held.
+func (b *Batch[T]) acquireSlice() []T {
+	if b.spareSlice != nil {
+		s := b.spareSlice[:0]
+		b.spareSlice = nil
+		return s
+	}
+	return nil
+}
+
+// releaseSlice returns a slice to the pool for reuse.
+// Must be called with b.mu held.
+func (b *Batch[T]) releaseSlice(s []T) {
+	// Only keep if spare is empty and capacity is reasonable
+	if b.spareSlice == nil && cap(s) > 0 && cap(s) <= 1024 {
+		// Clear slice elements to allow GC of referenced values
+		clear(s[:cap(s)])
+		b.spareSlice = s[:0]
+	}
+}
+
 // Do adds a value to be processed and waits for the batch to complete.
 // All callers in the same batch receive the same error result.
 // If MaxSize is set and the pending batch is full, the caller blocks until
@@ -38,58 +63,137 @@ func (b *Batch[T]) Do(value T) error {
 	b.mu.Lock()
 
 	for {
-		if b.current == nil {
-			// No current execution, start one immediately
-			c := &batchCall[T]{values: []T{value}}
-			c.wg.Add(1)
-			b.current = c
-			b.mu.Unlock()
-			b.run(c)
-			return c.err
-		}
+		// Current is running, try to add to pending or overflow
+		if b.current != nil {
+			// Try pending first
+			p := b.pending
+			if p == nil || b.MaxSize == 0 || len(p.values) < b.MaxSize {
+				if p == nil {
+					p = &batchCall[T]{values: b.acquireSlice()}
+					p.wg.Add(1)
+					b.pending = p
+				}
+				p.values = append(p.values, value)
+				myBatch := p
+				c := b.current
+				b.mu.Unlock()
+
+				// Wait for current to complete
+				c.wg.Wait()
+
+				// Try to become the runner for pending
+				b.mu.Lock()
+				if b.pending == myBatch && b.current == nil {
+					b.pending = b.overflow
+					b.overflow = nil
+					b.current = myBatch
+					b.mu.Unlock()
+					b.run(myBatch)
+					return myBatch.err
+				}
+				b.mu.Unlock()
+
+				// Someone else is running it
+				myBatch.wg.Wait()
+				return myBatch.err
+			}
+
+			// Pending full, try overflow
+			o := b.overflow
+			if o == nil || b.MaxSize == 0 || len(o.values) < b.MaxSize {
+				if o == nil {
+					o = &batchCall[T]{values: b.acquireSlice()}
+					o.wg.Add(1)
+					b.overflow = o
+				}
+				o.values = append(o.values, value)
+				myBatch := o
+				c := b.current
+				p := b.pending
+				b.mu.Unlock()
 
-		// Current is running, check if we can add to pending
-		p := b.pending
-		canAdd := p == nil || b.MaxSize == 0 || len(p.values) < b.MaxSize
+				// Wait for current to complete
+				c.wg.Wait()
+				// Wait for pending to complete (our overflow becomes pending after that)
+				p.wg.Wait()
+
+				// Try to become the runner for our batch (now pending)
+				b.mu.Lock()
+				if b.pending == myBatch && b.current == nil {
+					b.pending = b.overflow
+					b.overflow = nil
+					b.current = myBatch
+					b.mu.Unlock()
+					b.run(myBatch)
+					return myBatch.err
+				}
+				b.mu.Unlock()
 
-		if canAdd {
-			if p == nil {
-				p = &batchCall[T]{}
-				p.wg.Add(1)
-				b.pending = p
+				// Someone else is running it
+				myBatch.wg.Wait()
+				return myBatch.err
 			}
-			p.values = append(p.values, value)
+
+			// Both full, wait for current to complete then retry
 			c := b.current
 			b.mu.Unlock()
-
-			// Wait for current batch to finish
 			c.wg.Wait()
-
-			// Try to become the runner for the pending batch
+			runtime.Gosched() // Let others wake up too
 			b.mu.Lock()
-			if b.pending == p {
-				b.pending = nil
-				b.current = p
+			continue
+		}
+
+		// No current execution
+		// First check if there's a pending batch to promote
+		if b.pending != nil {
+			c := b.pending
+			// Try to add our value to this batch
+			if b.MaxSize == 0 || len(c.values) < b.MaxSize {
+				c.values = append(c.values, value)
+				b.pending = b.overflow
+				b.overflow = nil
+				b.current = c
 				b.mu.Unlock()
-				b.run(p)
-				return p.err
+				b.run(c)
+				return c.err
 			}
-			b.mu.Unlock()
 
-			// Someone else is running it, wait for completion
-			p.wg.Wait()
-			return p.err
+			// Batch is full, create new pending for our value
+			np := &batchCall[T]{values: b.acquireSlice()}
+			np.values = append(np.values, value)
+			np.wg.Add(1)
+
+			// Promote pending to current
+			b.pending = b.overflow
+			b.overflow = nil
+			b.current = c
+
+			// Place our new batch in the queue
+			if b.pending == nil {
+				b.pending = np
+			} else {
+				b.overflow = np
+			}
+
+			myBatch := np
+			b.mu.Unlock()
+			b.run(c)
+			myBatch.wg.Wait()
+			return myBatch.err
 		}
 
-		// Pending is full, wait for current to finish and retry
-		c := b.current
+		// No pending, start fresh with our value
+		c := &batchCall[T]{values: b.acquireSlice()}
+		c.values = append(c.values, value)
+		c.wg.Add(1)
+		b.current = c
 		b.mu.Unlock()
-		c.wg.Wait()
-		b.mu.Lock()
+		b.run(c)
+		return c.err
 	}
 }
 
-// run executes a batch.
+// run executes a single batch.
 func (b *Batch[T]) run(c *batchCall[T]) {
 	defer func() {
 		if r := recover(); r != nil {
@@ -98,6 +202,7 @@ func (b *Batch[T]) run(c *batchCall[T]) {
 
 		b.mu.Lock()
 		b.current = nil
+		b.releaseSlice(c.values)
 		b.mu.Unlock()
 
 		c.wg.Done()