/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-19 02:17:16 UTC
  • mto: (1908.3.21 usecases-benchmarks)
  • mto: This revision was merged to the branch mainline in revision 2068.
  • Revision ID: cfbolz@gmx.de-20060819021716-4a2cdd443e83721b
Refactor the bundle benchmarks to use the existing helper functions.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/benchmarks/bench_bundle.py
19
19
import shutil
20
20
from cStringIO import StringIO
21
21
 
 
22
from bzrlib.add import smart_add
 
23
from bzrlib import bzrdir
22
24
from bzrlib.benchmarks import Benchmark
23
25
from bzrlib.branch import Branch
24
26
from bzrlib.bundle import read_bundle
33
35
    """
34
36
   
35
37
    def make_kernel_like_tree_committed(self):
36
 
        self.make_kernel_like_tree_added()
 
38
        self.make_kernel_like_added_tree()
37
39
        self.run_bzr('commit', '-m', 'initial import')
38
40
 
39
41
    def test_create_bundle_known_kernel_like_tree(self):
40
42
        """Create a bundle for a kernel sized tree with no ignored, unknowns,
41
43
        or added and one commit.
42
44
        """ 
43
 
        self.make_kernel_like_tree_committed()
 
45
        self.make_kernel_like_committed_tree()
44
46
        self.time(self.run_bzr, 'bundle', '--revision', '..-1')
45
47
 
46
48
    def test_create_bundle_many_commit_tree (self):
70
72
 
71
73
class BundleLibraryLevelBenchmark(Benchmark):
72
74
 
73
 
    def make_parametrized_tree(self, num_files, num_revisions,
74
 
                               num_files_in_bundle):
75
 
        """Create a tree with given parameters. Always creates 2 levels of
76
 
        directories with the given number of files. Then the given number of
77
 
        revisions are created, changing some lines in one files in each
78
 
        revision. Only num_files_in_bundle files are changed in these
79
 
        revisions.
80
 
 
81
 
        :param num_files: number of files in tree
82
 
        :param num_revisions: number of revisions
83
 
        :param num_files_in_bundle: number of files changed in the revisions
84
 
        """
85
 
        directories = []
86
 
        files = []
87
 
        count = 0
88
 
        for outer in range(num_files // 64 + 1):
89
 
            directories.append("%s/" % outer)
90
 
            for middle in range(8):
91
 
                prefix = "%s/%s/" % (outer, middle)
92
 
                directories.append(prefix)
93
 
                for filename in range(min(8, num_files - count)):
94
 
                    count += 1
95
 
                    files.append(prefix + str(filename))
96
 
        self.run_bzr('init')
97
 
        self.build_tree(directories + files)
98
 
        for d in directories:
99
 
            self.run_bzr('add', d)
100
 
        self.run_bzr('commit', '-m', 'initial repo layout')
101
 
        # create revisions
102
 
        affected_files = files[:num_files_in_bundle]
103
 
        count = 0
104
 
        for changes_file in range(num_revisions // num_files_in_bundle + 1):
105
 
            for f in affected_files:
106
 
                count += 1
107
 
                if count >= num_revisions:
108
 
                    break
109
 
                content = "\n".join([str(i) for i in range(changes_file)] +
110
 
                                    [str(changes_file)] * 5) + "\n"
111
 
                self.build_tree_contents([(f, content)])
112
 
                self.run_bzr("commit", '-m', 'some changes')
113
 
        assert count >= num_revisions
114
 
 
115
75
    def _time_read_write(self):
116
 
        branch, relpath = Branch.open_containing(".")
 
76
        branch, relpath = Branch.open_containing("a")
117
77
        revision_history = branch.revision_history()
118
78
        bundle_text = StringIO()
119
79
        self.time(write_bundle, branch.repository, revision_history[-1],
122
82
        self.time(read_bundle, bundle_text)
123
83
 
124
84
    def test_few_files_small_tree_1_revision(self):
125
 
        self.make_parametrized_tree(5, 1, 5)
 
85
        os.mkdir("a")
 
86
        tree, files = self.create_with_commits(5, 1, directory_name="a")
 
87
        self.commit_some_revisions(tree, files[:5], 1, 1)
126
88
        self._time_read_write()
127
89
 
128
90
    def test_few_files_small_tree_500_revision(self):
129
 
        self.make_parametrized_tree(5, 500, 5)
 
91
        os.mkdir("a")
 
92
        tree, files = self.create_with_commits(5, 1, directory_name="a")
 
93
        self.commit_some_revisions(tree, files[:5], 500, 1)
130
94
        self._time_read_write()
131
95
 
132
96
    def test_few_files_small_tree_1000_revision(self):
133
 
        self.make_parametrized_tree(5, 1000, 5)
 
97
        os.mkdir("a")
 
98
        tree, files = self.create_with_commits(5, 1, directory_name="a")
 
99
        self.commit_some_revisions(tree, files[:5], 1000, 1)
134
100
        self._time_read_write()
135
101
 
136
102
    def test_few_files_moderate_tree_1_revision(self):
137
 
        self.make_parametrized_tree(100, 1, 5)
 
103
        os.mkdir("a")
 
104
        tree, files = self.create_with_commits(100, 1, directory_name="a")
 
105
        self.commit_some_revisions(tree, files[:5], 1, 1)
138
106
        self._time_read_write()
139
107
 
140
108
    def test_few_files_moderate_tree_500_revision(self):
141
 
        self.make_parametrized_tree(100, 500, 5)
 
109
        os.mkdir("a")
 
110
        tree, files = self.create_with_commits(100, 1, directory_name="a")
 
111
        self.commit_some_revisions(tree, files[:5], 500, 1)
142
112
        self._time_read_write()
143
113
 
144
114
    def test_few_files_moderate_tree_1000_revision(self):
145
 
        self.make_parametrized_tree(100, 1000, 5)
 
115
        os.mkdir("a")
 
116
        tree, files = self.create_with_commits(100, 1, directory_name="a")
 
117
        self.commit_some_revisions(tree, files[:5], 1000, 1)
146
118
        self._time_read_write()
147
119
 
148
120
    def test_some_files_moderate_tree_1_revision(self):
149
 
        self.make_parametrized_tree(100, 1, 100)
 
121
        os.mkdir("a")
 
122
        tree, files = self.create_with_commits(100, 1, directory_name="a")
 
123
        self.commit_some_revisions(tree, files[:100], 1, 1)
150
124
        self._time_read_write()
151
125
 
152
126
    def test_some_files_moderate_tree_500_revision(self):
153
 
        self.make_parametrized_tree(100, 500, 100)
 
127
        os.mkdir("a")
 
128
        tree, files = self.create_with_commits(100, 1, directory_name="a")
 
129
        self.commit_some_revisions(tree, files[:100], 500, 1)
154
130
        self._time_read_write()
155
131
 
156
132
    def test_some_files_moderate_tree_1000_revision(self):
157
 
        self.make_parametrized_tree(100, 1000, 100)
 
133
        os.mkdir("a")
 
134
        tree, files = self.create_with_commits(100, 1, directory_name="a")
 
135
        self.commit_some_revisions(tree, files[:100], 1000, 1)
158
136
        self._time_read_write()
159
137
 
160
138
    def test_few_files_big_tree_1_revision(self):
161
 
        self.make_parametrized_tree(1000, 1, 5)
 
139
        os.mkdir("a")
 
140
        tree, files = self.create_with_commits(1000, 1, directory_name="a")
 
141
        self.commit_some_revisions(tree, files[:5], 1, 1)
162
142
        self._time_read_write()
163
143
 
164
144
    def test_few_files_big_tree_500_revision(self):
165
 
        self.make_parametrized_tree(1000, 500, 5)
 
145
        os.mkdir("a")
 
146
        tree, files = self.create_with_commits(1000, 1, directory_name="a")
 
147
        self.commit_some_revisions(tree, files[:5], 500, 1)
166
148
        self._time_read_write()
167
149
 
168
150
    def test_few_files_big_tree_1000_revision(self):
169
 
        self.make_parametrized_tree(1000, 1000, 5)
 
151
        os.mkdir("a")
 
152
        tree, files = self.create_with_commits(1000, 1, directory_name="a")
 
153
        self.commit_some_revisions(tree, files[:5], 1000, 1)
170
154
        self._time_read_write()
171
155
 
172
156
    def test_some_files_big_tree_1_revision(self):
173
 
        self.make_parametrized_tree(1000, 1, 100)
 
157
        os.mkdir("a")
 
158
        tree, files = self.create_with_commits(1000, 1, directory_name="a")
 
159
        self.commit_some_revisions(tree, files[:100], 1, 1)
174
160
        self._time_read_write()
175
161
 
176
162
    def test_some_files_big_tree_500_revision(self):
177
 
        self.make_parametrized_tree(1000, 500, 100)
 
163
        os.mkdir("a")
 
164
        tree, files = self.create_with_commits(1000, 1, directory_name="a")
 
165
        self.commit_some_revisions(tree, files[:100], 500, 1)
178
166
        self._time_read_write()
179
167
 
180
168
    def test_some_files_big_tree_1000_revision(self):
181
 
        self.make_parametrized_tree(1000, 1000, 100)
 
169
        os.mkdir("a")
 
170
        tree, files = self.create_with_commits(1000, 1, directory_name="a")
 
171
        self.commit_some_revisions(tree, files[:100], 1000, 1)
182
172
        self._time_read_write()
183
173
 
184
174
    def test_many_files_big_tree_1_revision(self):
185
 
        self.make_parametrized_tree(1000, 1, 1000)
 
175
        os.mkdir("a")
 
176
        tree, files = self.create_with_commits(1000, 1, directory_name="a")
 
177
        self.commit_some_revisions(tree, files[:1000], 1, 1)
186
178
        self._time_read_write()
187
179
 
188
180
    def test_many_files_big_tree_500_revision(self):
189
 
        self.make_parametrized_tree(1000, 500, 1000)
 
181
        os.mkdir("a")
 
182
        tree, files = self.create_with_commits(1000, 1, directory_name="a")
 
183
        self.commit_some_revisions(tree, files[:1000], 500, 1)
190
184
        self._time_read_write()
191
185
 
192
186
    def test_many_files_big_tree_1000_revision(self):
193
 
        self.make_parametrized_tree(1000, 1000, 1000)
 
187
        os.mkdir("a")
 
188
        tree, files = self.create_with_commits(1000, 1, directory_name="a")
 
189
        self.commit_some_revisions(tree, files[:1000], 1000, 1)
194
190
        self._time_read_write()
195
191
 
196
192
 
205
201
            for num_revisions in [1, 500, 1000]:
206
202
                code = """\
207
203
    def test_%s_files_%s_tree_%s_revision(self):
208
 
        self.make_parametrized_tree(%s, %s, %s)
 
204
        os.mkdir("a")
 
205
        tree, files = self.create_with_commits(%s, 1, directory_name="a")
 
206
        self.commit_some_revisions(tree, files[:%s], %s, 1)
209
207
        self._time_read_write()
210
208
""" % (bundlefiles_h, treesize_h, num_revisions,
211
 
       treesize, num_revisions, bundlefiles)
 
209
       treesize, bundlefiles, num_revisions)
212
210
                print code
213
211
 
 
212