← Back to branch summary

~ubuntu-branches/debian/experimental/upspin/experimental

« back to all changes in this revision

Viewing changes to dir/server/bench_test.go

  • Committer: Package Import Robot
  • Author(s): Michael Stapelberg
  • Date: 2017-03-09 14:06:46 UTC
  • Revision ID: package-import@ubuntu.com-20170309140646-3q7qp80jy7aivjsg
Tags: upstream-0.0~git20170316.0.d0c0831
Import upstream version 0.0~git20170316.0.d0c0831

Show diffs side-by-side

added added

removed removed

Lines of Context:
dir/server/bench_test.go
 
1
// Copyright 2017 The Upspin Authors. All rights reserved.
 
2
// Use of this source code is governed by a BSD-style
 
3
// license that can be found in the LICENSE file.
 
4
 
 
5
package server
 
6
 
 
7
import (
 
8
        "fmt"
 
9
        "io/ioutil"
 
10
        "os"
 
11
        "testing"
 
12
 
 
13
        "upspin.io/cache"
 
14
        "upspin.io/log"
 
15
        "upspin.io/path"
 
16
        "upspin.io/upspin"
 
17
)
 
18
 
 
19
// These benchmarks by default run on local storage. To isolate the performance
 
20
// of the DirServer from the system's storage the DirServer logs should be
 
21
// written to a ram disk.
 
22
//
 
23
// To set up a ram disk on Linux Ubuntu 16.04 do:
 
24
//
 
25
// mkdir /dev/shm/benchdir
 
26
//
 
27
// Then run benchmarks:
 
28
//
 
29
// env TMPDIR=/dev/shm/benchdir go test -bench=. -benchmem
 
30
//
 
31
 
 
32
func BenchmarkPutAtRoot(b *testing.B) {
 
33
        benchmarkPut(b, userName)
 
34
}
 
35
 
 
36
func BenchmarkPut1Deep(b *testing.B) {
 
37
        benchmarkPut(b, userName+"/"+mkName())
 
38
}
 
39
 
 
40
func BenchmarkPut2Deep(b *testing.B) {
 
41
        benchmarkPut(b, userName+"/"+mkName()+"/"+mkName())
 
42
}
 
43
 
 
44
func BenchmarkPut4Deep(b *testing.B) {
 
45
        benchmarkPut(b, userName+"/"+mkName()+"/"+mkName()+"/"+mkName()+"/"+mkName())
 
46
}
 
47
 
 
48
func benchmarkPut(b *testing.B, dir upspin.PathName) {
 
49
        b.StopTimer()
 
50
        s, _, cleanup := setupBenchServer(b)
 
51
        defer cleanup()
 
52
        mkAll(b, s, dir)
 
53
        b.StartTimer()
 
54
 
 
55
        for i := 0; i < b.N; i++ {
 
56
                subdir := mkName()
 
57
                name := dir + "/" + subdir
 
58
                _, err := s.Put(&upspin.DirEntry{
 
59
                        Name:       name,
 
60
                        SignedName: name,
 
61
                        Attr:       upspin.AttrDirectory,
 
62
                })
 
63
                if err != nil {
 
64
                        b.Fatal(err)
 
65
                }
 
66
        }
 
67
}
 
68
 
 
69
const cached = true
 
70
 
 
71
func BenchmarkLookupAtRootNotCached(b *testing.B) {
 
72
        benckmarkLookup(b, !cached, userName+"/"+mkName())
 
73
}
 
74
 
 
75
func BenchmarkLookupAtRootCached(b *testing.B) {
 
76
        benckmarkLookup(b, cached, userName+"/"+mkName())
 
77
}
 
78
 
 
79
func BenchmarkLookup4DeepNotCached(b *testing.B) {
 
80
        benckmarkLookup(b, !cached, userName+"/"+mkName()+"/"+mkName()+"/"+mkName()+"/"+mkName())
 
81
}
 
82
 
 
83
func BenchmarkLookup4DeepCached(b *testing.B) {
 
84
        benckmarkLookup(b, cached, userName+"/"+mkName()+"/"+mkName()+"/"+mkName()+"/"+mkName())
 
85
}
 
86
 
 
87
func benckmarkLookup(b *testing.B, cached bool, dir upspin.PathName) {
 
88
        b.StopTimer()
 
89
        s, _, cleanup := setupBenchServer(b)
 
90
        defer cleanup()
 
91
        s.userTrees = cache.NewLRU(1)
 
92
        mkAll(b, s, dir)
 
93
        b.StartTimer()
 
94
 
 
95
        for i := 0; i < b.N; i++ {
 
96
                _, err := s.Lookup(dir)
 
97
                if err != nil {
 
98
                        b.Fatal(err)
 
99
                }
 
100
                if !cached {
 
101
                        s.userTrees.RemoveOldest()
 
102
                }
 
103
        }
 
104
}
 
105
 
 
106
// setupBenchServer sets up the benchmark tests and returns the server to use,
 
107
// the user's config and a clean up function to use after benchmarks are run.
 
108
func setupBenchServer(t testing.TB) (*server, upspin.Config, func()) {
 
109
        testDir, err := ioutil.TempDir("", "DirServer.Bench")
 
110
        if err != nil {
 
111
                panic(err)
 
112
        }
 
113
        generatorInstance = nil
 
114
        log.SetOutput(nil)
 
115
        s, cfg := newDirServerForTestingWithTestDir(t, userName, testDir)
 
116
        _, err = makeDirectory(s, userName+"/")
 
117
        if err != nil {
 
118
                t.Fatal(err)
 
119
        }
 
120
        f := func() {
 
121
                os.RemoveAll(testDir)
 
122
                log.SetOutput(os.Stderr)
 
123
        }
 
124
        return s, cfg, f
 
125
}
 
126
 
 
127
func mkAll(b *testing.B, s *server, dir upspin.PathName) {
 
128
        p, err := path.Parse(dir)
 
129
        if err != nil {
 
130
                b.Fatal(err)
 
131
        }
 
132
        for i := 0; i < p.NElem(); i++ {
 
133
                makeDirectory(s, p.First(i+1).Path())
 
134
        }
 
135
}
 
136
 
 
137
var nameCount int
 
138
 
 
139
func mkName() upspin.PathName {
 
140
        nameCount++
 
141
        return upspin.PathName(fmt.Sprintf("%d", nameCount))
 
142
}