Fixed some graphical glitches, along with streamlining the access to the visualizer.

1 files changed, 72 insertions, 17 deletions

diff --git a/unit_trace/viz/schedule.py b/unit_trace/viz/schedule.py
index ce062a3..4277f1a 100644
--- a/unit_trace/viz/schedule.py
+++ b/unit_trace/viz/schedule.py
@@ -65,6 +65,7 @@ class TimeSlotArray(object):
                 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
                     
                     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)
@@ -151,7 +152,7 @@ class Schedule(object):
                 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)
         
     def add_task(self, task):
@@ -395,7 +396,7 @@ class SwitchAwayEvent(Event):
     def __str__(self):
         if self.corresp_start_event is None:
             return 'Switch Away (w/o Switch To)' + self._common_str() + 'TIME=' \
-                   + self.get_time()
+                   + str(self.get_time())
         return str(self.corresp_start_event)
             
     def scan(self, cur_cpu, switches):
@@ -422,9 +423,25 @@ class SwitchAwayEvent(Event):
         super(SwitchAwayEvent, self).scan(cur_cpu, switches)
             
     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 # erroneous switch away or already rendered
-        self.corresp_start_event.render(graph, layer, prev_events, selectable)
+        if self.corresp_start_event is None:
+            # We never found a corresponding start event. In that case, we can assume it lies
+            # in some part of the trace that was never read in. So draw a bar starting from
+            # the very beginning.
+            if layer == self.layer:
+                prev_events[self] = None
+                cpu = self.get_cpu()
+                task_no = self.get_job().get_task().get_task_no()
+                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())
+        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):
@@ -434,7 +451,7 @@ class SwitchToEvent(Event):
     def __str__(self):
         if self.corresp_end_event is None:
             return 'Switch To (w/o Switch Away)' + self._common_str() + ', TIME=' \
-                   + self.get_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)
@@ -454,15 +471,21 @@ class SwitchToEvent(Event):
     def render(self, graph, layer, prev_events, selectable=False):
         if self.corresp_end_event is None:
             return # fatally erroneous switch to
-        if layer == Canvas.BOTTOM_LAYER:
+        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(), self.corresp_end_event.get_time(),
+                graph.add_sel_bar_at_time(self.get_time(), end_time,
                                      task_no, cpu, self)
             else:
-                graph.draw_bar_at_time(self.get_time(), self.corresp_end_event.get_time(),
+                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):
@@ -530,15 +553,21 @@ class InversionStartEvent(ErrorEvent):
         super(InversionStartEvent, self).scan(cur_cpu, switches)
     
     def render(self, graph, layer, prev_events, selectable=False):
-        if layer == Canvas.BOTTOM_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()
+            
+        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(), self.corresp_end_event.get_time(),
+                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(), self.corresp_end_event.get_time(),
+                graph.draw_mini_bar_at_time(self.get_time(), end_time,
                                    task_no, cpu, self.get_job().get_job_no(), self.is_selected())
             
 
@@ -570,19 +599,45 @@ class InversionEndEvent(ErrorEvent):
         super(InversionEndEvent, self).scan(cur_cpu, switches)
         
     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 # erroneous inversion end or already rendered
-        self.corresp_start_event.render(graph, layer, prev_events, selectable)
+        if self.corresp_start_event is None:
+            # We never found a corresponding start event. In that case, we can assume it lies
+            # in some part of the trace that was never read in. So draw a bar starting from
+            # the very beginning.
+            if layer == self.layer:
+                prev_events[self] = None
+                cpu = self.get_cpu()
+                task_no = self.get_job().get_task().get_task_no()
+                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())
+        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 InversionDummy(DummyEvent):
+    def __init__(self, time, cpu):
+        super(InversionDummy, self).__init__(time, Event.NO_CPU)
+        self.layer = Canvas.BOTTOM_LAYER
+        
     def render(self, graph, layer, prev_events, selectable=False):
-        if self.corresp_start_event in prev_events:
+        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)
         
 class IsRunningDummy(DummyEvent):
+    def __init__(self, time, cpu):
+        super(IsRunningDummy, self).__init__(time, Event.NO_CPU)
+        self.layer = Canvas.BOTTOM_LAYER
+        
     def render(self, graph, layer, prev_events, selectable=False):
-        if self.corresp_start_event in prev_events:
+        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)