1 """
2 Some helper functions to analyze the output of sys.getdxp() (which is
3 only available if Python was built with -DDYNAMIC_EXECUTION_PROFILE).
4 These will tell you which opcodes have been executed most frequently
5 in the current process, and, if Python was also built with -DDXPAIRS,
6 will tell you which instruction _pairs_ were executed most frequently,
7 which may help in choosing new instructions.
8
9 If Python was built without -DDYNAMIC_EXECUTION_PROFILE, importing
10 this module will raise a RuntimeError.
11
12 If you're running a script you want to profile, a simple way to get
13 the common pairs is:
14
15 $ PYTHONPATH=$PYTHONPATH:<python_srcdir>/Tools/scripts
16 ./python -i -O the_script.py --args
17 ...
18 > from analyze_dxp import *
19 > s = render_common_pairs()
20 > open('/tmp/some_file', 'w').write(s)
21 """
22
23 import copy
24 import opcode
25 import operator
26 import sys
27 import threading
28
29 if not hasattr(sys, "getdxp"):
30 raise RuntimeError("Can't import analyze_dxp: Python built without"
31 " -DDYNAMIC_EXECUTION_PROFILE.")
32
33
34 _profile_lock = threading.RLock()
35 _cumulative_profile = sys.getdxp()
36
37 # If Python was built with -DDXPAIRS, sys.getdxp() returns a list of
38 # lists of ints. Otherwise it returns just a list of ints.
39 def has_pairs(profile):
40 """Returns True if the Python that produced the argument profile
41 was built with -DDXPAIRS."""
42
43 return len(profile) > 0 and isinstance(profile[0], list)
44
45
46 def reset_profile():
47 """Forgets any execution profile that has been gathered so far."""
48 with _profile_lock:
49 sys.getdxp() # Resets the internal profile
50 global _cumulative_profile
51 _cumulative_profile = sys.getdxp() # 0s out our copy.
52
53
54 def merge_profile():
55 """Reads sys.getdxp() and merges it into this module's cached copy.
56
57 We need this because sys.getdxp() 0s itself every time it's called."""
58
59 with _profile_lock:
60 new_profile = sys.getdxp()
61 if has_pairs(new_profile):
62 for first_inst in range(len(_cumulative_profile)):
63 for second_inst in range(len(_cumulative_profile[first_inst])):
64 _cumulative_profile[first_inst][second_inst] += (
65 new_profile[first_inst][second_inst])
66 else:
67 for inst in range(len(_cumulative_profile)):
68 _cumulative_profile[inst] += new_profile[inst]
69
70
71 def snapshot_profile():
72 """Returns the cumulative execution profile until this call."""
73 with _profile_lock:
74 merge_profile()
75 return copy.deepcopy(_cumulative_profile)
76
77
78 def common_instructions(profile):
79 """Returns the most common opcodes in order of descending frequency.
80
81 The result is a list of tuples of the form
82 (opcode, opname, # of occurrences)
83
84 """
85 if has_pairs(profile) and profile:
86 inst_list = profile[-1]
87 else:
88 inst_list = profile
89 result = [(op, opcode.opname[op], count)
90 for op, count in enumerate(inst_list)
91 if count > 0]
92 result.sort(key=operator.itemgetter(2), reverse=True)
93 return result
94
95
96 def common_pairs(profile):
97 """Returns the most common opcode pairs in order of descending frequency.
98
99 The result is a list of tuples of the form
100 ((1st opcode, 2nd opcode),
101 (1st opname, 2nd opname),
102 # of occurrences of the pair)
103
104 """
105 if not has_pairs(profile):
106 return []
107 result = [((op1, op2), (opcode.opname[op1], opcode.opname[op2]), count)
108 # Drop the row of single-op profiles with [:-1]
109 for op1, op1profile in enumerate(profile[:-1])
110 for op2, count in enumerate(op1profile)
111 if count > 0]
112 result.sort(key=operator.itemgetter(2), reverse=True)
113 return result
114
115
116 def render_common_pairs(profile=None):
117 """Renders the most common opcode pairs to a string in order of
118 descending frequency.
119
120 The result is a series of lines of the form:
121 # of occurrences: ('1st opname', '2nd opname')
122
123 """
124 if profile is None:
125 profile = snapshot_profile()
126 def seq():
127 for _, ops, count in common_pairs(profile):
128 yield "%s: %s
" % (count, ops)
129 return ''.join(seq())