Benchmarking¶

Blink includes benchmarks to measure the performance of critical functions. This page describes how to run the benchmarks and how to interpret the results.

Running Benchmarks¶

You can run the benchmarks using the Makefile:

# Run benchmarks
make benchmark

Or you can use the Go test command directly:

# Run benchmarks
go test -v -bench=. -benchmem ./...

# Run benchmarks for a specific package
go test -v -bench=. -benchmem ./pkg/blink

# Run a specific benchmark
go test -v -bench=BenchmarkShouldIgnoreFile -benchmem ./pkg/blink

Benchmark Results¶

The benchmark results include:

• Operations per Second: How many operations the function can perform per second
• Time per Operation: How long each operation takes
• Memory Allocation: How much memory is allocated per operation
• Allocations per Operation: How many memory allocations are made per operation

Example benchmark results:

BenchmarkShouldIgnoreFile-10            39295886                30.57 ns/op            0 B/op          0 allocs/op
BenchmarkSubfolders-10                       144           7940372 ns/op          708393 B/op       4614 allocs/op
BenchmarkRemoveOldEvents-10                10000            121779 ns/op          298686 B/op         20 allocs/op

In this example:

• BenchmarkShouldIgnoreFile-10: The benchmark for the ShouldIgnoreFile function, running on 10 CPUs
• 39295886: The number of iterations the benchmark ran
• 30.57 ns/op: Each operation took 30.57 nanoseconds
• 0 B/op: No memory was allocated per operation
• 0 allocs/op: No memory allocations were made per operation

Benchmark Functions¶

Blink includes the following benchmark functions:

BenchmarkShouldIgnoreFile¶

Benchmarks the ShouldIgnoreFile function, which determines if a file should be ignored based on its name.

func BenchmarkShouldIgnoreFile(b *testing.B) {
 filenames := []string{
  "file.txt",
  ".hidden",
  "_temp",
  "dir",
  ".git",
  "_build",
 }

 b.ResetTimer()
 for i := 0; i < b.N; i++ {
  for _, filename := range filenames {
   ShouldIgnoreFile(filename)
  }
 }
}

BenchmarkSubfolders¶

Benchmarks the Subfolders function, which returns a list of all subdirectories in a given path.

func BenchmarkSubfolders(b *testing.B) {
 // Create a temporary directory structure for benchmarking
 tempDir, err := ioutil.TempDir("", "blink-bench-")
 if err != nil {
  b.Fatalf("Failed to create temp dir: %v", err)
 }
 defer os.RemoveAll(tempDir)

 // Create a directory structure with 5 levels and 3 directories per level
 createDirTree(b, tempDir, 5, 3)

 b.ResetTimer()
 for i := 0; i < b.N; i++ {
  Subfolders(tempDir)
 }
}

BenchmarkRemoveOldEvents¶

Benchmarks the RemoveOldEvents function, which removes old events from a TimeEventMap.

func BenchmarkRemoveOldEvents(b *testing.B) {
 // Create a TimeEventMap with a large number of events
 events := make(TimeEventMap)
 now := time.Now()

 // Add 1000 events at different times
 for i := 0; i < 1000; i++ {
  events[now.Add(-time.Duration(i)*time.Minute)] = Event{}
 }

 // Benchmark removing events older than 500 minutes
 maxAge := 500 * time.Minute
 b.ResetTimer()
 for i := 0; i < b.N; i++ {
  // Create a copy of the events map for each iteration
  eventsCopy := make(TimeEventMap)
  for k, v := range events {
   eventsCopy[k] = v
  }
  RemoveOldEvents(&eventsCopy, maxAge)
 }
}

Writing Benchmarks¶

When writing benchmarks for Blink, follow these guidelines:

1. Reset Timer: Use b.ResetTimer() before the benchmark loop to exclude setup time
2. Benchmark Memory: Use the -benchmem flag to measure memory usage
3. Benchmark Realistic Scenarios: Benchmark realistic scenarios with realistic data
4. Benchmark Critical Functions: Focus on performance-critical functions
5. Benchmark Edge Cases: Benchmark edge cases and worst-case scenarios

Example Benchmark¶

Here's an example of a good benchmark:

func BenchmarkEventFilter(b *testing.B) {
 // Create a filter
 filter := NewEventFilter()
 filter.SetIncludePatterns("*.js,*.css,*.html")
 filter.SetExcludePatterns("node_modules,*.tmp")
 filter.SetIncludeEvents("write,create")
 filter.SetIgnoreEvents("chmod")

 // Create events
 events := []fsnotify.Event{
  {Name: "file.js", Op: fsnotify.Write},
  {Name: "file.css", Op: fsnotify.Create},
  {Name: "file.html", Op: fsnotify.Chmod},
  {Name: "file.tmp", Op: fsnotify.Write},
  {Name: "node_modules/file.js", Op: fsnotify.Write},
 }

 b.ResetTimer()
 for i := 0; i < b.N; i++ {
  for _, event := range events {
   filter.ShouldInclude(event)
  }
 }
}

Performance Profiling¶

In addition to benchmarks, you can use Go's profiling tools to analyze performance:

# CPU profiling
go test -cpuprofile=cpu.prof -bench=. ./pkg/blink

# Memory profiling
go test -memprofile=mem.prof -bench=. ./pkg/blink

# Block profiling
go test -blockprofile=block.prof -bench=. ./pkg/blink

You can then analyze the profiles with:

go tool pprof cpu.prof
go tool pprof mem.prof
go tool pprof block.prof

Performance Goals¶

Blink aims to be high-performance, with the following goals:

• Low Latency: Events should be delivered with low latency
• High Throughput: Blink should handle a high rate of events
• Low Memory Usage: Blink should use memory efficiently
• Low CPU Usage: Blink should use CPU efficiently

The benchmarks help ensure that these goals are met and that performance regressions are caught early.