build: Add benchmark for open/read ops

This benchmark aims to compare the time and space complexity across the
different billy implementations, which will later be used to assess their
trends over time.

The initial figures shows that there is a substantial difference in cost
for the Open operation amongst the os-based options, however the impact on
Read operations is more subtle. As expected, in memory has the best figures
for most cases.

goos: linux
goarch: amd64
pkg: github.com/go-git/go-billy/v6/test
cpu: AMD Ryzen 7 PRO 8840HS w/ Radeon 780M Graphics
BenchmarkOpenRead/stdlib_open-16         	  319782	      3750 ns/op	     152 B/op	       3 allocs/op
BenchmarkOpenRead/osfs.chrootOS_open-16  	  248833	      4620 ns/op	     360 B/op	       9 allocs/op
BenchmarkOpenRead/osfs.boundOS_open-16   	  182808	      6370 ns/op	     984 B/op	      20 allocs/op
BenchmarkOpenRead/memfs_open-16          	 1000000	      1038 ns/op	     224 B/op	      10 allocs/op
BenchmarkOpenRead/stdlib_read-16         	  165465	      6791 ns/op	 150.79 MB/s	       0 B/op	       0 allocs/op
BenchmarkOpenRead/osfs.chrootOS_read-16  	  158107	      7018 ns/op	 145.90 MB/s	       0 B/op	       0 allocs/op
BenchmarkOpenRead/osfs.boundOS_read-16   	  155649	      6865 ns/op	 149.15 MB/s	       0 B/op	       0 allocs/op
BenchmarkOpenRead/memfs_read-16          	  705140	      1703 ns/op	 601.17 MB/s	       0 B/op	       0 allocs/op
PASS
ok  	github.com/go-git/go-billy/v6/test	34.080s

Signed-off-by: Paulo Gomes <[email protected]>

Author: pjbgf

test/bench_test.go

@@ -0,0 +1,149 @@
+package test
+
+import (
+	"crypto/rand"
+	"io"
+	"os"
+	"testing"
+
+	"github.com/go-git/go-billy/v6"
+	"github.com/go-git/go-billy/v6/memfs"
+	"github.com/go-git/go-billy/v6/osfs"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	fn          = "test"
+	contentSize = 1024 * 10
+	bufSize     = 1024
+)
+
+type test struct {
+	name    string
+	fn      string
+	sut     billy.Filesystem
+	openF   func(billy.Filesystem) func(string) (io.ReadSeekCloser, error)
+	createF func(*testing.B, billy.Filesystem, string) (io.WriteCloser, error)
+}
+
+func BenchmarkOpenRead(b *testing.B) {
+	tests := []test{
+		{
+			// provide baseline comparison against direct use of os.
+			name:    "stdlib",
+			fn:      filepath.Join(b.TempDir(), fn),
+			openF:   stdlibOpen,
+			createF: stdlibCreate,
+		},
+		{
+			name:    "osfs.chrootOS",
+			fn:      fn,
+			sut:     osfs.New(b.TempDir(), osfs.WithChrootOS()),
+			openF:   billyOpen,
+			createF: billyCreate,
+		},
+		{
+			name:    "osfs.boundOS",
+			fn:      fn,
+			sut:     osfs.New(b.TempDir(), osfs.WithBoundOS()),
+			openF:   billyOpen,
+			createF: billyCreate,
+		},
+		{
+			name:    "memfs",
+			fn:      fn,
+			sut:     memfs.New(),
+			openF:   billyOpen,
+			createF: billyCreate,
+		},
+	}
+
+	for _, tc := range tests {
+		f, err := tc.createF(b, tc.sut, tc.fn)
+		require.NoError(b, err)
+		assert.NotNil(b, f)
+
+		prepFS(b, f)
+		b.Run(tc.name+"_open", open(tc.fn, tc.openF(tc.sut)))
+	}
+
+	for _, tc := range tests {
+		b.Run(tc.name+"_read", read(tc.fn, tc.openF(tc.sut)))
+	}
+}
+
+func open(n string, of func(string) (io.ReadSeekCloser, error)) func(b *testing.B) {
+	return func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			f, err := of(n)
+			require.NoError(b, err)
+			assert.NotNil(b, f)
+
+			b.StopTimer()
+			err = f.Close()
+			require.NoError(b, err)
+			b.StartTimer()
+		}
+	}
+}
+
+func read(n string, of func(string) (io.ReadSeekCloser, error)) func(b *testing.B) {
+	return func(b *testing.B) {
+		b.StopTimer()
+
+		buf := make([]byte, 1024)
+		f, err := of(n)
+		require.NoError(b, err)
+		assert.NotNil(b, f)
+
+		b.StartTimer()
+		for i := 0; i < b.N; i++ {
+			_, err = f.Seek(0, io.SeekStart)
+			require.NoError(b, err)
+
+			for {
+				n, err := f.Read(buf)
+				if n == 0 {
+					break
+				}
+				b.SetBytes(int64(n))
+				require.NoError(b, err)
+			}
+		}
+
+		err = f.Close()
+		require.NoError(b, err)
+	}
+}
+
+func prepFS(b *testing.B, f io.WriteCloser) {
+	defer f.Close()
+
+	content := make([]byte, contentSize)
+	_, err := rand.Read(content)
+	require.NoError(b, err, "failed to generate random content")
+
+	_, err = f.Write(content)
+	require.NoError(b, err, "failed to write test file")
+}
+
+func stdlibOpen(_ billy.Filesystem) func(n string) (io.ReadSeekCloser, error) {
+	return func(n string) (io.ReadSeekCloser, error) {
+		return os.Open(n)
+	}
+}
+
+func billyOpen(fs billy.Filesystem) func(n string) (io.ReadSeekCloser, error) {
+	return func(n string) (io.ReadSeekCloser, error) {
+		return fs.Open(n)
+	}
+}
+
+func stdlibCreate(_ *testing.B, _ billy.Filesystem, n string) (io.WriteCloser, error) {
+	return os.Create(n)
+}
+
+func billyCreate(b *testing.B, fs billy.Filesystem, n string) (io.WriteCloser, error) {
+	return fs.Create(n)
+}