first pass at cumulative display mode

Philip Guo · Philip Guo · commit bc4e8ae18f66 · 2012-08-15T09:02:34.000-07:00
diff --git a/PyTutorGAE/pg_logger.py b/PyTutorGAE/pg_logger.py
@@ -78,7 +78,7 @@ def filter_var_dict(d):
 
 class PGLogger(bdb.Bdb):
 
-    def __init__(self, finalizer_func):
+    def __init__(self, finalizer_func, cumulative_display=False):
         bdb.Bdb.__init__(self)
         self.mainpyfile = ''
         self._wait_for_mainpyfile = 0
@@ -87,6 +87,12 @@ def __init__(self, finalizer_func):
         # processes it
         self.finalizer_func = finalizer_func
 
+        # if True, then displays ALL stack frames that have ever existed
+        # rather than only those currently on the stack (and their
+        # lexical parents)
+        self.cumulative_display = cumulative_display
+        self.cumulative_display = True
+
         # each entry contains a dict with the information for a single
         # executed line
         self.trace = []
@@ -98,10 +104,16 @@ def __init__(self, finalizer_func):
         # Value: parent frame
         self.closures = {}
 
-        # List of frames to KEEP AROUND after the function exits
-        # because nested functions were defined within those frames.
-        # (ORDER matters for aesthetics)
-        self.zombie_parent_frames = []
+        # Key: id() of frame object
+        # Value: monotonically increasing small ID, based on call order
+        self.frame_ordered_ids = {}
+        self.cur_frame_id = 1
+
+        # List of frames to KEEP AROUND after the function exits.
+        # If cumulative_display is True, then keep ALL frames in
+        # zombie_frames; otherwise keep only frames where
+        # nested functions were defined within them.
+        self.zombie_frames = []
 
         # all globals that ever appeared in the program, in the order in
         # which they appeared. note that this might be a superset of all
@@ -116,6 +128,10 @@ def __init__(self, finalizer_func):
         self.executed_script = None # Python script to be executed!
 
 
+    def get_frame_id(self, cur_frame):
+      return self.frame_ordered_ids[id(cur_frame)]
+
+
     # Returns the (lexical) parent frame of the function that was called
     # to create the stack frame 'frame'.
     #
@@ -148,19 +164,12 @@ def get_parent_frame(self, frame):
       return None
 
 
-    def get_zombie_parent_frame_id(self, f):
-      # should be None unless this is a zombie frame
-      try:
-        # make the frame id's one-indexed for clarity
-        # (and to prevent possible confusion with None)
-        return self.zombie_parent_frames.index(f) + 1
-      except ValueError:
-        pass
-      return None
-
-    def lookup_zombie_frame_by_id(self, idx):
-      # remember this is one-indexed
-      return self.zombie_parent_frames[idx - 1]
+    def lookup_zombie_frame_by_id(self, frame_id):
+      # TODO: kinda inefficient
+      for e in self.zombie_frames:
+        if self.get_frame_id(e) == frame_id:
+          return e
+      assert False # should never get here
 
 
     # unused ...
@@ -227,10 +236,19 @@ def interaction(self, frame, traceback, event_type):
         self.encoder.reset_heap() # VERY VERY VERY IMPORTANT,
                                   # or else we won't properly capture heap object mutations in the trace!
 
+        if event_type == 'call':
+          tfid = id(top_frame)
+          assert tfid not in self.frame_ordered_ids
+          self.frame_ordered_ids[tfid] = self.cur_frame_id
+          self.cur_frame_id += 1
+
+          if self.cumulative_display:
+            self.zombie_frames.append(top_frame)
+
 
         # only render zombie frames that are NO LONGER on the stack
         cur_stack_frames = [e[0] for e in self.stack]
-        zombie_frames_to_render = [e for e in self.zombie_parent_frames if e not in cur_stack_frames]
+        zombie_frames_to_render = [e for e in self.zombie_frames if e not in cur_stack_frames]
 
 
         # each element is a pair of (function name, ENCODED locals dict)
@@ -242,15 +260,13 @@ def create_encoded_stack_entry(cur_frame):
           ret = {}
 
 
-          # your immediate parent frame ID is parent_frame_id_list[0]
-          # and all other members are your further ancestors
           parent_frame_id_list = []
 
           f = cur_frame
           while True:
             p = self.get_parent_frame(f)
             if p:
-              pid = self.get_zombie_parent_frame_id(p)
+              pid = self.get_frame_id(p)
               assert pid
               parent_frame_id_list.append(pid)
               f = p
@@ -299,7 +315,7 @@ def create_encoded_stack_entry(cur_frame):
             if type(v) in (types.FunctionType, types.MethodType):
               try:
                 enclosing_frame = self.closures[v]
-                enclosing_frame_id = self.get_zombie_parent_frame_id(enclosing_frame)
+                enclosing_frame_id = self.get_frame_id(enclosing_frame)
                 self.encoder.set_function_parent_frame_ID(encoded_val, enclosing_frame_id)
               except KeyError:
                 pass
@@ -340,7 +356,8 @@ def create_encoded_stack_entry(cur_frame):
             assert e in encoded_locals
 
           return dict(func_name=cur_name,
-                      frame_id=self.get_zombie_parent_frame_id(cur_frame),
+                      frame_id=self.get_frame_id(cur_frame),
+                      # TODO: fixme
                       parent_frame_id_list=parent_frame_id_list,
                       encoded_locals=encoded_locals,
                       ordered_varnames=ordered_varnames)
@@ -355,8 +372,8 @@ def create_encoded_stack_entry(cur_frame):
             if (type(v) in (types.FunctionType, types.MethodType) and \
                 v not in self.closures):
               self.closures[v] = top_frame
-              if not top_frame in self.zombie_parent_frames:
-                self.zombie_parent_frames.append(top_frame)
+              if not top_frame in self.zombie_frames:
+                self.zombie_frames.append(top_frame)
 
 
         # climb up until you find '<module>', which is (hopefully) the global scope
@@ -382,7 +399,7 @@ def create_encoded_stack_entry(cur_frame):
           if type(v) in (types.FunctionType, types.MethodType):
             try:
               enclosing_frame = self.closures[v]
-              enclosing_frame_id = self.get_zombie_parent_frame_id(enclosing_frame)
+              enclosing_frame_id = self.get_frame_id(enclosing_frame)
               self.encoder.set_function_parent_frame_ID(encoded_val, enclosing_frame_id)
             except KeyError:
               pass
@@ -402,40 +419,38 @@ def create_encoded_stack_entry(cur_frame):
         # making it look aesthetically pretty
         stack_to_render = [];
 
-        # first push all regular stack entries BACKWARDS
+        # first push all regular stack entries
         if encoded_stack_locals:
-          stack_to_render = encoded_stack_locals[::-1]
-          for e in stack_to_render:
+          for e in encoded_stack_locals:
             e['is_zombie'] = False
             e['is_highlighted'] = False
+            stack_to_render.append(e)
 
-          stack_to_render[-1]['is_highlighted'] = True
+          # highlight the top-most active stack entry
+          stack_to_render[0]['is_highlighted'] = True
 
 
-        # zombie_encoded_stack_locals consists of exited functions that have returned
-        # nested functions. Push zombie stack entries at the BEGINNING of stack_to_render,
-        # EXCEPT put zombie entries BEHIND regular entries that are their parents
-        for e in zombie_encoded_stack_locals[::-1]:
+        # now push all zombie stack entries
+        for e in zombie_encoded_stack_locals:
           # don't display return value for zombie frames
+          # TODO: reconsider ...
+          '''
           try:
             e['ordered_varnames'].remove('__return__')
           except ValueError:
             pass
+          '''
 
           e['is_zombie'] = True
           e['is_highlighted'] = False # never highlight zombie entries
 
-          # j should be 0 most of the time, so we're always inserting new
-          # elements to the front of stack_to_render (which is why we are
-          # iterating backwards over zombie_stack_locals).
-          j = 0
-          while j < len(stack_to_render):
-            if stack_to_render[j]['frame_id'] in e['parent_frame_id_list']:
-              j += 1
-              continue
-            break
+          stack_to_render.append(e)
+
+        # now sort by frame_id since that sorts frames in "chronological
+        # order" based on the order they were invoked
+        stack_to_render.sort(key=lambda e: e['frame_id'])
+
 
-          stack_to_render.insert(j, e)
 
         # create a unique hash for this stack entry, so that the
         # frontend can uniquely identify it when doing incremental
@@ -445,8 +460,7 @@ def create_encoded_stack_entry(cur_frame):
         # disambiguating recursion!)
         for (stack_index, e) in enumerate(stack_to_render):
           hash_str = e['func_name']
-          if e['frame_id']:
-            hash_str += '_f' + str(e['frame_id'])
+          hash_str += '_f' + str(e['frame_id'])
           if e['parent_frame_id_list']:
             hash_str += '_p' + '_'.join([str(i) for i in e['parent_frame_id_list']])
           if e['is_zombie']:
