← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/benchmarks/tree_creator/kernel_like.py

Merge up through 2.2.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/benchmarks/tree_creator/kernel_like.py
1
 
# Copyright (C) 2006 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 as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
"""Tree creators for kernel-like trees"""
18
 
 
19
 
import errno
20
 
import os
21
 
 
22
 
from bzrlib import (
23
 
    bzrdir,
24
 
    osutils,
25
 
    workingtree,
26
 
    xml5,
27
 
    )
28
 
 
29
 
from bzrlib.benchmarks.tree_creator import TreeCreator
30
 
 
31
 
 
32
 
class KernelLikeTreeCreator(TreeCreator):
33
 
    """Create a basic tree with ~10k unversioned files"""
34
 
 
35
 
    def __init__(self, test, link_working=False, url=None):
36
 
        super(KernelLikeTreeCreator, self).__init__(test,
37
 
            tree_name='kernel_like_tree',
38
 
            link_working=link_working,
39
 
            link_bzr=False)
40
 
 
41
 
        self._url = url
42
 
 
43
 
    def create(self, root):
44
 
        """Create all the kernel files in the given location.
45
 
 
46
 
        This is overloaded for compatibility reasons.
47
 
        """
48
 
        if self._url is not None:
49
 
            b = bzrdir.BzrDir.create_branch_convenience(self._url)
50
 
            d = bzrdir.BzrDir.create(root)
51
 
            bzrlib.branch.BranchReferenceFormat().initialize(d, b)
52
 
            tree = d.create_workingtree()
53
 
        else:
54
 
            tree = bzrdir.BzrDir.create_standalone_workingtree(root)
55
 
 
56
 
        if not self._link_working or not self.is_caching_enabled():
57
 
            # Turns out that 'shutil.copytree()' is no faster than
58
 
            # just creating them. Probably the python overhead.
59
 
            # Plain _make_kernel_files takes 3-5s
60
 
            # cp -a takes 3s
61
 
            # using hardlinks takes < 1s.
62
 
            self._create_tree(root=root, in_cache=False)
63
 
            return tree
64
 
 
65
 
        self.ensure_cached()
66
 
        cache_dir = self._get_cache_dir()
67
 
        osutils.copy_tree(cache_dir, root,
68
 
                          handlers={'file':os.link})
69
 
        return tree
70
 
 
71
 
    def _create_tree(self, root, in_cache=False):
72
 
        # a kernel tree has ~10000 and 500 directory, with most files around
73
 
        # 3-4 levels deep.
74
 
        # we simulate this by three levels of dirs named 0-7, givin 512 dirs,
75
 
        # and 20 files each.
76
 
        files = []
77
 
        for outer in range(8):
78
 
            files.append("%s/" % outer)
79
 
            for middle in range(8):
80
 
                files.append("%s/%s/" % (outer, middle))
81
 
                for inner in range(8):
82
 
                    prefix = "%s/%s/%s/" % (outer, middle, inner)
83
 
                    files.append(prefix)
84
 
                    files.extend([prefix + str(foo) for foo in range(20)])
85
 
        cwd = osutils.getcwd()
86
 
        try:
87
 
            os.mkdir(root)
88
 
        except OSError, e:
89
 
            if e.errno not in (errno.EEXIST,):
90
 
                raise
91
 
        os.chdir(root)
92
 
        self._test.build_tree(files)
93
 
        os.chdir(cwd)
94
 
        if in_cache:
95
 
            self._protect_files(root)
96
 
 
97
 
 
98
 
class KernelLikeAddedTreeCreator(TreeCreator):
99
 
    """Create a tree with ~10k versioned but not committed files"""
100
 
 
101
 
    def __init__(self, test, link_working=False, hot_cache=True):
102
 
        super(KernelLikeAddedTreeCreator, self).__init__(test,
103
 
            tree_name='kernel_like_added_tree',
104
 
            link_working=link_working,
105
 
            link_bzr=False,
106
 
            hot_cache=hot_cache)
107
 
 
108
 
    def _create_tree(self, root, in_cache=False):
109
 
        """Create a kernel-like tree with the all files added
110
 
 
111
 
        :param root: The root directory to create the files
112
 
        :param in_cache: Is this being created in the cache dir?
113
 
        """
114
 
        kernel_creator = KernelLikeTreeCreator(self._test,
115
 
                                               link_working=in_cache)
116
 
        tree = kernel_creator.create(root=root)
117
 
 
118
 
        # Add everything to it
119
 
        tree.lock_write()
120
 
        try:
121
 
            tree.smart_add([root], recurse=True, save=True)
122
 
            if in_cache:
123
 
                self._protect_files(root+'/.bzr')
124
 
        finally:
125
 
            tree.unlock()
126
 
        return tree
127
 
 
128
 
 
129
 
class KernelLikeCommittedTreeCreator(TreeCreator):
130
 
    """Create a tree with ~10K files, and a single commit adding all of them"""
131
 
 
132
 
    def __init__(self, test, link_working=False, link_bzr=False,
133
 
                 hot_cache=True):
134
 
        super(KernelLikeCommittedTreeCreator, self).__init__(test,
135
 
            tree_name='kernel_like_committed_tree',
136
 
            link_working=link_working,
137
 
            link_bzr=link_bzr,
138
 
            hot_cache=hot_cache)
139
 
 
140
 
    def _create_tree(self, root, in_cache=False):
141
 
        """Create a kernel-like tree with all files committed
142
 
 
143
 
        :param root: The root directory to create the files
144
 
        :param in_cache: Is this being created in the cache dir?
145
 
        """
146
 
        kernel_creator = KernelLikeAddedTreeCreator(self._test,
147
 
                                                    link_working=in_cache,
148
 
                                                    hot_cache=(not in_cache))
149
 
        tree = kernel_creator.create(root=root)
150
 
        tree.commit('first post', rev_id='r1')
151
 
 
152
 
        if in_cache:
153
 
            self._protect_files(root+'/.bzr')
154
 
        return tree
155
 
 
156
 
 
157
 
class KernelLikeInventoryCreator(TreeCreator):
158
 
    """Return just the memory representation of a committed kernel-like tree"""
159
 
 
160
 
    def __init__(self, test):
161
 
        super(KernelLikeInventoryCreator, self).__init__(test,
162
 
            tree_name='kernel_like_inventory',
163
 
            link_working=True,
164
 
            link_bzr=True,
165
 
            hot_cache=True)
166
 
 
167
 
    def ensure_cached(self):
168
 
        """Make sure we have a cached version of the kernel-like inventory"""
169
 
        cache_dir = self._get_cache_dir()
170
 
        if cache_dir is None:
171
 
            return
172
 
 
173
 
        if self.is_cached():
174
 
            return
175
 
 
176
 
        committed_creator = KernelLikeCommittedTreeCreator(self._test,
177
 
                                                           link_working=True,
178
 
                                                           link_bzr=True,
179
 
                                                           hot_cache=False)
180
 
        committed_creator.ensure_cached()
181
 
        committed_cache_dir = committed_creator._get_cache_dir()
182
 
        committed_tree = workingtree.WorkingTree.open(committed_cache_dir)
183
 
        rev_tree = committed_tree.basis_tree()
184
 
        os.mkdir(cache_dir)
185
 
        f = open(cache_dir+'/inventory', 'wb')
186
 
        try:
187
 
            xml5.serializer_v5.write_inventory(rev_tree.inventory, f)
188
 
        finally:
189
 
            f.close()
190
 
 
191
 
    def create(self, root=None):
192
 
        """Create a kernel like inventory
193
 
 
194
 
        :param root: Exists to mimic the base class, but this class
195
 
            returns only an in-memory Inventory, so it should always be None.
196
 
        :return: An Inventory object.
197
 
        """
198
 
        cache_dir = self._get_cache_dir()
199
 
        if cache_dir is None:
200
 
            return self._create_and_return()
201
 
 
202
 
        self.ensure_cached()
203
 
        return self._open_cached(cache_dir)
204
 
 
205
 
    def _create_and_return(self):
206
 
        """Create a kernel-like tree, and return its inventory"""
207
 
        creator = KernelLikeCommittedTreeCreator(self._test,
208
 
                                                 link_working=True,
209
 
                                                 link_bzr=True,
210
 
                                                 hot_cache=False)
211
 
        tree = creator.create('.')
212
 
        basis = tree.basis_tree()
213
 
        basis.lock_read()
214
 
        try:
215
 
            return basis.inventory
216
 
        finally:
217
 
            basis.unlock()
218
 
 
219
 
    def _open_cached(self, cache_dir):
220
 
        f = open(cache_dir + '/inventory', 'rb')
221
 
        try:
222
 
            return xml5.serializer_v5.read_inventory(f)
223
 
        finally:
224
 
            f.close()