1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
// Copyright 2019 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// These benchmarks emulate memfs benchmarks. Ext4 images must be created
// before this benchmark is run using the `make_deep_ext4.sh` script at
// /tmp/image-{depth}.ext4 for all the depths tested below.
package benchmark_test
import (
"fmt"
"os"
"runtime"
"strings"
"testing"
"gvisor.dev/gvisor/pkg/sentry/context"
"gvisor.dev/gvisor/pkg/sentry/context/contexttest"
"gvisor.dev/gvisor/pkg/sentry/fs/ext"
"gvisor.dev/gvisor/pkg/sentry/kernel/auth"
"gvisor.dev/gvisor/pkg/sentry/vfs"
)
var depths = []int{1, 2, 3, 8, 64, 100}
const filename = "file.txt"
// setUp opens imagePath as an ext Filesystem and returns all necessary
// elements required to run tests. If error is nil, it also returns a tear
// down function which must be called after the test is run for clean up.
func setUp(b *testing.B, imagePath string) (context.Context, *vfs.VirtualFilesystem, *vfs.VirtualDentry, func(), error) {
f, err := os.Open(imagePath)
if err != nil {
return nil, nil, nil, nil, err
}
ctx := contexttest.Context(b)
creds := auth.CredentialsFromContext(ctx)
// Create VFS.
vfsObj := vfs.New()
vfsObj.MustRegisterFilesystemType("extfs", ext.FilesystemType{})
mntns, err := vfsObj.NewMountNamespace(ctx, creds, imagePath, "extfs", &vfs.NewFilesystemOptions{InternalData: int(f.Fd())})
if err != nil {
f.Close()
return nil, nil, nil, nil, err
}
root := mntns.Root()
tearDown := func() {
root.DecRef()
if err := f.Close(); err != nil {
b.Fatalf("tearDown failed: %v", err)
}
}
return ctx, vfsObj, &root, tearDown, nil
}
// mount mounts extfs at the path operation passed. Returns a tear down
// function which must be called after the test is run for clean up.
func mount(b *testing.B, imagePath string, vfsfs *vfs.VirtualFilesystem, pop *vfs.PathOperation) func() {
b.Helper()
f, err := os.Open(imagePath)
if err != nil {
b.Fatalf("could not open image at %s: %v", imagePath, err)
}
ctx := contexttest.Context(b)
creds := auth.CredentialsFromContext(ctx)
if err := vfsfs.NewMount(ctx, creds, imagePath, pop, "extfs", &vfs.NewFilesystemOptions{InternalData: int(f.Fd())}); err != nil {
b.Fatalf("failed to mount tmpfs submount: %v", err)
}
return func() {
if err := f.Close(); err != nil {
b.Fatalf("tearDown failed: %v", err)
}
}
}
// BenchmarkVFS2Ext4fsStat emulates BenchmarkVFS2MemfsStat.
func BenchmarkVFS2Ext4fsStat(b *testing.B) {
for _, depth := range depths {
b.Run(fmt.Sprintf("%d", depth), func(b *testing.B) {
ctx, vfsfs, root, tearDown, err := setUp(b, fmt.Sprintf("/tmp/image-%d.ext4", depth))
if err != nil {
b.Fatalf("setUp failed: %v", err)
}
defer tearDown()
creds := auth.CredentialsFromContext(ctx)
var filePathBuilder strings.Builder
filePathBuilder.WriteByte('/')
for i := 1; i <= depth; i++ {
filePathBuilder.WriteString(fmt.Sprintf("%d", i))
filePathBuilder.WriteByte('/')
}
filePathBuilder.WriteString(filename)
filePath := filePathBuilder.String()
runtime.GC()
b.ResetTimer()
for i := 0; i < b.N; i++ {
stat, err := vfsfs.StatAt(ctx, creds, &vfs.PathOperation{
Root: *root,
Start: *root,
Pathname: filePath,
FollowFinalSymlink: true,
}, &vfs.StatOptions{})
if err != nil {
b.Fatalf("stat(%q) failed: %v", filePath, err)
}
// Sanity check.
if stat.Size > 0 {
b.Fatalf("got wrong file size (%d)", stat.Size)
}
}
})
}
}
// BenchmarkVFS2ExtfsMountStat emulates BenchmarkVFS2MemfsMountStat.
func BenchmarkVFS2ExtfsMountStat(b *testing.B) {
for _, depth := range depths {
b.Run(fmt.Sprintf("%d", depth), func(b *testing.B) {
// Create root extfs with depth 1 so we can mount extfs again at /1/.
ctx, vfsfs, root, tearDown, err := setUp(b, fmt.Sprintf("/tmp/image-%d.ext4", 1))
if err != nil {
b.Fatalf("setUp failed: %v", err)
}
defer tearDown()
creds := auth.CredentialsFromContext(ctx)
mountPointName := "/1/"
pop := vfs.PathOperation{
Root: *root,
Start: *root,
Pathname: mountPointName,
}
// Save the mount point for later use.
mountPoint, err := vfsfs.GetDentryAt(ctx, creds, &pop, &vfs.GetDentryOptions{})
if err != nil {
b.Fatalf("failed to walk to mount point: %v", err)
}
defer mountPoint.DecRef()
// Create extfs submount.
mountTearDown := mount(b, fmt.Sprintf("/tmp/image-%d.ext4", depth), vfsfs, &pop)
defer mountTearDown()
var filePathBuilder strings.Builder
filePathBuilder.WriteString(mountPointName)
for i := 1; i <= depth; i++ {
filePathBuilder.WriteString(fmt.Sprintf("%d", i))
filePathBuilder.WriteByte('/')
}
filePathBuilder.WriteString(filename)
filePath := filePathBuilder.String()
runtime.GC()
b.ResetTimer()
for i := 0; i < b.N; i++ {
stat, err := vfsfs.StatAt(ctx, creds, &vfs.PathOperation{
Root: *root,
Start: *root,
Pathname: filePath,
FollowFinalSymlink: true,
}, &vfs.StatOptions{})
if err != nil {
b.Fatalf("stat(%q) failed: %v", filePath, err)
}
// Sanity check. touch(1) always creates files of size 0 (empty).
if stat.Size > 0 {
b.Fatalf("got wrong file size (%d)", stat.Size)
}
}
})
}
}
|
