bin/sympy_time_cache.py

   1 import time, timeit
   2
   3 class TreeNode(object):
   4      def __init__(self, name):
   5           self._name = name
   6           self._children = []
   7           self._time = 0
   8
   9      def __str__(self):
  10           return "%s: %s"%(self._name, self._time)
  11
  12      __repr__ = __str__
  13
  14      def add_child(self, node):
  15           self._children.append(node)
  16
  17      def children(self):
  18           return self._children
  19
  20      def child(self, i):
  21           return self.children()[i]
  22
  23      def set_time(self, time):
  24           self._time = time
  25
  26      def time(self):
  27           return self._time
  28
  29      total_time = time
  30
  31      def exclusive_time(self):
  32           return self.total_time() - sum(child.time() for child in self.children())
  33
  34      def name(self):
  35           return self._name
  36
  37      def linearize(self):
  38           res = [self]
  39           for child in self.children():
  40                res.extend(child.linearize())
  41           return res
  42
  43      def print_tree(self, level=0, max_depth=None):
  44           print "  "*level + str(self)
  45           if max_depth is not None and max_depth <= level:
  46                return
  47           for child in self.children():
  48                child.print_tree(level+1, max_depth=max_depth)
  49
  50      def print_generic(self, n=50, method="time"):
  51           slowest = sorted((getattr(node, method)(), node.name()) for node in self.linearize())[-n:]
  52           for time, name in slowest[::-1]:
  53                print "%s %s"%(time, name)
  54
  55      def print_slowest(self, n=50):
  56           self.print_generic(n=50, method="time")
  57
  58      def print_slowest_exclusive(self, n=50):
  59           self.print_generic(n, method="exclusive_time")
  60
  61      def write_cachegrind(self, f):
  62           if isinstance(f, str):
  63                f = open(f, "w")
  64                f.write("events: Microseconds\n")
  65                f.write("fl=sympyallimport\n")
  66                must_close = True
  67           else:
  68                must_close = False
  69
  70           f.write("fn=%s\n"%self.name())
  71           f.write("1 %s\n"%self.exclusive_time())
  72
  73           counter = 2
  74           for child in self.children():
  75                f.write("cfn=%s\n"%child.name())
  76                f.write("calls=1 1\n")
  77                f.write("%s %s\n"%(counter, child.time()))
  78                counter += 1
  79
  80           f.write("\n\n")
  81
  82           for child in self.children():
  83                child.write_cachegrind(f)
  84
  85           if must_close:
  86                f.close()
  87
  88
  89 pp = TreeNode(None)  #We have to use pp since there is a sage function
  90                      #called parent that gets imported
  91 seen = set()
  92
  93 def new_import(name, globals={}, locals={}, fromlist=[]):
  94      global pp
  95      if name in seen:
  96          return old_import(name, globals, locals, fromlist)
  97      seen.add(name)
  98
  99      node = TreeNode(name)
 100
 101      pp.add_child(node)
 102      old_pp = pp
 103      pp = node
 104
 105      #Do the actual import
 106      t1 = timeit.default_timer()
 107      module = old_import(name, globals, locals, fromlist)
 108      t2 = timeit.default_timer()
 109      node.set_time(int(1000000*(t2-t1)))
 110
 111
 112      pp = old_pp
 113
 114      return module
 115
 116 old_import = __builtins__.__import__
 117
 118 __builtins__.__import__ = new_import
 119 old_sum = sum
 120
 121 from sympy import *
 122
 123 sum = old_sum
 124
 125 sageall = pp.child(0)
 126 sageall.write_cachegrind("sympy.cachegrind")
 127
 128 print "Timings saved. Do:\n$ kcachegrind sympy.cachegrind"