“Télécharger analyser_dxp.py” Réponses codées

Télécharger analyser_dxp.py

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\n" % (count, ops)
  129     return ''.join(seq())