Significant performance improvements in the graphical rendering, as

well as the eradication of several bugs

Also, visualizer is now integrated into the main unit-trace command line tool
(use -v option)

Note that files are now taken in from the command line, no longer from the
GUI

1 files changed, 148 insertions, 88 deletions

diff --git a/unit_trace/viz/schedule.py b/unit_trace/viz/schedule.py
index 4277f1a..5efee7d 100644
--- a/unit_trace/viz/schedule.py
+++ b/unit_trace/viz/schedule.py
@@ -11,6 +11,7 @@ import util
 import copy
 
 EVENT_LIST = None
+SPAN_EVENTS = None
 
 class TimeSlotArray(object):
     """Represents another way of organizing the events. This structure organizes events by
@@ -55,20 +56,47 @@ class TimeSlotArray(object):
         
         self._put_event_in_slot(TimeSlotArray.TASK_LIST, task_no, event.__class__, time_slot, event)
         self._put_event_in_slot(TimeSlotArray.CPU_LIST, cpu, event.__class__, time_slot, event)
+        
+        if event.__class__ in SPAN_END_EVENTS:
+            self.fill_span_event_from_end(event)
+        
+    def fill_span_event_from_end(self, event):
+        start_slot = None
+        if event.corresp_start_event is None:
+            start_slot = self.get_time_slot(event.get_job().get_task().get_schedule().start) - 1
+        else:
+            start_slot = self.get_time_slot(event.corresp_start_event.get_time())
+        end_slot = self.get_time_slot(event.get_time())
+        
+        for slot in range(start_slot + 1, end_slot):
+            task_no = event.get_job().get_task().get_task_no()
+            cpu = event.get_cpu()
             
-        span_events = { SwitchAwayEvent : IsRunningDummy, InversionEndEvent : InversionDummy}
-        
-        for span_event in span_events:
-            if isinstance(event, span_event) and event.corresp_start_event is not None:
-                start_slot = self.get_time_slot(event.corresp_start_event.get_time())
-                end_slot = time_slot
-                for slot in range(start_slot + 1, end_slot):
-                    dummy = span_events[span_event](task_no, cpu)
-                    dummy.corresp_start_event = event.corresp_start_event
-                    dummy.corresp_end_event = event
+            dummy = SPAN_END_EVENTS[event.__class__](task_no, cpu)
+            dummy.corresp_start_event = event.corresp_start_event
+            dummy.corresp_end_event = event
                     
-                    self._put_event_in_slot(TimeSlotArray.TASK_LIST, task_no, dummy.__class__, slot, dummy)
-                    self._put_event_in_slot(TimeSlotArray.CPU_LIST, cpu, dummy.__class__, slot, dummy)
+            self._put_event_in_slot(TimeSlotArray.TASK_LIST, task_no, dummy.__class__, slot, dummy)
+            self._put_event_in_slot(TimeSlotArray.CPU_LIST, cpu, dummy.__class__, slot, dummy)
+            
+    def fill_span_event_from_start(self, event):
+        end_slot = None
+        if event.corresp_end_event is None:
+            end_slot = self.get_time_slot(event.get_job().get_task().get_schedule().end) + 1
+        else:
+            end_slot = self.get_time_slot(event.corresp_end_event.get_time())
+        start_slot = self.get_time_slot(event.get_time())
+        
+        for slot in range(start_slot + 1, end_slot):
+            task_no = event.get_job().get_task().get_task_no()
+            cpu = event.get_cpu()
+            
+            dummy = SPAN_START_EVENTS[event.__class__](task_no, cpu)
+            dummy.corresp_start_event = event
+            dummy.corresp_end_event = event.corresp_end_event
+            
+            self._put_event_in_slot(TimeSlotArray.TASK_LIST, task_no, dummy.__class__, slot, dummy)
+            self._put_event_in_slot(TimeSlotArray.CPU_LIST, cpu, dummy.__class__, slot, dummy)
             
     def iter_over_period(self, start, end, start_no, end_no, list_type, event_types):
         if self.array is None:
@@ -142,18 +170,28 @@ class Schedule(object):
         self.set_time_params(time_per_maj)
         
         # we scan the graph task by task, and job by job
-        switches = {}
-        for event in EVENT_LIST:
-            switches[event] = None
         for task_no, task in enumerate(self.get_task_list()):
+            switches = {}
+            for event in EVENT_LIST:
+                switches[event] = None
             cur_cpu = [Event.NO_CPU]
             for job_no in sorted(task.get_jobs().keys()):
                 job = task.get_jobs()[job_no]    
                 for event_time in sorted(job.get_events().keys()):
                     # could have multiple events at the same time (unlikely but possible)
                     for event in job.get_events()[event_time]:
-                        #print 'task, job, event:', task.name, job.job_no, event.__class__.__name__
+                        print 'task, job, event:', task.name, job.job_no, event.__class__.__name__
                         event.scan(cur_cpu, switches)
+                        
+            # What if one of the initial "span events" (switch to or inversion starting) never got a
+            # corresponding end event? Well, then we assume that the end event was simply outside of
+            # the range of whatever we read in. So we need to fill dummies starting from the initial
+            # event all the way to the end of the graph, so that the renderer can see the event no matter
+            # how far the user scrolls to the right.
+            for span_event in SPAN_START_EVENTS:
+                event = switches[span_event]
+                if event is not None:
+                    self.time_slot_array.fill_span_event_from_start(event)
         
     def add_task(self, task):
         if task.name in self.tasks:
@@ -311,7 +349,7 @@ class Event(DummyEvent):
             sched.start = time
         if sched.end is None or time > sched.end:
             sched.end = time
-            
+        
         sched.get_time_slot_array().add_event_to_time_slot(self)
 
 class ErrorEvent(Event):
@@ -387,11 +425,59 @@ class CompleteEvent(Event):
             else:
                 graph.draw_completion_marker_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                                  self.get_cpu(), self.is_selected())
+
+class SwitchToEvent(Event):
+    def __init__(self, time, cpu):
+        super(SwitchToEvent, self).__init__(time, cpu)
+        self.layer = Canvas.BOTTOM_LAYER
+        self.corresp_end_event = None
+        
+    def __str__(self):
+        if self.corresp_end_event is None:
+            return 'Switch To (w/o Switch Away)' + self._common_str() + ', TIME=' \
+                   + str(self.get_time())
+        return 'Scheduled' + self._common_str() + ', START=' \
+               + util.format_float(self.get_time(), Event.NUM_DEC_PLACES) \
+               + ', END=' + util.format_float(self.corresp_end_event.get_time(), Event.NUM_DEC_PLACES)
+        
+    def scan(self, cur_cpu, switches):
+        old_cur_cpu = cur_cpu[0]
+        cur_cpu[0] = self.get_cpu()
+        switches[SwitchToEvent] = self
+        self.corresp_end_event = None
         
+        if old_cur_cpu != Event.NO_CPU:
+            self.erroneous = True
+            print "currently scheduled somewhere, can't switch to a CPU"
+                            
+        super(SwitchToEvent, self).scan(cur_cpu, switches)
+    
+    def render(self, graph, layer, prev_events, selectable=False):
+        if layer == self.layer:
+            end_time = None
+            clip = None
+            if self.corresp_end_event is None:
+                end_time = self.get_job().get_task().get_schedule().end
+                clip = AlignMode.RIGHT
+            else:
+                end_time = self.corresp_end_event.get_time()
+            
+            prev_events[self] = None
+            cpu = self.get_cpu()
+            task_no = self.get_job().get_task().get_task_no()
+            if selectable:
+                graph.add_sel_bar_at_time(self.get_time(), end_time,
+                                     task_no, cpu, self)
+            else:
+                graph.draw_bar_at_time(self.get_time(), end_time,
+                                   task_no, cpu, self.get_job().get_job_no(),
+                                   clip, self.is_selected())
+                                           
 class SwitchAwayEvent(Event):
     def __init__(self, time, cpu):
         super(SwitchAwayEvent, self).__init__(time, cpu)
         self.layer = Canvas.BOTTOM_LAYER
+        self.corresp_start_event = None
     
     def __str__(self):
         if self.corresp_start_event is None:
@@ -431,63 +517,19 @@ class SwitchAwayEvent(Event):
                 prev_events[self] = None
                 cpu = self.get_cpu()
                 task_no = self.get_job().get_task().get_task_no()
+                start = self.get_job().get_task().get_schedule().start
                 if selectable:
-                    start = self.get_job().get_task().get_schedule().start
                     graph.add_sel_bar_at_time(start, self.get_time(),
                                      task_no, cpu, self)
                 else:
                     graph.draw_bar_at_time(start, self.get_time(),
-                                   task_no, cpu, self.get_job().get_job_no(), self.is_selected())
+                                   task_no, cpu, self.get_job().get_job_no(),
+                                   AlignMode.LEFT, self.is_selected())
         else:
             if self.corresp_start_event in prev_events:
                 return # already rendered the bar
             self.corresp_start_event.render(graph, layer, prev_events, selectable)
         
-class SwitchToEvent(Event):
-    def __init__(self, time, cpu):
-        super(SwitchToEvent, self).__init__(time, cpu)
-        self.layer = Canvas.BOTTOM_LAYER
-        
-    def __str__(self):
-        if self.corresp_end_event is None:
-            return 'Switch To (w/o Switch Away)' + self._common_str() + ', TIME=' \
-                   + str(self.get_time())
-        return 'Scheduled' + self._common_str() + ', START=' \
-               + util.format_float(self.get_time(), Event.NUM_DEC_PLACES) \
-               + ', END=' + util.format_float(self.corresp_end_event.get_time(), Event.NUM_DEC_PLACES)
-        
-    def scan(self, cur_cpu, switches):
-        old_cur_cpu = cur_cpu[0]
-        cur_cpu[0] = self.get_cpu()
-        switches[SwitchToEvent] = self
-        self.corresp_end_event = None
-        
-        if old_cur_cpu != Event.NO_CPU:
-            self.erroneous = True
-            print "currently scheduled somewhere, can't switch to a CPU"
-                            
-        super(SwitchToEvent, self).scan(cur_cpu, switches)
-    
-    def render(self, graph, layer, prev_events, selectable=False):
-        if self.corresp_end_event is None:
-            return # fatally erroneous switch to
-        if layer == self.layer:
-            end_time = None
-            if self.corresp_end_event is None:
-                end_time = self.get_job().get_task().get_schedule().end
-            else:
-                end_time = self.corresp_end_event.get_time()
-            
-            prev_events[self] = None
-            cpu = self.get_cpu()
-            task_no = self.get_job().get_task().get_task_no()
-            if selectable:
-                graph.add_sel_bar_at_time(self.get_time(), end_time,
-                                     task_no, cpu, self)
-            else:
-                graph.draw_bar_at_time(self.get_time(), end_time,
-                                   task_no, cpu, self.get_job().get_job_no(), self.is_selected())
-        
 class ReleaseEvent(Event):
     def __init__(self, time, cpu):
         super(ReleaseEvent, self).__init__(time, cpu)
@@ -536,6 +578,7 @@ class InversionStartEvent(ErrorEvent):
     def __init__(self, time):
         super(InversionStartEvent, self).__init__(time, Event.NO_CPU)
         self.layer = Canvas.BOTTOM_LAYER
+        self.corresp_end_event = None
     
     def __str__(self):
         if self.corresp_end_event is None:
@@ -553,28 +596,33 @@ class InversionStartEvent(ErrorEvent):
         super(InversionStartEvent, self).scan(cur_cpu, switches)
     
     def render(self, graph, layer, prev_events, selectable=False):
-        end_time = None
-        if self.corresp_end_event is None:
-            end_time = self.get_job().get_task().get_schedule().end
-        else:
-            end_time = self.corresp_end_event.get_time()
-            
         if layer == self.layer:
-            prev_events[self] = None
-            cpu = self.get_cpu()
-            task_no = self.get_job().get_task().get_task_no()
-            if selectable:
-                graph.add_sel_mini_bar_at_time(self.get_time(), end_time,
-                                     task_no, cpu, self)
+            end_time = None
+            clip = None
+            if self.corresp_end_event is None:
+                end_time = self.get_job().get_task().get_schedule().end
+                clip = AlignMode.RIGHT
             else:
-                graph.draw_mini_bar_at_time(self.get_time(), end_time,
-                                   task_no, cpu, self.get_job().get_job_no(), self.is_selected())
+                end_time = self.corresp_end_event.get_time()
+            
+            if layer == self.layer:
+                prev_events[self] = None
+                cpu = self.get_cpu()
+                task_no = self.get_job().get_task().get_task_no()
+                if selectable:
+                    graph.add_sel_mini_bar_at_time(self.get_time(), end_time,
+                                     task_no, cpu, self)
+                else:
+                    graph.draw_mini_bar_at_time(self.get_time(), end_time,
+                                     task_no, cpu, self.get_job().get_job_no(),
+                                     clip, self.is_selected())
             
 
 class InversionEndEvent(ErrorEvent):
     def __init__(self, time):
         super(InversionEndEvent, self).__init__(time, Event.NO_CPU)
         self.layer = Canvas.BOTTOM_LAYER
+        self.corresp_start_event = None
     
     def __str__(self):
         if self.corresp_start_event is None:
@@ -607,13 +655,14 @@ class InversionEndEvent(ErrorEvent):
                 prev_events[self] = None
                 cpu = self.get_cpu()
                 task_no = self.get_job().get_task().get_task_no()
+                start = self.get_job().get_task().get_schedule().start
                 if selectable:
-                    start = self.get_job().get_task().get_schedule().start
                     graph.add_sel_mini_bar_at_time(start, self.get_time(),
                                      task_no, cpu, self)
                 else:
                     graph.draw_mini_bar_at_time(start, self.get_time(),
-                                   task_no, cpu, self.get_job().get_job_no(), self.is_selected())
+                                   task_no, cpu, self.get_job().get_job_no(),
+                                   AlignMode.LEFT, self.is_selected())
         else:
             if self.corresp_start_event in prev_events:
                 return # already rendered the bar
@@ -625,11 +674,14 @@ class InversionDummy(DummyEvent):
         self.layer = Canvas.BOTTOM_LAYER
         
     def render(self, graph, layer, prev_events, selectable=False):
-        if self.corresp_start_event is not None and self.corresp_start_event in prev_events:
-            return # we have already been rendered
-        if self.corresp_end_event is not None and self.corresp_end_event in prev_events:
-            return
-        self.corresp_start_event.render(graph, layer, prev_events, selectable)
+        if self.corresp_start_event is None:
+            if self.corresp_end_event in prev_events:
+                return # we have already been rendered
+            self.corresp_end_event.render(graph, layer, prev_events, selectable)
+        else:    
+            if self.corresp_start_event in prev_events:
+                return # we have already been rendered
+            self.corresp_start_event.render(graph, layer, prev_events, selectable)
         
 class IsRunningDummy(DummyEvent):
     def __init__(self, time, cpu):
@@ -637,12 +689,20 @@ class IsRunningDummy(DummyEvent):
         self.layer = Canvas.BOTTOM_LAYER
         
     def render(self, graph, layer, prev_events, selectable=False):
-        if self.corresp_start_event is None or self.corresp_start_event in prev_events:
-            return # we have already been rendered
-        self.corresp_start_event.render(graph, layer, prev_events, selectable)
+        if self.corresp_start_event is None:
+            if self.corresp_end_event in prev_events:
+                return # we have already been rendered
+            self.corresp_end_event.render(graph, layer, prev_events, selectable)
+        else:
+            if self.corresp_start_event in prev_events:
+                return # we have already been rendered
+            self.corresp_start_event.render(graph, layer, prev_events, selectable)
 
 EVENT_LIST = {SuspendEvent : None, ResumeEvent : None, CompleteEvent : None,
               SwitchAwayEvent : None, SwitchToEvent : None, ReleaseEvent : None,
               DeadlineEvent : None, IsRunningDummy : None,
               InversionStartEvent : None, InversionEndEvent : None,
               InversionDummy : None}
+
+SPAN_START_EVENTS = { SwitchToEvent : IsRunningDummy, InversionStartEvent : InversionDummy }
+SPAN_END_EVENTS = { SwitchAwayEvent : IsRunningDummy, InversionEndEvent : InversionDummy}