~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lsprof.py

• browse files at revision 5017.3.7
• compare with another revision
• download diff
• download tarball
• view history from revision 5017.3.7

• reverse the comparison (5017.3.7 to 2052.6.2)
• stop comparing with revision 2052.6.2

Show diffs side-by-side

added

removed

bzrlib/lsprof.py

10

10

import threading

11

11

from _lsprof import Profiler, profiler_entry

12

12

 

 

13

 

13

14

__all__ = ['profile', 'Stats']

14

15

 

15

 

_g_threadmap = {}

16

 

 

17

 

 

18

 

def _thread_profile(f, *args, **kwds):

19

 

    # we lose the first profile point for a new thread in order to trampoline

20

 

    # a new Profile object into place

21

 

    global _g_threadmap

22

 

    thr = thread.get_ident()

23

 

    _g_threadmap[thr] = p = Profiler()

24

 

    # this overrides our sys.setprofile hook:

25

 

    p.enable(subcalls=True, builtins=True)

26

 

 

27

 

 

28

16

def profile(f, *args, **kwds):

29

 

    """XXX docstring"""

30

 

    global _g_threadmap

31

 

    p = Profiler()

32

 

    p.enable(subcalls=True)

33

 

    threading.setprofile(_thread_profile)

 

17

    """Run a function profile.

 

18

 

 

19

    Exceptions are not caught: If you need stats even when exceptions are to be

 

20

    raised, pass in a closure that will catch the exceptions and transform them

 

21

    appropriately for your driver function.

 

22

 

 

23

    :return: The functions return value and a stats object.

 

24

    """

 

25

    profiler = BzrProfiler()

 

26

    profiler.start()

34

27

    try:

35

28

        ret = f(*args, **kwds)

36

29

    finally:

37

 

        p.disable()

38

 

        for pp in _g_threadmap.values():

 

30

        stats = profiler.stop()

 

31

    return ret, stats

 

32

 

 

33

 

 

34

class BzrProfiler(object):

 

35

    """Bzr utility wrapper around Profiler.

 

36

    

 

37

    For most uses the module level 'profile()' function will be suitable.

 

38

    However profiling when a simple wrapped function isn't available may

 

39

    be easier to accomplish using this class.

 

40

 

 

41

    To use it, create a BzrProfiler and call start() on it. Some arbitrary

 

42

    time later call stop() to stop profiling and retrieve the statistics

 

43

    from the code executed in the interim.

 

44

    """

 

45

 

 

46

    def start(self):

 

47

        """Start profiling.

 

48

        

 

49

        This hooks into threading and will record all calls made until

 

50

        stop() is called.

 

51

        """

 

52

        self._g_threadmap = {}

 

53

        self.p = Profiler()

 

54

        self.p.enable(subcalls=True)

 

55

        threading.setprofile(self._thread_profile)

 

56

 

 

57

    def stop(self):

 

58

        """Stop profiling.

 

59

 

 

60

        This unhooks from threading and cleans up the profiler, returning

 

61

        the gathered Stats object.

 

62

 

 

63

        :return: A bzrlib.lsprof.Stats object.

 

64

        """

 

65

        self.p.disable()

 

66

        for pp in self._g_threadmap.values():

39

67

            pp.disable()

40

68

        threading.setprofile(None)

41

 

    

42

 

    threads = {}

43

 

    for tid, pp in _g_threadmap.items():

44

 

        threads[tid] = Stats(pp.getstats(), {})

45

 

    _g_threadmap = {}

46

 

    return ret, Stats(p.getstats(), threads)

 

69

        p = self.p

 

70

        self.p = None

 

71

        threads = {}

 

72

        for tid, pp in self._g_threadmap.items():

 

73

            threads[tid] = Stats(pp.getstats(), {})

 

74

        self._g_threadmap = None

 

75

        return Stats(p.getstats(), threads)

 

76

 

 

77

    def _thread_profile(self, f, *args, **kwds):

 

78

        # we lose the first profile point for a new thread in order to

 

79

        # trampoline a new Profile object into place

 

80

        thr = thread.get_ident()

 

81

        self._g_threadmap[thr] = p = Profiler()

 

82

        # this overrides our sys.setprofile hook:

 

83

        p.enable(subcalls=True, builtins=True)

47

84

 

48

85

 

49

86

class Stats(object):

113

150

        :param format: 'txt' for a text representation;

114

151

            'callgrind' for calltree format;

115

152

            otherwise a pickled Python object. A format of None indicates

116

 

            that the format to use is to be found from the extension of

117

 

            filename.

 

153

            that the format to use is to be found from the filename. If

 

154

            the name starts with callgrind.out, callgrind format is used

 

155

            otherwise the format is given by the filename extension.

118

156

        """

119

157

        if format is None:

120

 

            ext = os.path.splitext(filename)[1]

121

 

            if len(ext) > 1:

122

 

                format = ext[1:]

 

158

            basename = os.path.basename(filename)

 

159

            if basename.startswith('callgrind.out'):

 

160

                format = "callgrind"

 

161

            else:

 

162

                ext = os.path.splitext(filename)[1]

 

163

                if len(ext) > 1:

 

164

                    format = ext[1:]

123

165

        outfile = open(filename, 'wb')

124

166

        try:

125

167

            if format == "callgrind":

138

180

 

139

181

    This code is taken from http://ddaa.net/blog/python/lsprof-calltree

140

182

    with the changes made by J.P. Calderone and Itamar applied. Note that

141

 

    isinstance(code, str) needs to be used at times to determine if the code 

 

183

    isinstance(code, str) needs to be used at times to determine if the code

142

184

    object is actually an external code object (with a filename, etc.) or

143

185

    a Python built-in.

144

186

    """

148

190

        self.out_file = None

149

191

 

150

192

    def output(self, out_file):

151

 

        self.out_file = out_file        

152

 

        print >> out_file, 'events: Ticks'

 

193

        self.out_file = out_file

 

194

        out_file.write('events: Ticks\n')

153

195

        self._print_summary()

154

196

        for entry in self.data:

155

197

            self._entry(entry)

159

201

        for entry in self.data:

160

202

            totaltime = int(entry.totaltime * 1000)

161

203

            max_cost = max(max_cost, totaltime)

162

 

        print >> self.out_file, 'summary: %d' % (max_cost,)

 

204

        self.out_file.write('summary: %d\n' % (max_cost,))

163

205

 

164

206

    def _entry(self, entry):

165

207

        out_file = self.out_file

166

208

        code = entry.code

167

209

        inlinetime = int(entry.inlinetime * 1000)

168

 

        #print >> out_file, 'ob=%s' % (code.co_filename,)

169

 

        if isinstance(code, str):

170

 

            print >> out_file, 'fi=~'

171

 

        else:

172

 

            print >> out_file, 'fi=%s' % (code.co_filename,)

173

 

        print >> out_file, 'fn=%s' % (label(code, True),)

174

 

        if isinstance(code, str):

175

 

            print >> out_file, '0 ', inlinetime

176

 

        else:

177

 

            print >> out_file, '%d %d' % (code.co_firstlineno, inlinetime)

 

210

        #out_file.write('ob=%s\n' % (code.co_filename,))

 

211

        if isinstance(code, str):

 

212

            out_file.write('fi=~\n')

 

213

        else:

 

214

            out_file.write('fi=%s\n' % (code.co_filename,))

 

215

        out_file.write('fn=%s\n' % (label(code, True),))

 

216

        if isinstance(code, str):

 

217

            out_file.write('0  %s\n' % (inlinetime,))

 

218

        else:

 

219

            out_file.write('%d %d\n' % (code.co_firstlineno, inlinetime))

178

220

        # recursive calls are counted in entry.calls

179

221

        if entry.calls:

180

222

            calls = entry.calls

186

228

            lineno = code.co_firstlineno

187

229

        for subentry in calls:

188

230

            self._subentry(lineno, subentry)

189

 

        print >> out_file

 

231

        out_file.write('\n')

190

232

 

191

233

    def _subentry(self, lineno, subentry):

192

234

        out_file = self.out_file

193

235

        code = subentry.code

194

236

        totaltime = int(subentry.totaltime * 1000)

195

 

        #print >> out_file, 'cob=%s' % (code.co_filename,)

196

 

        print >> out_file, 'cfn=%s' % (label(code, True),)

 

237

        #out_file.write('cob=%s\n' % (code.co_filename,))

 

238

        out_file.write('cfn=%s\n' % (label(code, True),))

197

239

        if isinstance(code, str):

198

 

            print >> out_file, 'cfi=~'

199

 

            print >> out_file, 'calls=%d 0' % (subentry.callcount,)

 

240

            out_file.write('cfi=~\n')

 

241

            out_file.write('calls=%d 0\n' % (subentry.callcount,))

200

242

        else:

201

 

            print >> out_file, 'cfi=%s' % (code.co_filename,)

202

 

            print >> out_file, 'calls=%d %d' % (

203

 

                subentry.callcount, code.co_firstlineno)

204

 

        print >> out_file, '%d %d' % (lineno, totaltime)

 

243

            out_file.write('cfi=%s\n' % (code.co_filename,))

 

244

            out_file.write('calls=%d %d\n' % (

 

245

                subentry.callcount, code.co_firstlineno))

 

246

        out_file.write('%d %d\n' % (lineno, totaltime))

205

247

 

206

248

_fn2mod = {}

207

249

 

233

275

    import os

234

276

    sys.argv = sys.argv[1:]

235

277

    if not sys.argv:

236

 

        print >> sys.stderr, "usage: lsprof.py <script> <arguments...>"

 

278

        sys.stderr.write("usage: lsprof.py <script> <arguments...>\n")

237

279

        sys.exit(2)

238

280

    sys.path.insert(0, os.path.abspath(os.path.dirname(sys.argv[0])))

239

281

    stats = profile(execfile, sys.argv[0], globals(), locals())

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1