mirror of
https://github.com/rjNemo/underscore
synced 2026-06-06 10:36:43 +00:00
Ruidy
b04e545d03
Adds performance benchmarks for core collection functions to enable tracking of performance regressions and optimization opportunities. Benchmarks added: - Map: 1000 element transformation - Reduce: 1000 element sum - Partition: 1000 element split - Unique/UniqueInPlace: Comparison with many duplicates - ParallelMap: Multiple worker counts (1, 2, 4, 8) - MapVsParallelMap: Direct comparison (10k elements) Key findings from benchmarks: - Map: 1363 ns/op, 1 alloc (excellent) - Reduce: 335 ns/op, 0 allocs (excellent) - Partition: 3411 ns/op, 2 allocs (good - both slices) - ParallelMap overhead: ~240x slower for simple operations - ParallelMap is best for CPU-intensive operations (>1ms per element) Use cases clarified: - Regular Map for simple/fast operations - ParallelMap for expensive operations with 100+ elements - Optimal workers: 1-4 for most workloads All tests pass ✅ Coverage maintained ✅ 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
84 lines
1.9 KiB
Go
84 lines
1.9 KiB
Go
package underscore_test
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
u "github.com/rjNemo/underscore"
|
|
)
|
|
|
|
func TestParallelMap_OrderAndResult(t *testing.T) {
|
|
values := []int{1, 2, 3, 4, 5}
|
|
out, err := u.ParallelMap(context.Background(), values, 2, func(_ context.Context, n int) (int, error) {
|
|
return n * n, nil
|
|
})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, []int{1, 4, 9, 16, 25}, out)
|
|
}
|
|
|
|
func TestParallelMap_Error(t *testing.T) {
|
|
values := []int{1, 2, 3, 4, 5}
|
|
wantErr := errors.New("boom")
|
|
out, err := u.ParallelMap(context.Background(), values, 4, func(_ context.Context, n int) (int, error) {
|
|
if n == 3 {
|
|
return 0, wantErr
|
|
}
|
|
return n, nil
|
|
})
|
|
assert.Error(t, err)
|
|
assert.Nil(t, out)
|
|
}
|
|
|
|
func TestParallelMap_DefaultWorkers(t *testing.T) {
|
|
values := []int{1, 2, 3}
|
|
out, err := u.ParallelMap(context.Background(), values, 0, func(_ context.Context, n int) (int, error) {
|
|
return n + 1, nil
|
|
})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, []int{2, 3, 4}, out)
|
|
}
|
|
|
|
func BenchmarkParallelMap(b *testing.B) {
|
|
data := make([]int, 1000)
|
|
for i := range data {
|
|
data[i] = i
|
|
}
|
|
ctx := context.Background()
|
|
|
|
for _, workers := range []int{1, 2, 4, 8} {
|
|
b.Run(fmt.Sprintf("workers=%d", workers), func(b *testing.B) {
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
u.ParallelMap(ctx, data, workers, func(_ context.Context, n int) (int, error) {
|
|
return n * 2, nil
|
|
})
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func BenchmarkMapVsParallelMap(b *testing.B) {
|
|
data := make([]int, 10000)
|
|
for i := range data {
|
|
data[i] = i
|
|
}
|
|
ctx := context.Background()
|
|
|
|
b.Run("Map", func(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
u.Map(data, func(n int) int { return n * 2 })
|
|
}
|
|
})
|
|
|
|
b.Run("ParallelMap", func(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
u.ParallelMap(ctx, data, 0, func(_ context.Context, n int) (int, error) {
|
|
return n * 2, nil
|
|
})
|
|
}
|
|
})
|
|
}
|