Skip to content

Commit e6f7782

Browse files
dsymedsyme
authored
Merge pull request #194 from fsprojects/daily-perf-improver/benchmarkdotnet-setup
Daily Perf Improver: Set up BenchmarkDotNet for systematic benchmarking
2 parents 86d503a + 09ba13f commit e6f7782

File tree

4 files changed

+258
-0
lines changed

4 files changed

+258
-0
lines changed

‎tests/FSharp.Control.AsyncSeq.Benchmarks/AsyncSeqBenchmarks.fs‎

Lines changed: 155 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,155 @@
1+
namespace AsyncSeqBenchmarks
2+
3+
open System
4+
open BenchmarkDotNet.Attributes
5+
open BenchmarkDotNet.Configs
6+
open BenchmarkDotNet.Running
7+
open BenchmarkDotNet.Jobs
8+
open BenchmarkDotNet.Engines
9+
open BenchmarkDotNet.Toolchains.InProcess.Emit
10+
open FSharp.Control
11+
12+
/// Core AsyncSeq performance benchmarks focused on foundational operations
13+
[<MemoryDiagnoser>]
14+
[<SimpleJob(RuntimeMoniker.Net80)>]
15+
type AsyncSeqCoreBenchmarks() =
16+
17+
[<Params(1000, 10000)>]
18+
member val ElementCount = 0 with get, set
19+
20+
/// Benchmark unfoldAsync - core sequence generation
21+
[<Benchmark(Baseline = true)>]
22+
member this.UnfoldAsync() =
23+
let generator state = async {
24+
if state < this.ElementCount then
25+
return Some (state, state + 1)
26+
else
27+
return None
28+
}
29+
AsyncSeq.unfoldAsync generator 0
30+
|> AsyncSeq.iterAsync (fun _ -> async.Return())
31+
|> Async.RunSynchronously
32+
33+
/// Benchmark replicate - simple constant generation
34+
[<Benchmark>]
35+
member this.Replicate() =
36+
AsyncSeq.replicate this.ElementCount 42
37+
|> AsyncSeq.iterAsync (fun _ -> async.Return())
38+
|> Async.RunSynchronously
39+
40+
/// Benchmark mapAsync - common transformation
41+
[<Benchmark>]
42+
member this.MapAsync() =
43+
AsyncSeq.replicate this.ElementCount 1
44+
|> AsyncSeq.mapAsync (fun x -> async.Return (x * 2))
45+
|> AsyncSeq.iterAsync (fun _ -> async.Return())
46+
|> Async.RunSynchronously
47+
48+
/// Benchmark chooseAsync with high selectivity
49+
[<Benchmark>]
50+
member this.ChooseAsync() =
51+
AsyncSeq.replicate this.ElementCount 1
52+
|> AsyncSeq.chooseAsync (fun x -> async.Return (Some (x * 2)))
53+
|> AsyncSeq.iterAsync (fun _ -> async.Return())
54+
|> Async.RunSynchronously
55+
56+
/// Benchmarks for append operations (previously had memory leaks)
57+
[<MemoryDiagnoser>]
58+
[<SimpleJob(RuntimeMoniker.Net80)>]
59+
type AsyncSeqAppendBenchmarks() =
60+
61+
[<Params(10, 50, 100)>]
62+
member val ChainCount = 0 with get, set
63+
64+
/// Benchmark chained appends - tests for memory leaks and O(n²) behavior
65+
[<Benchmark>]
66+
member this.ChainedAppends() =
67+
let mutable result = AsyncSeq.singleton 1
68+
for i in 2 .. this.ChainCount do
69+
result <- AsyncSeq.append result (AsyncSeq.singleton i)
70+
result
71+
|> AsyncSeq.iterAsync (fun _ -> async.Return())
72+
|> Async.RunSynchronously
73+
74+
/// Benchmark multiple sequence appends
75+
[<Benchmark>]
76+
member this.MultipleAppends() =
77+
let sequences = [1 .. this.ChainCount] |> List.map (fun i -> AsyncSeq.singleton i)
78+
sequences
79+
|> List.reduce AsyncSeq.append
80+
|> AsyncSeq.iterAsync (fun _ -> async.Return())
81+
|> Async.RunSynchronously
82+
83+
/// Benchmarks for computation builder recursive patterns (previously O(n²))
84+
[<MemoryDiagnoser>]
85+
[<SimpleJob(RuntimeMoniker.Net80)>]
86+
type AsyncSeqBuilderBenchmarks() =
87+
88+
[<Params(50, 100, 200)>]
89+
member val RecursionDepth = 0 with get, set
90+
91+
/// Benchmark recursive asyncSeq computation - tests for O(n²) regression
92+
[<Benchmark>]
93+
member this.RecursiveAsyncSeq() =
94+
let rec generate cnt = asyncSeq {
95+
if cnt = 0 then () else
96+
let! v = async.Return 1
97+
yield v
98+
yield! generate (cnt-1)
99+
}
100+
generate this.RecursionDepth
101+
|> AsyncSeq.iterAsync (fun _ -> async.Return())
102+
|> Async.RunSynchronously
103+
104+
/// Benchmark unfoldAsync equivalent for comparison
105+
[<Benchmark>]
106+
member this.UnfoldAsyncEquivalent() =
107+
AsyncSeq.unfoldAsync (fun cnt -> async {
108+
if cnt = 0 then return None
109+
else
110+
let! v = async.Return 1
111+
return Some (v, cnt - 1)
112+
}) this.RecursionDepth
113+
|> AsyncSeq.iterAsync (fun _ -> async.Return())
114+
|> Async.RunSynchronously
115+
116+
/// Entry point for running benchmarks
117+
module AsyncSeqBenchmarkRunner =
118+
119+
[<EntryPoint>]
120+
let Main args =
121+
printfn "AsyncSeq Performance Benchmarks"
122+
printfn "================================"
123+
printfn "Running comprehensive performance benchmarks to establish baseline metrics"
124+
printfn "and verify fixes for known performance issues (memory leaks, O(n²) patterns)."
125+
printfn ""
126+
127+
let result =
128+
match args |> Array.tryHead with
129+
| Some "core" ->
130+
printfn "Running Core Operations Benchmarks..."
131+
BenchmarkRunner.Run<AsyncSeqCoreBenchmarks>() |> ignore
132+
0
133+
| Some "append" ->
134+
printfn "Running Append Operations Benchmarks..."
135+
BenchmarkRunner.Run<AsyncSeqAppendBenchmarks>() |> ignore
136+
0
137+
| Some "builder" ->
138+
printfn "Running Builder Pattern Benchmarks..."
139+
BenchmarkRunner.Run<AsyncSeqBuilderBenchmarks>() |> ignore
140+
0
141+
| Some "all" | None ->
142+
printfn "Running All Benchmarks..."
143+
BenchmarkRunner.Run<AsyncSeqCoreBenchmarks>() |> ignore
144+
BenchmarkRunner.Run<AsyncSeqAppendBenchmarks>() |> ignore
145+
BenchmarkRunner.Run<AsyncSeqBuilderBenchmarks>() |> ignore
146+
0
147+
| Some suite ->
148+
printfn "Unknown benchmark suite: %s" suite
149+
printfn "Available suites: core, append, builder, all"
150+
1
151+
152+
printfn ""
153+
printfn "Benchmarks completed. Results provide baseline performance metrics"
154+
printfn "for future performance improvements and regression detection."
155+
result

‎tests/FSharp.Control.AsyncSeq.Benchmarks/FSharp.Control.AsyncSeq.Benchmarks.fsproj‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
<?xml version="1.0" encoding="utf-8"?>
2+
<Project Sdk="Microsoft.NET.Sdk">
3+
<PropertyGroup>
4+
<OutputType>Exe</OutputType>
5+
<TargetFramework>net8.0</TargetFramework>
6+
<IsPackable>false</IsPackable>
7+
<ServerGarbageCollection>true</ServerGarbageCollection>
8+
</PropertyGroup>
9+
<ItemGroup>
10+
<Compile Include="AsyncSeqBenchmarks.fs" />
11+
</ItemGroup>
12+
<ItemGroup>
13+
<PackageReference Include="BenchmarkDotNet" Version="0.14.0" />
14+
<ProjectReference Include="..\..\src\FSharp.Control.AsyncSeq\FSharp.Control.AsyncSeq.fsproj" />
15+
</ItemGroup>
16+
</Project>

‎tests/FSharp.Control.AsyncSeq.Benchmarks/README.md‎

Lines changed: 86 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,86 @@
1+
# AsyncSeq Performance Benchmarks
2+
3+
This project contains systematic performance benchmarks for FSharp.Control.AsyncSeq using BenchmarkDotNet.
4+
5+
## Purpose
6+
7+
These benchmarks provide:
8+
- **Baseline Performance Metrics**: Establish current performance characteristics
9+
- **Regression Detection**: Detect performance regressions in future changes
10+
- **Optimization Validation**: Measure impact of performance improvements
11+
- **Issue Verification**: Verify fixes for known performance issues (#35, #57, etc.)
12+
13+
## Benchmark Suites
14+
15+
### Core Operations (`core`)
16+
Tests fundamental AsyncSeq operations:
17+
- `unfoldAsync` - Core sequence generation
18+
- `replicate` - Simple constant generation
19+
- `mapAsync` - Common transformation operation
20+
- `chooseAsync` - Filtering with async projection
21+
22+
### Append Operations (`append`)
23+
Tests append functionality (previously had memory leaks):
24+
- `ChainedAppends` - Sequential append operations
25+
- `MultipleAppends` - Batch append operations
26+
27+
### Builder Patterns (`builder`)
28+
Tests computation expression performance (previously O(n²)):
29+
- `RecursiveAsyncSeq` - Recursive `yield!` patterns
30+
- `UnfoldAsyncEquivalent` - Optimized equivalent using `unfoldAsync`
31+
32+
## Usage
33+
34+
### Build and Run
35+
```bash
36+
# Build benchmarks
37+
dotnet build tests/FSharp.Control.AsyncSeq.Benchmarks -c Release
38+
39+
# Run all benchmark suites
40+
dotnet run --project tests/FSharp.Control.AsyncSeq.Benchmarks -c Release
41+
42+
# Run specific suite
43+
dotnet run --project tests/FSharp.Control.AsyncSeq.Benchmarks -c Release -- core
44+
dotnet run --project tests/FSharp.Control.AsyncSeq.Benchmarks -c Release -- append
45+
dotnet run --project tests/FSharp.Control.AsyncSeq.Benchmarks -c Release -- builder
46+
```
47+
48+
### Interpreting Results
49+
50+
BenchmarkDotNet provides detailed metrics including:
51+
- **Mean**: Average execution time
52+
- **Error**: Standard error of measurements
53+
- **StdDev**: Standard deviation
54+
- **Gen0/Gen1/Gen2**: Garbage collection counts
55+
- **Allocated**: Memory allocations per operation
56+
57+
### Key Performance Indicators
58+
59+
Watch for:
60+
- **Linear scaling**: Execution time should scale linearly with element count
61+
- **Low GC pressure**: Minimal Gen0/Gen1 collections for streaming operations
62+
- **Constant memory**: No memory leaks in long-running operations
63+
- **No O(n²) patterns**: Performance should not degrade quadratically
64+
65+
## Integration with Performance Plan
66+
67+
These benchmarks support the performance improvement plan phases:
68+
69+
**Round 1 (Foundation)**:
70+
- ✅ Systematic benchmarking infrastructure (this project)
71+
- ✅ Baseline performance documentation
72+
- 🔄 Performance regression detection
73+
74+
**Round 2-4**:
75+
- Use these benchmarks to measure optimization impact
76+
- Add new benchmarks for additional performance improvements
77+
- Validate performance targets and success metrics
78+
79+
## Known Issues Being Monitored
80+
81+
- **Issue #35**: Memory leaks in append operations (fixed in PR #193)
82+
- **Issue #57**: O(n²) performance in recursive patterns (fixed in 2016)
83+
- **Issue #50**: Excessive append function calls
84+
- **Issues #74, #95**: Parallelism inefficiencies
85+
86+
Results from these benchmarks help verify these issues remain resolved and detect any regressions.

‎tests/FSharp.Control.AsyncSeq.Tests/FSharp.Control.AsyncSeq.Tests.fsproj‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@
99
<None Include="AsyncSeqPerf.fsx" />
1010
</ItemGroup>
1111
<ItemGroup>
12+
<PackageReference Include="BenchmarkDotNet" Version="0.14.0" />
1213
<PackageReference Include="coverlet.collector" Version="6.0.0" />
1314
<ProjectReference Include="..\..\src\FSharp.Control.AsyncSeq\FSharp.Control.AsyncSeq.fsproj" />
1415
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />

0 commit comments

Comments
 (0)