/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

Merge bundle benchmarks and resolve conflict. 

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
import os
 
20
import shutil
 
21
from StringIO import StringIO
 
22
 
18
23
from bzrlib.benchmarks import Benchmark
19
 
 
 
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 
 
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)
20
59
 
21
60
class BundleBenchmark(Benchmark):
22
61
    """
23
62
    The bundle tests should (also) be done at a lower level with
24
63
    direct call to the bzrlib."""
25
 
    
 
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
 
26
70
    def test_create_bundle_known_kernel_like_tree(self):
27
71
        """
28
72
        Create a bundle for a kernel sized tree with no ignored, unknowns,
29
73
        or added and one commit.""" 
30
 
        self.make_kernel_like_tree()
31
 
        self.run_bzr('add')
32
 
        self.run_bzr('commit', '-m', 'initial import')
 
74
        cached_make(self.make_kernel_like_tree_committed)
33
75
        self.time(self.run_bzr, 'bundle', '--revision', '..-1')
34
76
 
35
77
    def test_create_bundle_many_commit_tree (self):
36
78
        """
37
79
        Create a bundle for a tree with many commits but no changes.""" 
38
 
        self.make_many_commit_tree()
 
80
        cached_make(self.make_many_commit_tree)
39
81
        self.time(self.run_bzr, 'bundle', '--revision', '..-1')
40
82
 
41
83
    def test_create_bundle_heavily_merged_tree(self):
42
84
        """
43
85
        Create a bundle for a heavily merged tree.""" 
44
 
        self.make_heavily_merged_tree()
 
86
        cached_make(self.make_heavily_merged_tree)
45
87
        self.time(self.run_bzr, 'bundle', '--revision', '..-1')
46
 
 
 
88
        
47
89
    def test_apply_bundle_known_kernel_like_tree(self):
48
90
        """
49
91
        Create a bundle for a kernel sized tree with no ignored, unknowns,
50
92
        or added and one commit.""" 
51
 
        self.make_kernel_like_tree()
52
 
        self.run_bzr('add')
53
 
        self.run_bzr('commit', '-m', 'initial import')
54
 
        self.run_bzr('branch', '.', '../branch_a')
55
 
        self.run_bzr('bundle', '--revision', '..-1')
 
93
        cached_make(self.make_kernel_like_tree_committed)
56
94
        f = file('../bundle', 'wb')
57
95
        try:
58
96
            f.write(self.run_bzr('bundle', '--revision', '..-1')[0])
59
97
        finally:
60
98
            f.close()
 
99
        self.run_bzr("init", "../branch_a")
61
100
        os.chdir('../branch_a')
62
101
        self.time(self.run_bzr, 'merge', '../bundle')
 
102
 
63
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
 
 
149
    for treesize, treesize_h in [(5, "small"), (100, "moderate"),
 
150
                                 (1000, "big")]:
 
151
        for bundlefiles, bundlefiles_h in [(5, "few"), (100, "some"),
 
152
                                           (1000, "many")]:
 
153
            if bundlefiles > treesize:
 
154
                continue
 
155
            for num_revisions in [1, 500, 1000]:
 
156
                code = """
 
157
def test_%s_files_%s_tree_%s_revision(self):
 
158
    cached_make(self.make_parametrized_tree, %s, %s, %s)
 
159
    branch, _ = Branch.open_containing(".")
 
160
    revision_history = branch.revision_history()
 
161
    bundle_text = StringIO()
 
162
    self.time(write_bundle, branch.repository, revision_history[-1],
 
163
              None, bundle_text)
 
164
    bundle_text.seek(0)
 
165
    self.time(read_bundle, bundle_text)""" % (
 
166
                    bundlefiles_h, treesize_h, num_revisions,
 
167
                    treesize, num_revisions, bundlefiles)
 
168
                exec code
 
169