Updated the documentation to describe the visualizer, made unit-trace itself not require gtk/cairo, and a few other minor things.

1 files changed, 217 insertions, 149 deletions

diff --git a/unit_trace/viz/schedule.py b/unit_trace/viz/schedule.py
index 81269fa..a44ce8d 100644
--- a/unit_trace/viz/schedule.py
+++ b/unit_trace/viz/schedule.py
@@ -18,19 +18,19 @@ class TimeSlotArray(object):
     the (approximate) time at which they occur. Events that occur at approximately the same
     time are assigned the same ``slot'', and each slot organizes its events by task number
     as well as by CPU."""
-    
+
     TASK_LIST = 0
     CPU_LIST = 1
-    
+
     def __init__(self, time_per_maj=None, num_tasks=0, num_cpus=0):
         if time_per_maj is None:
             self.array = None
             return
-            
+
         self.time_per_maj = time_per_maj
         self.list_sizes = { TimeSlotArray.TASK_LIST : num_tasks, TimeSlotArray.CPU_LIST : num_cpus }
         self.array = {}
-        
+
         for type in self.list_sizes:
             num = self.list_sizes[type]
             self.array[type] = []
@@ -40,26 +40,26 @@ class TimeSlotArray(object):
                 # by task).
                 self.array[type].append(dict(zip(EVENT_LIST, \
                                 [{} for j in range(0, len(EVENT_LIST))])))
-    
+
     def get_time_slot(self, time):
         return int(time // self.time_per_maj)
-    
+
     def _put_event_in_slot(self, list_type, no, klass, slot, event):
         if slot not in self.array[list_type][no][klass]:
             self.array[list_type][no][klass][slot] = []
         self.array[list_type][no][klass][slot].append(event)
-                
+
     def add_event_to_time_slot(self, event):
         task_no = event.get_job().get_task().get_task_no()
         cpu = event.get_cpu()
         time_slot = self.get_time_slot(event.get_time())
-        
+
         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:
@@ -67,18 +67,18 @@ class TimeSlotArray(object):
         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()
-            
+
             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)
-            
+
     def fill_span_event_from_start(self, event):
         end_slot = None
         if event.corresp_end_event is None:
@@ -86,18 +86,18 @@ class TimeSlotArray(object):
         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 get_events(self, slots, list_type, event_types):
         for type in event_types:
             for slot in slots:
@@ -105,31 +105,31 @@ class TimeSlotArray(object):
                     if slot in self.array[list_type][no][type]:
                         for event in self.array[list_type][no][type][slot]:
                             yield event
-        
+
     def get_slots(self, slots, start, end, start_no, end_no, list_type):
         if self.array is None:
             return # empty schedule
-            
+
         if start > end:
             raise ValueError('Litmus is not a time machine')
         if start_no > end_no:
             raise ValueError('start no should be less than end no')
-            
+
         start_slot = self.get_time_slot(start)
         end_slot = self.get_time_slot(end) + 1
         start_no = max(0, start_no)
         end_no = min(self.list_sizes[list_type] - 1, end_no)
-        
+
         for slot in xrange(start_slot, end_slot + 1):
             if slot not in slots:
                 slots[slot] = {}
             for no in xrange(start_no, end_no + 1):
                 slots[slot][no] = None
-    
+
 class Schedule(object):
     """The total schedule (task system), consisting of a certain number of
     tasks."""
-    
+
     def __init__(self, name, num_cpus, task_list=[]):
         self.name = name
         self.tasks = {}
@@ -140,13 +140,13 @@ class Schedule(object):
         self.num_cpus = num_cpus
         for task in task_list:
             self.add_task(task)
-    
+
     def get_selected(self):
         return self.selected
-        
+
     def set_selected(self, selected):
         self.selected = selected
-    
+
     def add_selected(self, selected):
         for layer in selected:
             if layer not in self.selected:
@@ -156,35 +156,35 @@ class Schedule(object):
                     self.selected[layer][event] = {}
                 for graph in selected[layer][event]:
                     self.selected[layer][event][graph] = selected[layer][event][graph]
-            
+
     def remove_selected(self, selected):
         for layer in selected:
             if layer in self.selected:
                 for event in selected[layer]:
                     if event in self.selected[layer]:
                         del self.selected[layer][event]
-        
+
     def set_time_params(self, time_per_maj=None):
         self.time_per_maj = time_per_maj
         if self.time_per_maj is None:
             self.time_slot_array = TimeSlotArray()
             return
-            
+
         self.time_slot_array = TimeSlotArray(self.time_per_maj, \
                                                  len(self.task_list), self.num_cpus)
-            
+
     def get_time_slot_array(self):
         return self.time_slot_array
-    
+
     def get_time_bounds(self):
         return (self.start, self.end)
-        
+
     def scan(self, time_per_maj):
         self.start = None
         self.end = None
-        
+
         self.set_time_params(time_per_maj)
-        
+
         # we scan the graph task by task, and job by job
         for task_no, task in enumerate(self.get_task_list()):
             switches = {}
@@ -192,12 +192,12 @@ class Schedule(object):
                 switches[event] = None
             cur_cpu = [Event.NO_CPU]
             for job_no in sorted(task.get_jobs().keys()):
-                job = task.get_jobs()[job_no]    
+                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]:
                         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
@@ -207,7 +207,7 @@ class Schedule(object):
                 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:
             raise ValueError("task already in list!")
@@ -216,29 +216,29 @@ class Schedule(object):
         task.schedule = self
         task.task_no = self.cur_task_no
         self.cur_task_no += 1
-    
+
     def get_tasks(self):
         return self.tasks
-        
+
     def get_task_list(self):
         return self.task_list
-    
+
     def get_name(self):
         return self.name
-    
+
     def get_num_cpus(self):
         return self.num_cpus
 
 def deepcopy_selected(selected):
     selected_copy = {}
     for layer in selected:
-        selected_copy[layer] = copy.copy(selected[layer])  
+        selected_copy[layer] = copy.copy(selected[layer])
     return selected_copy
-                   
+
 class Task(object):
     """Represents a task, including the set of jobs that were run under
     this task."""
-    
+
     def __init__(self, name, job_list=[]):
         self.name = name
         self.jobs = {}
@@ -246,25 +246,25 @@ class Task(object):
         self.schedule = None
         for job in job_list:
             self.add_job(job)
-        
+
     def add_job(self, job):
         if job.job_no in self.jobs:
             raise ScheduleError("a job is already being released at this time for this task")
         self.jobs[job.job_no] = job
         job.task = self
-    
+
     def get_schedule(self):
         return self.schedule
-        
+
     def get_jobs(self):
         return self.jobs
-    
+
     def get_task_no(self):
         return self.task_no
-        
+
     def get_name(self):
         return self.name
-            
+
 class Job(object):
     """Represents a job, including everything that happens related to the job"""
     def __init__(self, job_no, event_list=[]):
@@ -273,19 +273,19 @@ class Job(object):
         self.task = None
         for event in event_list:
             self.add_event(event)
-        
+
     def add_event(self, event):
         if event.time not in self.events:
             self.events[event.time] = []
         self.events[event.time].append(event)
         event.job = self
-    
+
     def get_events(self):
         return self.events
-    
+
     def get_task(self):
         return self.task
-    
+
     def get_job_no(self):
         return self.job_no
 
@@ -301,61 +301,73 @@ class DummyEvent(object):
         self.cpu = cpu
         self.job = None
         self.layer = None
-    
+
     def __str__(self):
         return '[Dummy Event]'
-            
+
     def get_time(self):
         return self.time
-        
+
     def get_cpu(self):
         return self.cpu
-        
+
     def get_job(self):
         return self.job
-    
+
     def get_layer(self):
         return self.layer
-        
+
     def render(self, graph, layer, prev_events, selectable=False):
         """Method that the visualizer calls to tell the event to render itself
         Obviously only implemented by subclasses (actual event types)
-        
+
         ``Rendering'' can mean either actually drawing the event or just
         adding it as a selectable region. This is controlled by the
         ``selectable'' parameter"""
         raise NotImplementdError
-        
+
 class Event(DummyEvent):
     """Represents an event that occurs while a job is running (e.g. get scheduled
     on a CPU, block, ...)"""
     NO_CPU = -1
     NUM_DEC_PLACES = 2
-    
+
     def __init__(self, time, cpu):
         super(Event, self).__init__(time, cpu)
         self.erroneous = False
-    
+
+    def get_name(self):
+        raise NotImplementedError
+
     def __str__(self):
-        return '[Event]'
-    
+        return self.get_name() + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
+
+    def str_long(self):
+        """Prints the event as a string, in ``long'' form."""
+        return 'Event Type: ' + self.get_name() + \
+                '\nTask Name: ' + str(self.get_job().get_task().get_name()) + \
+                '\n(Task no., Job no.): ' + str((self.get_job().get_task().get_task_no(), \
+                                                self.get_job().get_job_no())) + \
+                '\nCPU: ' + str(self.get_cpu()) + \
+                '\nTime: ' + str(self.get_time())
+
     def _common_str(self):
         job = self.get_job()
         task = job.get_task()
         return ' for task ' + str(task.get_name()) + ': (TASK, JOB)=' + str((task.get_task_no(), \
             job.get_job_no())) + ', CPU=' + str(self.get_cpu())
-            
+
     def is_erroneous(self):
         """An erroneous event is where something with the event is not quite right,
         something significantly wrong that we don't have logical information telling
         us how we should render the event."""
         return self.erroneous
-    
+
     def is_selected(self):
         """Returns whether the event has been selected by the user. (needed for rendering)"""
         selected = self.get_job().get_task().get_schedule().get_selected()
         return self.get_layer() in selected and self in selected[self.get_layer()]
-            
+
     def scan(self, cur_cpu, switches):
         """Part of the procedure that walks through all the events and sets
         some parameters that are unknown at first. For instance, a SwitchAwayEvent
@@ -370,26 +382,26 @@ 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):
     pass
-                
+
 class SuspendEvent(Event):
     def __init__(self, time, cpu):
         super(SuspendEvent, self).__init__(time, cpu)
         self.layer = Canvas.MIDDLE_LAYER
-    
-    def __str__(self):
-        return 'Suspend' + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-            
+
+    def get_name(self):
+        return 'Suspend'
+
     def scan(self, cur_cpu, switches):
         if self.get_cpu() != cur_cpu[0]:
             self.erroneous = True
             #fprint "suspending on a CPU different from the CPU we are on!"
         super(SuspendEvent, self).scan(cur_cpu, switches)
-            
+
     def render(self, graph, layer, prev_events, selectable=False):
         if layer == self.layer:
             prev_events[self] = None
@@ -399,22 +411,22 @@ class SuspendEvent(Event):
             else:
                 graph.draw_suspend_triangle_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                                 self.get_cpu(), self.is_selected())
-            
-        
+
+
 class ResumeEvent(Event):
     def __init__(self, time, cpu):
         super(ResumeEvent, self).__init__(time, cpu)
         self.layer = Canvas.MIDDLE_LAYER
-    
-    def __str__(self):
-        return 'Resume' + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-            
+
+    def get_name(self):
+        return 'Resume'
+
     def scan(self, cur_cpu, switches):
         if cur_cpu[0] != Event.NO_CPU and cur_cpu[0] != self.get_cpu():
             self.erroneous = True
             #print "Resuming when currently scheduled on a CPU, but on a different CPU from the current CPU!"
         super(ResumeEvent, self).scan(cur_cpu, switches)
-        
+
     def render(self, graph, layer, prev_events, selectable=False):
         if layer == self.layer:
             prev_events[self] = None
@@ -424,19 +436,19 @@ class ResumeEvent(Event):
             else:
                 graph.draw_resume_triangle_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                                self.get_cpu(), self.is_selected())
-                
-        
+
+
 class CompleteEvent(Event):
     def __init__(self, time, cpu):
         super(CompleteEvent, self).__init__(time, cpu)
         self.layer = Canvas.TOP_LAYER
-    
-    def __str__(self):
-        return 'Complete' + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-            
+
+    def get_name(self):
+        return 'Complete'
+
     def scan(self, cur_cpu, switches):
         super(CompleteEvent, self).scan(cur_cpu, switches)
-    
+
     def render(self, graph, layer, prev_events, selectable=False):
         if layer == Canvas.TOP_LAYER:
             prev_events[self] = None
@@ -452,27 +464,44 @@ class SwitchToEvent(Event):
         super(SwitchToEvent, self).__init__(time, cpu)
         self.layer = Canvas.BOTTOM_LAYER
         self.corresp_end_event = None
-        
+
+    def get_name(self):
+        if self.corresp_end_event is None:
+            return 'Switch To (w/o Switch Away)'
+        else:
+            return 'Scheduled'
+
     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=' \
+            return super(SwitchToEvent, self).__str__()
+        return self.get_name() + 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 str_long(self):
+        if self.corresp_end_event is None:
+            return super(SwitchToEvent, self).str_long()
+        else :
+            return 'Event Type: ' + self.get_name() + \
+                '\nTask Name: ' + str(self.get_job().get_task().get_name()) + \
+                '\n(Task no., Job no.): ' + str((self.get_job().get_task().get_task_no(), \
+                                                self.get_job().get_job_no())) + \
+                '\nCPU: ' + str(self.get_cpu()) + \
+                '\nStart: ' + str(self.get_time()) + \
+                '\nEnd: ' + str(self.corresp_end_event.get_time())
+
     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
@@ -482,7 +511,7 @@ class SwitchToEvent(Event):
                 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()
@@ -493,30 +522,41 @@ class SwitchToEvent(Event):
                 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 get_name(self):
+        if self.corresp_start_event is None:
+            return 'Switch Away (w/o Switch To)'
+        else:
+            return 'Scheduled'
+
     def __str__(self):
         if self.corresp_start_event is None:
-            return 'Switch Away (w/o Switch To)' + self._common_str() + ', TIME=' \
-                   + str(self.get_time())
+            return super(SwitchAwayEvent, self).__str__()
         return str(self.corresp_start_event)
-            
+
+    def str_long(self):
+        if self.corresp_start_event is None:
+            return super(SwitchAwayEvent, self).str_long()
+
+        return self.corresp_start_event.str_long()
+
     def scan(self, cur_cpu, switches):
         old_cur_cpu = cur_cpu[0]
-        
+
         self.corresp_start_event = switches[SwitchToEvent]
-        
+
         cur_cpu[0] = Event.NO_CPU
         switches[SwitchToEvent] = None
-        
+
         if self.corresp_start_event is not None:
             self.corresp_start_event.corresp_end_event = self
-            
+
         if self.get_cpu() != old_cur_cpu:
             self.erroneous = True
             #print "switching away from a CPU different from the CPU we are currently on"
@@ -526,9 +566,9 @@ class SwitchAwayEvent(Event):
         elif self.get_time() < self.corresp_start_event.get_time():
             self.erroneous = True
             #print "switching away from a processor before we switched to it?!"
-        
+
         super(SwitchAwayEvent, self).scan(cur_cpu, switches)
-            
+
     def render(self, graph, layer, prev_events, selectable=False):
         if self.corresp_start_event is None:
             # We never found a corresponding start event. In that case, we can assume it lies
@@ -550,18 +590,18 @@ class SwitchAwayEvent(Event):
             if self.corresp_start_event in prev_events:
                 return # already rendered the bar
             self.corresp_start_event.render(graph, layer, prev_events, selectable)
-        
+
 class ReleaseEvent(Event):
     def __init__(self, time, cpu):
         super(ReleaseEvent, self).__init__(time, cpu)
         self.layer = Canvas.TOP_LAYER
-    
-    def __str__(self):
-        return 'Release' + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-        
+
+    def get_name(self):
+        return 'Release'
+
     def scan(self, cur_cpu, switches):
         super(ReleaseEvent, self).scan(cur_cpu, switches)
-        
+
     def render(self, graph, layer, prev_events, selectable=False):
         prev_events[self] = None
         if layer == Canvas.TOP_LAYER:
@@ -571,19 +611,19 @@ class ReleaseEvent(Event):
             else:
                 graph.draw_release_arrow_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                              self.get_job().get_job_no(), self.is_selected())
-            
-                                             
+
+
 class DeadlineEvent(Event):
     def __init__(self, time, cpu):
         super(DeadlineEvent, self).__init__(time, cpu)
         self.layer = Canvas.TOP_LAYER
-    
-    def __str__(self):
-        return 'Deadline' + self._common_str() + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-            
+
+    def get_name(self):
+        return 'Deadline'
+
     def scan(self, cur_cpu, switches):
         super(DeadlineEvent, self).scan(cur_cpu, switches)
-        
+
     def render(self, graph, layer, prev_events, selectable=False):
         prev_events[self] = None
         if layer == Canvas.TOP_LAYER:
@@ -593,29 +633,46 @@ class DeadlineEvent(Event):
             else:
                 graph.draw_deadline_arrow_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                               self.get_job().get_job_no(), self.is_selected())
-            
+
 
 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 get_name(self):
+        if self.corresp_end_event is None:
+            return 'Inversion Start (w/o Inversion End)'
+        else:
+            return 'Priority Inversion'
+
     def __str__(self):
         if self.corresp_end_event is None:
-            return 'Inversion Start (w/o Inversion End)' + self._common_str() \
-                  + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-        return 'Priority Inversion' + self._common_str() + ', START=' \
+            return super(InversionStartEvent, self).__str__()
+        return self.get_name() + 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 str_long(self):
+        if self.corresp_end_event is None:
+            return super(InversionStartEvent, self).str_long()
+        else :
+            return 'Event Type: ' + self.get_name() + \
+                '\nTask Name: ' + str(self.get_job().get_task().get_name()) + \
+                '\n(Task no., Job no.): ' + str((self.get_job().get_task().get_task_no(), \
+                                                self.get_job().get_job_no())) + \
+                '\nCPU: ' + str(self.get_cpu()) + \
+                '\nStart: ' + str(self.get_time()) + \
+                '\nEnd: ' + str(self.corresp_end_event.get_time())
+
     def scan(self, cur_cpu, switches):
         switches[InversionStartEvent] = self
         self.corresp_end_event = None
-        
+
         # the corresp_end_event should already be set
         super(InversionStartEvent, self).scan(cur_cpu, switches)
-    
+
     def render(self, graph, layer, prev_events, selectable=False):
         if layer == self.layer:
             end_time = None
@@ -625,7 +682,7 @@ class InversionStartEvent(ErrorEvent):
                 clip = AlignMode.RIGHT
             else:
                 end_time = self.corresp_end_event.get_time()
-            
+
             if layer == self.layer:
                 prev_events[self] = None
                 cpu = self.get_cpu()
@@ -637,36 +694,47 @@ class InversionStartEvent(ErrorEvent):
                     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 get_name(self):
+        if self.corresp_start_event is None:
+            return 'Inversion End (w/o Inversion Start)'
+        else:
+            return 'Priority Inversion'
+
     def __str__(self):
         if self.corresp_start_event is None:
-            return 'Inversion End (w/o Inversion Start)' + self._common_str() \
-                  + ', TIME=' + util.format_float(self.get_time(), Event.NUM_DEC_PLACES)
-        
+            return super(InversionEndEvent, self).__str__()
+
         return str(self.corresp_start_event)
-                      
+
+    def str_long(self):
+        if self.corresp_start_event is None:
+            return super(InversionEndEvent, self).str_long()
+
+        return self.corresp_start_event.str_long()
+
     def scan(self, cur_cpu, switches):
         self.corresp_start_event = switches[InversionStartEvent]
-        
+
         cur_cpu[0] = Event.NO_CPU
         switches[InversionStartEvent] = None
-        
+
         if self.corresp_start_event is not None:
             self.corresp_start_event.corresp_end_event = self
-            
+
         if self.corresp_start_event is None:
             self.erroneous = True
             #print "inversion end was not matched by a corresponding inversion start"
-        
+
         super(InversionEndEvent, self).scan(cur_cpu, switches)
-        
+
     def render(self, graph, layer, prev_events, selectable=False):
         if self.corresp_start_event is None:
             # We never found a corresponding start event. In that case, we can assume it lies
@@ -688,27 +756,27 @@ class InversionEndEvent(ErrorEvent):
             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 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:    
+        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):
         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 is None:
             if self.corresp_end_event in prev_events: