/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: holger krekel
  • Date: 2006-08-12 15:56:40 UTC
  • mto: (1908.3.21 usecases-benchmarks)
  • mto: This revision was merged to the branch mainline in revision 2068.
  • Revision ID: hpk@merlinux.de-20060812155640-8306a30158d2c5fe
Explicitely generate test functions. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2006 by Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License version 2 as published by
 
5
# the Free Software Foundation.
 
6
#
 
7
# This program is distributed in the hope that it will be useful,
 
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
# GNU General Public License for more details.
 
11
#
 
12
# You should have received a copy of the GNU General Public License
 
13
# along with this program; if not, write to the Free Software
 
14
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
 
 
16
"""Tests for bzr bundle performance."""
 
17
 
 
18
 
 
19
import os
 
20
import shutil
 
21
from StringIO import StringIO
 
22
 
 
23
from bzrlib.benchmarks import Benchmark
 
24
from bzrlib.workingtree import WorkingTree
 
25
from bzrlib.branch import Branch
 
26
from bzrlib.bundle.serializer import write_bundle
 
27
from bzrlib.bundle import read_bundle
 
28
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)
 
59
 
 
60
class BundleBenchmark(Benchmark):
 
61
    """
 
62
    The bundle tests should (also) be done at a lower level with
 
63
    direct call to the bzrlib."""
 
64
   
 
65
    def make_kernel_like_tree_committed(self): 
 
66
        cached_make(self.make_kernel_like_tree)
 
67
        self.run_bzr('add')
 
68
        self.run_bzr('commit', '-m', 'initial import')
 
69
 
 
70
    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)
 
75
        self.time(self.run_bzr, 'bundle', '--revision', '..-1')
 
76
 
 
77
    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)
 
81
        self.time(self.run_bzr, 'bundle', '--revision', '..-1')
 
82
 
 
83
    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)
 
87
        self.time(self.run_bzr, 'bundle', '--revision', '..-1')
 
88
        
 
89
    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)
 
94
        f = file('../bundle', 'wb')
 
95
        try:
 
96
            f.write(self.run_bzr('bundle', '--revision', '..-1')[0])
 
97
        finally:
 
98
            f.close()
 
99
        self.run_bzr("init", "../branch_a")
 
100
        os.chdir('../branch_a')
 
101
        self.time(self.run_bzr, 'merge', '../bundle')
 
102
 
 
103
 
 
104
class BundleLibraryLevelBenchmark(Benchmark):
 
105
 
 
106
    def make_parametrized_tree(self, num_files, num_revisions,
 
107
                               num_files_in_bundle):
 
108
        """Create a tree with given parameters. Always creates 2 levels of
 
109
        directories with the given number of files. Then the given number of
 
110
        revisions are created, changing some lines in one files in each
 
111
        revision. Only num_files_in_bundle files are changed in these
 
112
        revisions.
 
113
 
 
114
        :param num_files: number of files in tree
 
115
        :param num_revisions: number of revisions
 
116
        :param num_files_in_bundle: number of files changed in the revisions
 
117
        """
 
118
        directories = []
 
119
        files = []
 
120
        count = 0
 
121
        for outer in range(num_files // 64 + 1):
 
122
            directories.append("%s/" % outer)
 
123
            for middle in range(8):
 
124
                prefix = "%s/%s/" % (outer, middle)
 
125
                directories.append(prefix)
 
126
                for filename in range(min(8, num_files - count)):
 
127
                    count += 1
 
128
                    files.append(prefix + str(filename))
 
129
        self.run_bzr('init')
 
130
        self.build_tree(directories + files)
 
131
        for d in directories:
 
132
            self.run_bzr('add', d)
 
133
        self.run_bzr('commit', '-m', 'initial repo layout')
 
134
        # create revisions
 
135
        affected_files = files[:num_files_in_bundle]
 
136
        count = 0
 
137
        for changes_file in range(num_revisions // num_files_in_bundle + 1):
 
138
            for f in affected_files:
 
139
                count += 1
 
140
                if count >= num_revisions:
 
141
                    break
 
142
                content = "\n".join([str(i) for i in range(changes_file)] +
 
143
                                    [str(changes_file)] * 5) + "\n"
 
144
                self.build_tree_contents([(f, content)])
 
145
                self.run_bzr("commit", '-m', 'some changes')
 
146
        assert count >= num_revisions
 
147
 
 
148
    def _time_read_write(self):
 
149
        branch, _ = Branch.open_containing(".")
 
150
        revision_history = branch.revision_history()
 
151
        bundle_text = StringIO()
 
152
        self.time(write_bundle, branch.repository, revision_history[-1],
 
153
                  None, bundle_text)
 
154
        bundle_text.seek(0)
 
155
        self.time(read_bundle, bundle_text)
 
156
 
 
157
    def test_few_files_small_tree_1_revision(self):
 
158
        cached_make(self.make_parametrized_tree, 5, 1, 5)
 
159
        self._time_read_write()
 
160
 
 
161
    def test_few_files_small_tree_500_revision(self):
 
162
        cached_make(self.make_parametrized_tree, 5, 500, 5)
 
163
        self._time_read_write()
 
164
 
 
165
    def test_few_files_small_tree_1000_revision(self):
 
166
        cached_make(self.make_parametrized_tree, 5, 1000, 5)
 
167
        self._time_read_write()
 
168
 
 
169
    def test_few_files_moderate_tree_1_revision(self):
 
170
        cached_make(self.make_parametrized_tree, 100, 1, 5)
 
171
        self._time_read_write()
 
172
 
 
173
    def test_few_files_moderate_tree_500_revision(self):
 
174
        cached_make(self.make_parametrized_tree, 100, 500, 5)
 
175
        self._time_read_write()
 
176
 
 
177
    def test_few_files_moderate_tree_1000_revision(self):
 
178
        cached_make(self.make_parametrized_tree, 100, 1000, 5)
 
179
        self._time_read_write()
 
180
 
 
181
    def test_some_files_moderate_tree_1_revision(self):
 
182
        cached_make(self.make_parametrized_tree, 100, 1, 100)
 
183
        self._time_read_write()
 
184
 
 
185
    def test_some_files_moderate_tree_500_revision(self):
 
186
        cached_make(self.make_parametrized_tree, 100, 500, 100)
 
187
        self._time_read_write()
 
188
 
 
189
    def test_some_files_moderate_tree_1000_revision(self):
 
190
        cached_make(self.make_parametrized_tree, 100, 1000, 100)
 
191
        self._time_read_write()
 
192
 
 
193
    def test_few_files_big_tree_1_revision(self):
 
194
        cached_make(self.make_parametrized_tree, 1000, 1, 5)
 
195
        self._time_read_write()
 
196
 
 
197
    def test_few_files_big_tree_500_revision(self):
 
198
        cached_make(self.make_parametrized_tree, 1000, 500, 5)
 
199
        self._time_read_write()
 
200
 
 
201
    def test_few_files_big_tree_1000_revision(self):
 
202
        cached_make(self.make_parametrized_tree, 1000, 1000, 5)
 
203
        self._time_read_write()
 
204
 
 
205
    def test_some_files_big_tree_1_revision(self):
 
206
        cached_make(self.make_parametrized_tree, 1000, 1, 100)
 
207
        self._time_read_write()
 
208
 
 
209
    def test_some_files_big_tree_500_revision(self):
 
210
        cached_make(self.make_parametrized_tree, 1000, 500, 100)
 
211
        self._time_read_write()
 
212
 
 
213
    def test_some_files_big_tree_1000_revision(self):
 
214
        cached_make(self.make_parametrized_tree, 1000, 1000, 100)
 
215
        self._time_read_write()
 
216
 
 
217
    def test_many_files_big_tree_1_revision(self):
 
218
        cached_make(self.make_parametrized_tree, 1000, 1, 1000)
 
219
        self._time_read_write()
 
220
 
 
221
    def test_many_files_big_tree_500_revision(self):
 
222
        cached_make(self.make_parametrized_tree, 1000, 500, 1000)
 
223
        self._time_read_write()
 
224
 
 
225
    def test_many_files_big_tree_1000_revision(self):
 
226
        cached_make(self.make_parametrized_tree, 1000, 1000, 1000)
 
227
        self._time_read_write()
 
228
 
 
229
 
 
230
if __name__ == '__main__':
 
231
    # USE the following if you want to regenerate the above test functions 
 
232
    for treesize, treesize_h in [(5, "small"), (100, "moderate"),
 
233
                                 (1000, "big")]:
 
234
        for bundlefiles, bundlefiles_h in [(5, "few"), (100, "some"),
 
235
                                           (1000, "many")]:
 
236
            if bundlefiles > treesize:
 
237
                continue
 
238
            for num_revisions in [1, 500, 1000]:
 
239
                code = """\
 
240
    def test_%s_files_%s_tree_%s_revision(self):
 
241
        cached_make(self.make_parametrized_tree, %s, %s, %s)
 
242
        self._time_read_write()
 
243
""" % (bundlefiles_h, treesize_h, num_revisions,
 
244
       treesize, num_revisions, bundlefiles)
 
245
                print code 
 
246