Now that we have both of our GetCounts algorithms implemented—one using the io.Pipe approach and another performing a single-pass over the data—let’s talk about how we can determine which one is faster in terms of performance.

---

Benchmark Testing in Go

When it comes to measuring performance in Go, one great approach is benchmark testing, which is part of the testing package. Benchmark testing is used to measure how long a function or block of code takes to execute, which is especially useful for:

• Performance optimization
• Comparing different implementations

In Go, benchmark tests are written by creating functions that start with Benchmark instead of Test, and accept a *testing.B parameter.

---

Writing a Benchmark for GetCounts

To get started, go to count_test.go and add the following:

var benchData = []string{
    "this is a test data string that runs across multiple lines.",
    "one two three four five six seven eight",
    "this is a weird string.",
}

Next, write the benchmark function:

func BenchmarkGetCounts(b *testing.B) {
    for i := 0; i < b.N; i++ {
        data := benchData[i % len(benchData)]
        r := strings.NewReader(data)
        counter.GetCounts(r)
    }
}

• b.N is the number of times the function will run to get an average runtime.
• We cycle through the benchData using modulus to avoid indexing errors.

---

Running the Benchmark

Use this command to run the benchmark:

go test -bench=.

This outputs:

• Which CPU and OS is used
• Number of iterations
• Average time per operation

Example output:

BenchmarkGetCounts-8    51706    26549 ns/op

This means:

• The test ran 51,706 times
• Each run took 26,549 nanoseconds on average (~26µs)

---

Adding a Benchmark for GetCountsSinglePass

Now let’s compare this with our single-pass implementation:

func BenchmarkGetCountsSinglePass(b *testing.B) {
    for i := 0; i < b.N; i++ {
        data := benchData[i % len(benchData)]
        r := strings.NewReader(data)
        counter.GetCountsSinglePass(r)
    }
}

Now re-run the benchmarks:

go test -bench=.

Example output:

BenchmarkGetCounts-8             51706     26549 ns/op
BenchmarkGetCountsSinglePass-8  524000      2446 ns/op

The single-pass implementation:

• Ran 10x more iterations
• Is about 10x faster
• Clearly the better performing algorithm

---

Benchmarking Memory Usage

To compare memory efficiency, use the -benchmem flag:

go test -bench=. -benchmem

Example output:

BenchmarkGetCounts-8            51706     26549 ns/op    10000 B/op    24 allocs/op
BenchmarkGetCountsSinglePass-8 524000     2446 ns/op     4000 B/op     2 allocs/op

Takeaways:

• GetCounts allocates 10KB and 24 allocations per op
• GetCountsSinglePass allocates only 4KB and 2 allocations per op

---

Testing the TeeReader Version

We can now test the older TeeReader implementation by reverting to that code and running:

go test -bench=BenchmarkGetCounts -benchmem

This version turns out to be:

• Faster than io.Pipe
• Has fewer allocations

This confirms that allocations are the main bottleneck in the slower implementation.

---

Tips for Benchmarking Implementations

The only downside is comparing against older code can be difficult. You either:

• Keep legacy versions around in separate functions (as we did), or
• Use Git to temporarily roll back and test them

Tip: Commit frequently and in small chunks to make this easier!

---

Final Thoughts

Now that we’ve benchmarked both versions, we have real data to confirm:

• GetCountsSinglePass is the best performing algorithm
• It’s faster and uses less memory

In the next lesson, we’ll go back to using GetCountsSinglePass, but we’ll also keep the old one in the codebase—and we’ll look at an interesting way to organize that.

For now, let’s commit our changes:

git add .
git commit -m "added in a benchmark test for both the count and counts method"

And with that, I’ll see you in the next lesson.