Merge pull request #10 from s0ders/main

astavonin · web-flow · commit edd60ad85bf9 · 2025-04-07T14:05:07.000+06:00
feat: now using the preferred testing.b.Loop instead of testing.b.N for benchmarks.
diff --git a/docs/01-common-patterns/src/batching-ops_test.go b/docs/01-common-patterns/src/batching-ops_test.go
@@ -10,7 +10,6 @@ import (
     "testing"
 )
 
-var sink string
 var lines = make([]string, 10000)
 
 func init() {
@@ -22,31 +21,31 @@ func init() {
 // --- 1. No I/O ---
 
 func BenchmarkUnbatchedProcessing(b *testing.B) {
-    for n := 0; n < b.N; n++ {
+    for b.Loop() {
         for _, line := range lines {
-            sink = strings.ToUpper(line)
+            strings.ToUpper(line)
         }
     }
 }
 
 func BenchmarkBatchedProcessing(b *testing.B) {
     batchSize := 100
-    for n := 0; n < b.N; n++ {
+    for b.Loop() {
         for i := 0; i < len(lines); i += batchSize {
             end := i + batchSize
             if end > len(lines) {
                 end = len(lines)
             }
             batch := strings.Join(lines[i:end], "|")
-            sink = strings.ToUpper(batch)
+            strings.ToUpper(batch)
         }
     }
 }
 
 // --- 2. With I/O ---
 
 func BenchmarkUnbatchedIO(b *testing.B) {
-    for n := 0; n < b.N; n++ {
+    for b.Loop() {
         f, err := os.CreateTemp("", "unbatched")
         if err != nil {
             b.Fatal(err)
@@ -61,7 +60,7 @@ func BenchmarkUnbatchedIO(b *testing.B) {
 
 func BenchmarkBatchedIO(b *testing.B) {
     batchSize := 100
-    for n := 0; n < b.N; n++ {
+    for b.Loop() {
         f, err := os.CreateTemp("", "batched")
         if err != nil {
             b.Fatal(err)
@@ -87,23 +86,23 @@ func hash(s string) string {
 }
 
 func BenchmarkUnbatchedCrypto(b *testing.B) {
-    for n := 0; n < b.N; n++ {
+    for b.Loop() {
         for _, line := range lines {
-            sink = hash(line)
+            hash(line)
         }
     }
 }
 
 func BenchmarkBatchedCrypto(b *testing.B) {
     batchSize := 100
-    for n := 0; n < b.N; n++ {
+    for b.Loop() {
         for i := 0; i < len(lines); i += batchSize {
             end := i + batchSize
             if end > len(lines) {
                 end = len(lines)
             }
             joined := strings.Join(lines[i:end], "")
-            sink = hash(joined)
+            hash(joined)
         }
     }
 }
diff --git a/docs/01-common-patterns/src/buffered-io_test.go b/docs/01-common-patterns/src/buffered-io_test.go
@@ -44,7 +44,7 @@ func writeBuffered(w io.Writer, count int) {
 }
 
 func BenchmarkWriteNotBuffered(b *testing.B) {
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		f, _ := os.CreateTemp("", "nobuf")
 		writeNotBuffered(f, N)
 		f.Close()
@@ -53,7 +53,7 @@ func BenchmarkWriteNotBuffered(b *testing.B) {
 }
 
 func BenchmarkWriteBuffered(b *testing.B) {
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		f, _ := os.CreateTemp("", "buf")
 		writeBuffered(f, N)
 		f.Close()
diff --git a/docs/01-common-patterns/src/fields-alignment_test.go b/docs/01-common-patterns/src/fields-alignment_test.go
@@ -19,25 +19,21 @@ type WellAligned struct {
 }
 // types-simple-end
 
-var result int64
-
 // simple-start
 func BenchmarkPoorlyAligned(b *testing.B) {
-    for i := 0; i < b.N; i++ {
+    for b.Loop() {
         var items = make([]PoorlyAligned, 10_000_000)
         for j := range items {
             items[j].count = int64(j)
-            result += items[j].count
         }
     }
 }
 
 func BenchmarkWellAligned(b *testing.B) {
-    for i := 0; i < b.N; i++ {
+    for b.Loop() {
         var items = make([]WellAligned, 10_000_000)
         for j := range items {
             items[j].count = int64(j)
-            result += items[j].count
         }
     }
 }
@@ -63,8 +59,7 @@ func BenchmarkFalseSharing(b *testing.B) {
     var c SharedCounterBad  // (1)
     var wg sync.WaitGroup
 
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
+    for b.Loop() {
         wg.Add(2)
         go func() {
             for i := 0; i < 1_000_000; i++ {
@@ -87,8 +82,7 @@ func BenchmarkNoFalseSharing(b *testing.B) {
     var c SharedCounterGood
     var wg sync.WaitGroup
 
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
+    for b.Loop() {
         wg.Add(2)
         go func() {
             for i := 0; i < 1_000_000; i++ {
diff --git a/docs/01-common-patterns/src/interface-boxing_test.go b/docs/01-common-patterns/src/interface-boxing_test.go
@@ -18,49 +18,45 @@ func (LargeJob) Work() {}
 // interface-end
 
 // bench-slice-start
-var sink []Worker
-
 func BenchmarkBoxedLargeSlice(b *testing.B) {
     jobs := make([]Worker, 0, 1000)
-    for i := 0; i < b.N; i++ {
+    for b.Loop() {
         jobs = jobs[:0]
         for j := 0; j < 1000; j++ {
             var job LargeJob
             jobs = append(jobs, job)
         }
-        sink = jobs
     }
 }
 
 func BenchmarkPointerLargeSlice(b *testing.B) {
     jobs := make([]Worker, 0, 1000)
-    for i := 0; i < b.N; i++ {
+    for b.Loop() {
         jobs := jobs[:0]
         for j := 0; j < 1000; j++ {
             job := &LargeJob{}
             jobs = append(jobs, job)
         }
-        sink = jobs
     }
 }
 // bench-slice-end
 
 // bench-call-start
-var sinkOne Worker
+var sink Worker
 
 func call(w Worker) {
-    sinkOne = w
+    sink = w
 }
 
 func BenchmarkCallWithValue(b *testing.B) {
-    for i := 0; i < b.N; i++ {
+    for b.Loop() {
         var j LargeJob
         call(j)
     }
 }
 
 func BenchmarkCallWithPointer(b *testing.B) {
-    for i := 0; i < b.N; i++ {
+    for b.Loop() {
         j := &LargeJob{}
         call(j)
     }
diff --git a/docs/01-common-patterns/src/mem-prealloc_test.go b/docs/01-common-patterns/src/mem-prealloc_test.go
@@ -5,7 +5,7 @@ import (
 )
 
 func BenchmarkAppendNoPrealloc(b *testing.B) {
-    for i := 0; i < b.N; i++ {
+    for b.Loop() {
         var s []int
         for j := 0; j < 10000; j++ {
             s = append(s, j)
@@ -14,10 +14,10 @@ func BenchmarkAppendNoPrealloc(b *testing.B) {
 }
 
 func BenchmarkAppendWithPrealloc(b *testing.B) {
-    for i := 0; i < b.N; i++ {
+    for b.Loop() {
         s := make([]int, 0, 10000)
         for j := 0; j < 10000; j++ {
             s = append(s, j)
         }
     }
-}
+}
diff --git a/docs/01-common-patterns/src/object-pooling_test.go b/docs/01-common-patterns/src/object-pooling_test.go
@@ -10,14 +10,11 @@ type Data struct {
 	Values [1024]int
 }
 
-// globalSink prevents compiler optimizations that could remove memory allocations.
-var globalSink *Data
-
 // BenchmarkWithoutPooling measures the performance of direct heap allocations.
 func BenchmarkWithoutPooling(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		globalSink = &Data{}      // Allocating a new object each time
-		globalSink.Values[0] = 42 // Simulating some memory activity
+	for b.Loop() {
+    data := &Data{}      // Allocating a new object each time
+		data.Values[0] = 42 // Simulating some memory activity
 	}
 }
 
@@ -30,10 +27,9 @@ var dataPool = sync.Pool{
 
 // BenchmarkWithPooling measures the performance of using sync.Pool to reuse objects.
 func BenchmarkWithPooling(b *testing.B) {
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		obj := dataPool.Get().(*Data) // Retrieve from pool
 		obj.Values[0] = 42            // Simulate memory usage
 		dataPool.Put(obj)             // Return object to pool for reuse
-		globalSink = obj              // Prevents compiler optimizations from removing pooling logic
 	}
 }
diff --git a/docs/01-common-patterns/src/stack-alloc_test.go b/docs/01-common-patterns/src/stack-alloc_test.go
@@ -16,13 +16,13 @@ func HeapAlloc() *Data {
 }
 
 func BenchmarkStackAlloc(b *testing.B) {
-    for i := 0; i < b.N; i++ {
+    for b.Loop() {
         _ = StackAlloc()
     }
 }
 
 func BenchmarkHeapAlloc(b *testing.B) {
-    for i := 0; i < b.N; i++ {
+    for b.Loop() {
         _ = HeapAlloc()
     }
 }
@@ -37,7 +37,7 @@ func HeapAllocEscape() {
 }
 
 func BenchmarkHeapAllocEscape(b *testing.B) {
-    for i := 0; i < b.N; i++ {
+    for b.Loop() {
         HeapAllocEscape()
     }
 }
diff --git a/docs/01-common-patterns/src/worker-pool_test.go b/docs/01-common-patterns/src/worker-pool_test.go
@@ -21,7 +21,7 @@ func doWork(n int) [32]byte {
 }
 
 func BenchmarkUnboundedGoroutines(b *testing.B) {
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		var wg sync.WaitGroup
 		wg.Add(numJobs)
 
@@ -43,7 +43,7 @@ func worker(jobs <-chan int, wg *sync.WaitGroup) {
 }
 
 func BenchmarkWorkerPool(b *testing.B) {
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		var wg sync.WaitGroup
 		wg.Add(numJobs)
 
diff --git a/docs/01-common-patterns/src/zero-copy_test.go b/docs/01-common-patterns/src/zero-copy_test.go
@@ -10,22 +10,18 @@ import (
 )
 
 // bench-start
-var sink []byte
-
 func BenchmarkCopy(b *testing.B) {
     data := make([]byte, 64*1024)
-    for i := 0; i < b.N; i++ {
+    for b.Loop() {
         buf := make([]byte, len(data))
         copy(buf, data)
-        sink = buf
     }
 }
 
 func BenchmarkSlice(b *testing.B) {
     data := make([]byte, 64*1024)
-    for i := 0; i < b.N; i++ {
-        s := data[:]
-        sink = s
+    for b.Loop() {
+        _ = data[:]
     }
 }
 // bench-end
@@ -39,13 +35,11 @@ func BenchmarkReadWithCopy(b *testing.B) {
     defer f.Close()
 
     buf := make([]byte, 4*1024*1024) // 4MB buffer
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
+    for b.Loop() {
         _, err := f.ReadAt(buf, 0)
         if err != nil && err != io.EOF {
             b.Fatal(err)
         }
-        sink = buf
     }
 }
 
@@ -57,13 +51,11 @@ func BenchmarkReadWithMmap(b *testing.B) {
     defer r.Close()
 
     buf := make([]byte, r.Len())
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
+    for b.Loop() {
         _, err := r.ReadAt(buf, 0)
         if err != nil && err != io.EOF {
             b.Fatal(err)
         }
-        sink = buf
     }
 }
-// bench-io-end
+// bench-io-end

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,6 @@ import (`
`10`	`10`	`"testing"`
`11`	`11`	`)`
`12`	`12`
`13`		`-var sink string`
`14`	`13`	`var lines = make([]string, 10000)`
`15`	`14`
`16`	`15`	`func init() {`
`@@ -22,31 +21,31 @@ func init() {`
`22`	`21`	`// --- 1. No I/O ---`
`23`	`22`
`24`	`23`	`func BenchmarkUnbatchedProcessing(b *testing.B) {`
`25`		`- for n := 0; n < b.N; n++ {`
	`24`	`+ for b.Loop() {`
`26`	`25`	`for _, line := range lines {`
`27`		`- sink = strings.ToUpper(line)`
	`26`	`+ strings.ToUpper(line)`
`28`	`27`	`}`
`29`	`28`	`}`
`30`	`29`	`}`
`31`	`30`
`32`	`31`	`func BenchmarkBatchedProcessing(b *testing.B) {`
`33`	`32`	`batchSize := 100`
`34`		`- for n := 0; n < b.N; n++ {`
	`33`	`+ for b.Loop() {`
`35`	`34`	`for i := 0; i < len(lines); i += batchSize {`
`36`	`35`	`end := i + batchSize`
`37`	`36`	`if end > len(lines) {`
`38`	`37`	`end = len(lines)`
`39`	`38`	`}`
`40`	`39`	`batch := strings.Join(lines[i:end], "\|")`
`41`		`- sink = strings.ToUpper(batch)`
	`40`	`+ strings.ToUpper(batch)`
`42`	`41`	`}`
`43`	`42`	`}`
`44`	`43`	`}`
`45`	`44`
`46`	`45`	`// --- 2. With I/O ---`
`47`	`46`
`48`	`47`	`func BenchmarkUnbatchedIO(b *testing.B) {`
`49`		`- for n := 0; n < b.N; n++ {`
	`48`	`+ for b.Loop() {`
`50`	`49`	`f, err := os.CreateTemp("", "unbatched")`
`51`	`50`	`if err != nil {`
`52`	`51`	`b.Fatal(err)`
`@@ -61,7 +60,7 @@ func BenchmarkUnbatchedIO(b *testing.B) {`
`61`	`60`
`62`	`61`	`func BenchmarkBatchedIO(b *testing.B) {`
`63`	`62`	`batchSize := 100`
`64`		`- for n := 0; n < b.N; n++ {`
	`63`	`+ for b.Loop() {`
`65`	`64`	`f, err := os.CreateTemp("", "batched")`
`66`	`65`	`if err != nil {`
`67`	`66`	`b.Fatal(err)`
`@@ -87,23 +86,23 @@ func hash(s string) string {`
`87`	`86`	`}`
`88`	`87`
`89`	`88`	`func BenchmarkUnbatchedCrypto(b *testing.B) {`
`90`		`- for n := 0; n < b.N; n++ {`
	`89`	`+ for b.Loop() {`
`91`	`90`	`for _, line := range lines {`
`92`		`- sink = hash(line)`
	`91`	`+ hash(line)`
`93`	`92`	`}`
`94`	`93`	`}`
`95`	`94`	`}`
`96`	`95`
`97`	`96`	`func BenchmarkBatchedCrypto(b *testing.B) {`
`98`	`97`	`batchSize := 100`
`99`		`- for n := 0; n < b.N; n++ {`
	`98`	`+ for b.Loop() {`
`100`	`99`	`for i := 0; i < len(lines); i += batchSize {`
`101`	`100`	`end := i + batchSize`
`102`	`101`	`if end > len(lines) {`
`103`	`102`	`end = len(lines)`
`104`	`103`	`}`
`105`	`104`	`joined := strings.Join(lines[i:end], "")`
`106`		`- sink = hash(joined)`
	`105`	`+ hash(joined)`
`107`	`106`	`}`
`108`	`107`	`}`
`109`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,49 +18,45 @@ func (LargeJob) Work() {}`
`18`	`18`	`// interface-end`
`19`	`19`
`20`	`20`	`// bench-slice-start`
`21`		`-var sink []Worker`
`22`		`-`
`23`	`21`	`func BenchmarkBoxedLargeSlice(b *testing.B) {`
`24`	`22`	`jobs := make([]Worker, 0, 1000)`
`25`		`- for i := 0; i < b.N; i++ {`
	`23`	`+ for b.Loop() {`
`26`	`24`	`jobs = jobs[:0]`
`27`	`25`	`for j := 0; j < 1000; j++ {`
`28`	`26`	`var job LargeJob`
`29`	`27`	`jobs = append(jobs, job)`
`30`	`28`	`}`
`31`		`- sink = jobs`
`32`	`29`	`}`
`33`	`30`	`}`
`34`	`31`
`35`	`32`	`func BenchmarkPointerLargeSlice(b *testing.B) {`
`36`	`33`	`jobs := make([]Worker, 0, 1000)`
`37`		`- for i := 0; i < b.N; i++ {`
	`34`	`+ for b.Loop() {`
`38`	`35`	`jobs := jobs[:0]`
`39`	`36`	`for j := 0; j < 1000; j++ {`
`40`	`37`	`job := &LargeJob{}`
`41`	`38`	`jobs = append(jobs, job)`
`42`	`39`	`}`
`43`		`- sink = jobs`
`44`	`40`	`}`
`45`	`41`	`}`
`46`	`42`	`// bench-slice-end`
`47`	`43`
`48`	`44`	`// bench-call-start`
`49`		`-var sinkOne Worker`
	`45`	`+var sink Worker`
`50`	`46`
`51`	`47`	`func call(w Worker) {`
`52`		`- sinkOne = w`
	`48`	`+ sink = w`
`53`	`49`	`}`
`54`	`50`
`55`	`51`	`func BenchmarkCallWithValue(b *testing.B) {`
`56`		`- for i := 0; i < b.N; i++ {`
	`52`	`+ for b.Loop() {`
`57`	`53`	`var j LargeJob`
`58`	`54`	`call(j)`
`59`	`55`	`}`
`60`	`56`	`}`
`61`	`57`
`62`	`58`	`func BenchmarkCallWithPointer(b *testing.B) {`
`63`		`- for i := 0; i < b.N; i++ {`
	`59`	`+ for b.Loop() {`
`64`	`60`	`j := &LargeJob{}`
`65`	`61`	`call(j)`
`66`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ import (`
`5`	`5`	`)`
`6`	`6`
`7`	`7`	`func BenchmarkAppendNoPrealloc(b *testing.B) {`
`8`		`- for i := 0; i < b.N; i++ {`
	`8`	`+ for b.Loop() {`
`9`	`9`	`var s []int`
`10`	`10`	`for j := 0; j < 10000; j++ {`
`11`	`11`	`s = append(s, j)`
`@@ -14,10 +14,10 @@ func BenchmarkAppendNoPrealloc(b *testing.B) {`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`func BenchmarkAppendWithPrealloc(b *testing.B) {`
`17`		`- for i := 0; i < b.N; i++ {`
	`17`	`+ for b.Loop() {`
`18`	`18`	`s := make([]int, 0, 10000)`
`19`	`19`	`for j := 0; j < 10000; j++ {`
`20`	`20`	`s = append(s, j)`
`21`	`21`	`}`
`22`	`22`	`}`
`23`		`-}`
	`23`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -10,14 +10,11 @@ type Data struct {`
`10`	`10`	`Values [1024]int`
`11`	`11`	`}`
`12`	`12`
`13`		`-// globalSink prevents compiler optimizations that could remove memory allocations.`
`14`		`-var globalSink *Data`
`15`		`-`
`16`	`13`	`// BenchmarkWithoutPooling measures the performance of direct heap allocations.`
`17`	`14`	`func BenchmarkWithoutPooling(b *testing.B) {`
`18`		`- for i := 0; i < b.N; i++ {`
`19`		`- globalSink = &Data{} // Allocating a new object each time`
`20`		`- globalSink.Values[0] = 42 // Simulating some memory activity`
	`15`	`+ for b.Loop() {`
	`16`	`+ data := &Data{} // Allocating a new object each time`
	`17`	`+ data.Values[0] = 42 // Simulating some memory activity`
`21`	`18`	`}`
`22`	`19`	`}`
`23`	`20`
`@@ -30,10 +27,9 @@ var dataPool = sync.Pool{`
`30`	`27`
`31`	`28`	`// BenchmarkWithPooling measures the performance of using sync.Pool to reuse objects.`
`32`	`29`	`func BenchmarkWithPooling(b *testing.B) {`
`33`		`- for i := 0; i < b.N; i++ {`
	`30`	`+ for b.Loop() {`
`34`	`31`	`obj := dataPool.Get().(*Data) // Retrieve from pool`
`35`	`32`	`obj.Values[0] = 42 // Simulate memory usage`
`36`	`33`	`dataPool.Put(obj) // Return object to pool for reuse`
`37`		`- globalSink = obj // Prevents compiler optimizations from removing pooling logic`
`38`	`34`	`}`
`39`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,13 +16,13 @@ func HeapAlloc() *Data {`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`func BenchmarkStackAlloc(b *testing.B) {`
`19`		`- for i := 0; i < b.N; i++ {`
	`19`	`+ for b.Loop() {`
`20`	`20`	`_ = StackAlloc()`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`func BenchmarkHeapAlloc(b *testing.B) {`
`25`		`- for i := 0; i < b.N; i++ {`
	`25`	`+ for b.Loop() {`
`26`	`26`	`_ = HeapAlloc()`
`27`	`27`	`}`
`28`	`28`	`}`
`@@ -37,7 +37,7 @@ func HeapAllocEscape() {`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`func BenchmarkHeapAllocEscape(b *testing.B) {`
`40`		`- for i := 0; i < b.N; i++ {`
	`40`	`+ for b.Loop() {`
`41`	`41`	`HeapAllocEscape()`
`42`	`42`	`}`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ func doWork(n int) [32]byte {`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`func BenchmarkUnboundedGoroutines(b *testing.B) {`
`24`		`- for i := 0; i < b.N; i++ {`
	`24`	`+ for b.Loop() {`
`25`	`25`	`var wg sync.WaitGroup`
`26`	`26`	`wg.Add(numJobs)`
`27`	`27`
`@@ -43,7 +43,7 @@ func worker(jobs <-chan int, wg *sync.WaitGroup) {`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`func BenchmarkWorkerPool(b *testing.B) {`
`46`		`- for i := 0; i < b.N; i++ {`
	`46`	`+ for b.Loop() {`
`47`	`47`	`var wg sync.WaitGroup`
`48`	`48`	`wg.Add(numJobs)`
`49`	`49`
Original file line number	Diff line number	Diff line change
`@@ -10,22 +10,18 @@ import (`
`10`	`10`	`)`
`11`	`11`
`12`	`12`	`// bench-start`
`13`		`-var sink []byte`
`14`		`-`
`15`	`13`	`func BenchmarkCopy(b *testing.B) {`
`16`	`14`	`data := make([]byte, 64*1024)`
`17`		`- for i := 0; i < b.N; i++ {`
	`15`	`+ for b.Loop() {`
`18`	`16`	`buf := make([]byte, len(data))`
`19`	`17`	`copy(buf, data)`
`20`		`- sink = buf`
`21`	`18`	`}`
`22`	`19`	`}`
`23`	`20`
`24`	`21`	`func BenchmarkSlice(b *testing.B) {`
`25`	`22`	`data := make([]byte, 64*1024)`
`26`		`- for i := 0; i < b.N; i++ {`
`27`		`- s := data[:]`
`28`		`- sink = s`
	`23`	`+ for b.Loop() {`
	`24`	`+ _ = data[:]`
`29`	`25`	`}`
`30`	`26`	`}`
`31`	`27`	`// bench-end`
`@@ -39,13 +35,11 @@ func BenchmarkReadWithCopy(b *testing.B) {`
`39`	`35`	`defer f.Close()`
`40`	`36`
`41`	`37`	`buf := make([]byte, 410241024) // 4MB buffer`
`42`		`- b.ResetTimer()`
`43`		`- for i := 0; i < b.N; i++ {`
	`38`	`+ for b.Loop() {`
`44`	`39`	`_, err := f.ReadAt(buf, 0)`
`45`	`40`	`if err != nil && err != io.EOF {`
`46`	`41`	`b.Fatal(err)`
`47`	`42`	`}`
`48`		`- sink = buf`
`49`	`43`	`}`
`50`	`44`	`}`
`51`	`45`
`@@ -57,13 +51,11 @@ func BenchmarkReadWithMmap(b *testing.B) {`
`57`	`51`	`defer r.Close()`
`58`	`52`
`59`	`53`	`buf := make([]byte, r.Len())`
`60`		`- b.ResetTimer()`
`61`		`- for i := 0; i < b.N; i++ {`
	`54`	`+ for b.Loop() {`
`62`	`55`	`_, err := r.ReadAt(buf, 0)`
`63`	`56`	`if err != nil && err != io.EOF {`
`64`	`57`	`b.Fatal(err)`
`65`	`58`	`}`
`66`		`- sink = buf`
`67`	`59`	`}`
`68`	`60`	`}`
`69`		`-// bench-io-end`
	`61`	`+// bench-io-end`