Add execution-path syncer benchmarks · Entire
Add execution-path syncer benchmarks
e9b6ed4→main·
Soph·3mo ago·2 files·+221 added/-3 removed
Sessions
2a65ca22e9d1View transcript
Changes
2
docs
- Mrewrite-issue-list.md+3/-3
internal/syncer
- Abenchmark_test.go+218
418 unmodified lines
419
420
421
422
422
423
424
425
426
427
428
428
429
430
431
5 unmodified lines
437
438
439
440
440
441
442
443
418 unmodified lines
### 22. No benchmark coverage for the expensive paths
Status: partial
Status: done
Rewrite requirement:
- Add benchmarks for relay path overhead, planning overhead, and fallback graph/object work.
Current rewrite note:
- Planner and protocol benchmarks exist, but execution-path benchmarks for bootstrap relay, incremental relay, and materialized fallback still appear missing.
- Planner and protocol benchmarks exist, and the rewrite now also includes syncer-level execution-path benchmarks for bootstrap relay, incremental relay, and a materialized fallback case.
## Rewrite Branch Acceptance Criteria
5 unmodified lines
- Logging is structured and concurrency-safe. Status: done
- Protocol parsing has explicit malformed-input tests. Status: done
- Rewrite passes `go test ./...` and `go test -race ./...`. Status: done
- Rewrite includes benchmarks for the critical planning and execution paths. Status: partial
- Rewrite includes benchmarks for the critical planning and execution paths. Status: done
- Rewrite branch can be compared against current behavior using the same integration scenarios. Status: done
Notes:
Mdocs/rewrite-issue-list.md+3/-3
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
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
package syncer
import (
"context"
"fmt"
"io"
"testing"
"time"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/memfs"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage/memory"
)
func BenchmarkRunBootstrapEmptyTarget(b *testing.B) {
b.ReportAllocs()
sourceRepo, sourceFS := newBenchRepo(b)
makeBenchCommits(b, sourceRepo, sourceFS, 8)
sourceServer := newSmartHTTPRepoServerV2(&testing.T{}, sourceRepo)
defer sourceServer.Close()
b.ResetTimer()
for i := 0; i < b.N; i++ {
b.StopTimer()
targetRepo, err := git.Init(memory.NewStorage(), nil)
if err != nil {
b.Fatalf("init target repo: %v", err)
}
targetServer := newSmartHTTPRepoServer(&testing.T{}, targetRepo)
b.StartTimer()
_, err = Run(context.Background(), Config{
Source: Endpoint{URL: sourceServer.RepoURL()},
Target: Endpoint{URL: targetServer.RepoURL()},
ProtocolMode: protocolModeAuto,
})
b.StopTimer()
targetServer.Close()
if err != nil {
b.Fatalf("bootstrap benchmark run failed: %v", err)
}
b.StartTimer()
}
}
func BenchmarkRunIncrementalRelay(b *testing.B) {
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
b.StopTimer()
sourceRepo, sourceFS := newBenchRepo(b)
makeBenchCommits(b, sourceRepo, sourceFS, 2)
targetRepo, err := git.Init(memory.NewStorage(), nil)
if err != nil {
b.Fatalf("init target repo: %v", err)
}
if err := copyRefsAndObjects(sourceRepo.Storer, targetRepo.Storer, []plumbing.ReferenceName{plumbing.NewBranchReferenceName(testBranch)}); err != nil {
b.Fatalf("copy target baseline: %v", err)
}
makeBenchCommits(b, sourceRepo, sourceFS, 1)
sourceServer := newSmartHTTPRepoServerV2(&testing.T{}, sourceRepo)
targetServer := newSmartHTTPRepoServer(&testing.T{}, targetRepo)
b.StartTimer()
_, err = Run(context.Background(), Config{
Source: Endpoint{URL: sourceServer.RepoURL()},
Target: Endpoint{URL: targetServer.RepoURL()},
ProtocolMode: protocolModeAuto,
})
b.StopTimer()
sourceServer.Close()
targetServer.Close()
if err != nil {
b.Fatalf("incremental benchmark run failed: %v", err)
}
b.StartTimer()
}
}
func BenchmarkRunMaterializedFallback(b *testing.B) {
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
b.StopTimer()
sourceRepo, sourceFS := newBenchRepo(b)
makeBenchCommits(b, sourceRepo, sourceFS, 3)
sourceHead, err := sourceRepo.Reference(plumbing.NewBranchReferenceName(testBranch), true)
if err != nil {
b.Fatalf("resolve source head: %v", err)
}
if err := sourceRepo.Storer.SetReference(plumbing.NewHashReference(plumbing.NewBranchReferenceName("release"), sourceHead.Hash())); err != nil {
b.Fatalf("set source release branch: %v", err)
}
sourceServer := newSmartHTTPRepoServerV2(&testing.T{}, sourceRepo)
targetServer := newSmartHTTPRepoServer(&testing.T{}, targetRepo)
b.StartTimer()
_, err = Run(context.Background(), Config{
Source: Endpoint{URL: sourceServer.RepoURL()},
Target: Endpoint{URL: targetServer.RepoURL()},
ProtocolMode: protocolModeAuto,
})
b.StopTimer()
sourceServer.Close()
targetServer.Close()
if err != nil {
b.Fatalf("materialized benchmark run failed: %v", err)
}
b.StartTimer()
}
}
func newBenchRepo(b *testing.B) (*git.Repository, billy.Filesystem) {
b.Helper()
fs := memfs.New()
repo, err := git.Init(memory.NewStorage(), fs)
if err != nil {
b.Fatalf("init repo: %v", err)
}
return repo, fs
}
func makeBenchCommits(b *testing.B, repo *git.Repository, fs billy.Filesystem, count int) {
b.Helper()
wt, err := repo.Worktree()
if err != nil {
b.Fatalf("open worktree: %v", err)
}
for i := 0; i < count; i++ {
content := fmt.Sprintf("bench line %d %d\n", i, time.Now().UnixNano())
file, err := fs.Create("tracked.txt")
if err != nil {
b.Fatalf("create file: %v", err)
}
if _, err := io.WriteString(file, content); err != nil {
b.Fatalf("write file: %v", err)
}
if err := file.Close(); err != nil {
b.Fatalf("close file: %v", err)
}
if _, err := wt.Add("tracked.txt"); err != nil {
b.Fatalf("add file: %v", err)
}
if _, err := wt.Commit(fmt.Sprintf("bench commit %d", i), &git.CommitOptions{
Author: &objectSignature,
Committer: &objectSignature,
}); err != nil {
b.Fatalf("commit: %v", err)
}
}
}
func copyRefsAndObjects(src, dst storer.Storer, refs []plumbing.ReferenceName) error {
iter, err := src.IterEncodedObjects(plumbing.AnyObject)
if err != nil {
return err
}
defer iter.Close()
if err := iter.ForEach(func(obj plumbing.EncodedObject) error {
newObj := dst.NewEncodedObject()
newObj.SetType(obj.Type())
newObj.SetSize(obj.Size())
r, err := obj.Reader()
if err != nil {
return err
}
defer r.Close()
w, err := newObj.Writer()
if err != nil {
return err
}
if _, err := io.Copy(w, r); err != nil {
_ = w.Close()
return err
}
if err := w.Close(); err != nil {
return err
}
_, err = dst.SetEncodedObject(newObj)
return err
}); err != nil {
return err
}
for _, refName := range refs {
ref, err := src.Reference(refName)
if err != nil {
return err
}
if err := dst.SetReference(plumbing.NewHashReference(refName, ref.Hash())); err != nil {
return err
}
}
return nil
}