/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/benchmarks/bench_bundle.py

  • Committer: Carl Friedrich Bolz
  • Date: 2006-08-18 23:37:50 UTC
  • mto: (1908.3.21 usecases-benchmarks)
  • mto: This revision was merged to the branch mainline in revision 2068.
  • Revision ID: cfbolz@gmx.de-20060818233750-db224a07bf88740b
Fix docstrings and other things to be PEP 8 compatible. Removed caching of
trees in preparation of using John's mechanism.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/benchmarks/bench_bundle.py
15
15
 
16
16
"""Tests for bzr bundle performance."""
17
17
 
18
 
 
19
18
import os
20
19
import shutil
21
 
from StringIO import StringIO
 
20
from cStringIO import StringIO
22
21
 
23
22
from bzrlib.benchmarks import Benchmark
24
 
from bzrlib.workingtree import WorkingTree
25
23
from bzrlib.branch import Branch
 
24
from bzrlib.bundle import read_bundle
26
25
from bzrlib.bundle.serializer import write_bundle
27
 
from bzrlib.bundle import read_bundle
28
26
from bzrlib.revisionspec import RevisionSpec
29
 
 
30
 
# if set, creation of test trees will be globally cached (even across test runs)
31
 
#CACHEDIR = os.path.expanduser("~/.bazaar/devtemp")
32
 
CACHEDIR = None 
33
 
 
34
 
def cached_make(maker, *args):
35
 
    if CACHEDIR is None:
36
 
        return maker(*args)
37
 
    olddir = os.getcwd()
38
 
    try:
39
 
        if not os.path.exists(CACHEDIR):
40
 
            os.makedirs(CACHEDIR)
41
 
        os.chdir(CACHEDIR)
42
 
        cache_name = "_".join([maker.__name__] + [str(x) for x in args])
43
 
        if not os.path.exists(cache_name):
44
 
            os.mkdir(cache_name)
45
 
            os.chdir(cache_name)
46
 
            try:
47
 
                maker(*args)
48
 
            except:
49
 
                os.chdir(CACHEDIR)
50
 
                shutil.rmtree(cache_name)
51
 
                raise
52
 
            os.chdir(CACHEDIR)
53
 
                
54
 
        for subdir in os.listdir(cache_name):
55
 
            shutil.copytree(os.path.join(cache_name, subdir),
56
 
                            os.path.join(olddir, subdir))
57
 
    finally:
58
 
        os.chdir(olddir)
 
27
from bzrlib.workingtree import WorkingTree
 
28
 
59
29
 
60
30
class BundleBenchmark(Benchmark):
 
31
    """The bundle tests should (also) be done at a lower level with
 
32
    direct call to the bzrlib.
61
33
    """
62
 
    The bundle tests should (also) be done at a lower level with
63
 
    direct call to the bzrlib."""
64
34
   
65
 
    def make_kernel_like_tree_committed(self): 
66
 
        cached_make(self.make_kernel_like_tree)
67
 
        self.run_bzr('add')
 
35
    def make_kernel_like_tree_committed(self):
 
36
        self.make_kernel_like_tree_added()
68
37
        self.run_bzr('commit', '-m', 'initial import')
69
38
 
70
39
    def test_create_bundle_known_kernel_like_tree(self):
71
 
        """
72
 
        Create a bundle for a kernel sized tree with no ignored, unknowns,
73
 
        or added and one commit.""" 
74
 
        cached_make(self.make_kernel_like_tree_committed)
 
40
        """Create a bundle for a kernel sized tree with no ignored, unknowns,
 
41
        or added and one commit.
 
42
        """ 
 
43
        self.make_kernel_like_tree_committed()
75
44
        self.time(self.run_bzr, 'bundle', '--revision', '..-1')
76
45
 
77
46
    def test_create_bundle_many_commit_tree (self):
78
 
        """
79
 
        Create a bundle for a tree with many commits but no changes.""" 
80
 
        cached_make(self.make_many_commit_tree)
 
47
        """Create a bundle for a tree with many commits but no changes.""" 
 
48
        self.make_many_commit_tree()
81
49
        self.time(self.run_bzr, 'bundle', '--revision', '..-1')
82
50
 
83
51
    def test_create_bundle_heavily_merged_tree(self):
84
 
        """
85
 
        Create a bundle for a heavily merged tree.""" 
86
 
        cached_make(self.make_heavily_merged_tree)
 
52
        """Create a bundle for a heavily merged tree.""" 
 
53
        self.make_heavily_merged_tree()
87
54
        self.time(self.run_bzr, 'bundle', '--revision', '..-1')
88
55
        
89
56
    def test_apply_bundle_known_kernel_like_tree(self):
90
 
        """
91
 
        Create a bundle for a kernel sized tree with no ignored, unknowns,
92
 
        or added and one commit.""" 
93
 
        cached_make(self.make_kernel_like_tree_committed)
 
57
        """Create a bundle for a kernel sized tree with no ignored, unknowns,
 
58
        or added and one commit.
 
59
        """ 
 
60
        self.make_kernel_like_tree_committed()
94
61
        f = file('../bundle', 'wb')
95
62
        try:
96
63
            f.write(self.run_bzr('bundle', '--revision', '..-1')[0])
146
113
        assert count >= num_revisions
147
114
 
148
115
    def _time_read_write(self):
149
 
        branch, _ = Branch.open_containing(".")
 
116
        branch, relpath = Branch.open_containing(".")
150
117
        revision_history = branch.revision_history()
151
118
        bundle_text = StringIO()
152
119
        self.time(write_bundle, branch.repository, revision_history[-1],
155
122
        self.time(read_bundle, bundle_text)
156
123
 
157
124
    def test_few_files_small_tree_1_revision(self):
158
 
        cached_make(self.make_parametrized_tree, 5, 1, 5)
 
125
        self.make_parametrized_tree(5, 1, 5)
159
126
        self._time_read_write()
160
127
 
161
128
    def test_few_files_small_tree_500_revision(self):
162
 
        cached_make(self.make_parametrized_tree, 5, 500, 5)
 
129
        self.make_parametrized_tree(5, 500, 5)
163
130
        self._time_read_write()
164
131
 
165
132
    def test_few_files_small_tree_1000_revision(self):
166
 
        cached_make(self.make_parametrized_tree, 5, 1000, 5)
 
133
        self.make_parametrized_tree(5, 1000, 5)
167
134
        self._time_read_write()
168
135
 
169
136
    def test_few_files_moderate_tree_1_revision(self):
170
 
        cached_make(self.make_parametrized_tree, 100, 1, 5)
 
137
        self.make_parametrized_tree(100, 1, 5)
171
138
        self._time_read_write()
172
139
 
173
140
    def test_few_files_moderate_tree_500_revision(self):
174
 
        cached_make(self.make_parametrized_tree, 100, 500, 5)
 
141
        self.make_parametrized_tree(100, 500, 5)
175
142
        self._time_read_write()
176
143
 
177
144
    def test_few_files_moderate_tree_1000_revision(self):
178
 
        cached_make(self.make_parametrized_tree, 100, 1000, 5)
 
145
        self.make_parametrized_tree(100, 1000, 5)
179
146
        self._time_read_write()
180
147
 
181
148
    def test_some_files_moderate_tree_1_revision(self):
182
 
        cached_make(self.make_parametrized_tree, 100, 1, 100)
 
149
        self.make_parametrized_tree(100, 1, 100)
183
150
        self._time_read_write()
184
151
 
185
152
    def test_some_files_moderate_tree_500_revision(self):
186
 
        cached_make(self.make_parametrized_tree, 100, 500, 100)
 
153
        self.make_parametrized_tree(100, 500, 100)
187
154
        self._time_read_write()
188
155
 
189
156
    def test_some_files_moderate_tree_1000_revision(self):
190
 
        cached_make(self.make_parametrized_tree, 100, 1000, 100)
 
157
        self.make_parametrized_tree(100, 1000, 100)
191
158
        self._time_read_write()
192
159
 
193
160
    def test_few_files_big_tree_1_revision(self):
194
 
        cached_make(self.make_parametrized_tree, 1000, 1, 5)
 
161
        self.make_parametrized_tree(1000, 1, 5)
195
162
        self._time_read_write()
196
163
 
197
164
    def test_few_files_big_tree_500_revision(self):
198
 
        cached_make(self.make_parametrized_tree, 1000, 500, 5)
 
165
        self.make_parametrized_tree(1000, 500, 5)
199
166
        self._time_read_write()
200
167
 
201
168
    def test_few_files_big_tree_1000_revision(self):
202
 
        cached_make(self.make_parametrized_tree, 1000, 1000, 5)
 
169
        self.make_parametrized_tree(1000, 1000, 5)
203
170
        self._time_read_write()
204
171
 
205
172
    def test_some_files_big_tree_1_revision(self):
206
 
        cached_make(self.make_parametrized_tree, 1000, 1, 100)
 
173
        self.make_parametrized_tree(1000, 1, 100)
207
174
        self._time_read_write()
208
175
 
209
176
    def test_some_files_big_tree_500_revision(self):
210
 
        cached_make(self.make_parametrized_tree, 1000, 500, 100)
 
177
        self.make_parametrized_tree(1000, 500, 100)
211
178
        self._time_read_write()
212
179
 
213
180
    def test_some_files_big_tree_1000_revision(self):
214
 
        cached_make(self.make_parametrized_tree, 1000, 1000, 100)
 
181
        self.make_parametrized_tree(1000, 1000, 100)
215
182
        self._time_read_write()
216
183
 
217
184
    def test_many_files_big_tree_1_revision(self):
218
 
        cached_make(self.make_parametrized_tree, 1000, 1, 1000)
 
185
        self.make_parametrized_tree(1000, 1, 1000)
219
186
        self._time_read_write()
220
187
 
221
188
    def test_many_files_big_tree_500_revision(self):
222
 
        cached_make(self.make_parametrized_tree, 1000, 500, 1000)
 
189
        self.make_parametrized_tree(1000, 500, 1000)
223
190
        self._time_read_write()
224
191
 
225
192
    def test_many_files_big_tree_1000_revision(self):
226
 
        cached_make(self.make_parametrized_tree, 1000, 1000, 1000)
 
193
        self.make_parametrized_tree(1000, 1000, 1000)
227
194
        self._time_read_write()
228
195
 
229
196
 
238
205
            for num_revisions in [1, 500, 1000]:
239
206
                code = """\
240
207
    def test_%s_files_%s_tree_%s_revision(self):
241
 
        cached_make(self.make_parametrized_tree, %s, %s, %s)
 
208
        self.make_parametrized_tree(%s, %s, %s)
242
209
        self._time_read_write()
243
210
""" % (bundlefiles_h, treesize_h, num_revisions,
244
211
       treesize, num_revisions, bundlefiles)
245
 
                print code 
 
212
                print code
246
213