Preliminary, fairly workable version of unit_trace, including the visualizer.

1 files changed, 137 insertions, 73 deletions

diff --git a/viz/schedule.py b/viz/schedule.py
index f842c8d..e525b17 100644
--- a/viz/schedule.py
+++ b/viz/schedule.py
@@ -8,6 +8,10 @@ graphic."""
 from draw import *
 import util
 
+import copy
+
+EVENT_LIST = None
+
 class TimeSlotArray(object):
     """Represents another way of organizing the events. This structure organizes events by
     the (approximate) time at which they occur. Events that occur at approximately the same
@@ -17,14 +21,28 @@ class TimeSlotArray(object):
     TASK_LIST = 0
     CPU_LIST = 1
     
-    def __init__(self, start, end, time_per_maj, num_tasks, num_cpus):
+    def __init__(self, start=None, end=None, time_per_maj=1, num_tasks=0, num_cpus=0):
+        if start is None or end is None:
+            self.array = None
+            return
+            
         self.start = start
         self.end = end
         self.time_per_maj = time_per_maj
         self.list_sizes = { TimeSlotArray.TASK_LIST : num_tasks, TimeSlotArray.CPU_LIST : num_cpus }
-        self.array = [{TimeSlotArray.TASK_LIST : [{} for i in range(0, num_tasks)], \
-                       TimeSlotArray.CPU_LIST : [{} for i in range (0, num_cpus)]} \
-                       for i in range(0, (end - start) // self.time_per_maj + 1)]
+        self.array = {}
+        
+        for type in self.list_sizes:
+            num = self.list_sizes[type]
+            self.array[type] = []
+            for i in range(0, int((end - start) // self.time_per_maj + 1)):
+                # for each slot in the array, we need a list of all events under this type
+                # (for example, a list of all events that occur in this time slot, indexed
+                # by task).
+                self.array[type].append([])
+                for j in range(0, num):
+                    self.array[type][i].append(dict(zip(EVENT_LIST, \
+                                    [[] for j in range(0, len(EVENT_LIST))])))
     
     def get_time_slot(self, time):
         return int((time - self.start) // self.time_per_maj)
@@ -34,29 +52,32 @@ class TimeSlotArray(object):
         cpu = event.get_cpu()
         time_slot = self.get_time_slot(event.get_time())
         
-        self.array[time_slot][TimeSlotArray.TASK_LIST][task_no][event.__class__] = event
-        self.array[time_slot][TimeSlotArray.CPU_LIST][cpu][event.__class__] = event
-        
+        self.array[TimeSlotArray.TASK_LIST][time_slot][task_no][event.__class__].append(event)
+        self.array[TimeSlotArray.CPU_LIST][time_slot][cpu][event.__class__].append(event)
+            
         span_events = { SwitchAwayEvent : IsRunningDummy, InversionEndEvent : InversionDummy}
         
         for span_event in span_events:
-            if isinstance(event, span_event) and not event.is_erroneous():
+            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 = self.get_time_slot(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
-                    self.array[slot][TimeSlotArray.TASK_LIST][task_no][dummy.__class__] = dummy
-                    self.array[slot][TimeSlotArray.CPU_LIST][cpu][dummy.__class__] = dummy
+                    self.array[TimeSlotArray.TASK_LIST][slot][task_no][dummy.__class__].append(dummy)
+                    self.array[TimeSlotArray.CPU_LIST][slot][cpu][dummy.__class__].append(dummy)
             
     def iter_over_period(self, start, end, start_no, end_no, list_type, event_types):
+        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 = max(0, self.get_time_slot(start))
-        end_slot = min(len(self.array), self.get_time_slot(end) + 2)
+        end_slot = min(len(self.array[list_type]), self.get_time_slot(end) + 2)
         
         start_no = max(0, start_no)
         end_no = min(self.list_sizes[list_type] - 1, end_no)
@@ -64,8 +85,8 @@ class TimeSlotArray(object):
         for slot in range(start_slot, end_slot):
             for no in range(start_no, end_no + 1):
                 for type in event_types:
-                    if type in self.array[slot][list_type][no]:
-                        yield self.array[slot][list_type][no][type]
+                    for event in self.array[list_type][slot][no][type]:
+                        yield event
     
 class Schedule(object):
     """The total schedule (task system), consisting of a certain number of
@@ -75,36 +96,47 @@ class Schedule(object):
         self.name = name
         self.tasks = {}
         self.task_list = []
+        self.selected = {}
         self.time_slot_array = None
         self.cur_task_no = 0
         self.num_cpus = num_cpus
         for task in task_list:
             self.add_task(task)
     
-    def set_time_params(self, time_per_maj=None):
-        if self.get_task_list() is None:
-            return (0, 0)
+    def get_selected(self):
+        return self.selected
         
+    def set_selected(self, new_selected):
+        for event in self.selected:
+            event.selected = False
+        for event in new_selected:
+            event.selected = True
+        self.selected = new_selected
+    
+    def get_selected(self):
+        return copy.copy(self.selected)
+            
+    def set_time_params(self, time_per_maj=None, max_num_slots=None):
         def find_extreme_time_sched(sched, cmp):
             def find_extreme_time_task(task, cmp):
                 def find_extreme_time_job(job, cmp):
                     extreme_time = None
                     for time in job.get_events():
-                        if extreme_time is None or cmp(time, extreme_time) < 0:
+                        if (extreme_time is None) or cmp(time, extreme_time) < 0:
                             extreme_time = time
                     return extreme_time
                 
                 extreme_time = None
                 for job_no in task.get_jobs():
                     time = find_extreme_time_job(task.get_jobs()[job_no], cmp)
-                    if time is not None and (extreme_time is None or cmp(time, extreme_time) < 0):
+                    if (time is not None) and ((extreme_time is None) or cmp(time, extreme_time) < 0):
                         extreme_time = time    
                 return extreme_time
             
             extreme_time = None
             for task in sched.get_task_list():
                 time = find_extreme_time_task(task, cmp)
-                if time is not None and (extreme_time is None or cmp(time, extreme_time) < 0):
+                if (time is not None) and ((extreme_time is None) or cmp(time, extreme_time) < 0):
                     extreme_time = time
                     
             return extreme_time
@@ -129,20 +161,32 @@ class Schedule(object):
         
         self.start = find_extreme_time_sched(self, earliest_cmp)
         self.end = find_extreme_time_sched(self, latest_cmp)
-        self.time_per_maj = time_per_maj
+        if self.start is None or self.end is None:
+            self.time_slot_array = TimeSlotArray()
+            return
+            
+        min_time_per_maj = (self.end - self.start) * 1.0 / max_num_slots
+        if max_num_slots is not None and time_per_maj is not None:
+            if time_per_maj < min_time_per_maj:
+                self.time_per_maj = min_time_per_maj
+            else:
+                self.time_per_maj = time_per_maj
+        else:
+            self.time_per_maj = time_per_maj
         self.time_slot_array = None
         if self.time_per_maj is not None:
-            self.time_slot_array = TimeSlotArray(self.start, self.end, time_per_maj, \
+            self.time_slot_array = TimeSlotArray(self.start, self.end, 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.set_time_params(time_per_maj)
+    def scan(self, time_per_maj, max_num_slots):
+        self.set_time_params(time_per_maj, max_num_slots)
         
         # we scan the graph task by task, and job by job
         switches = {}
@@ -261,9 +305,13 @@ class DummyEvent(object):
     def get_layer(self):
         return self.layer
         
-    def render(self, graph, layer, prev_events):
+    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)"""
+        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):
@@ -295,10 +343,6 @@ class Event(DummyEvent):
     def is_selected(self):
         """Returns whether the event has been selected by the user. (needed for rendering)"""
         return self.selected
-    
-    def set_selected(self, sel):
-        """Sets the event's state to selected."""
-        self.selected = sel
             
     def scan(self, cur_cpu, switches):
         """Part of the procedure that walks through all the events and sets
@@ -328,13 +372,16 @@ class SuspendEvent(Event):
             print "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):
+    def render(self, graph, layer, prev_events, selectable=False):
         if layer == self.layer:
             prev_events[self] = None
-            graph.draw_suspend_triangle_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
-                                                self.get_cpu(), self.is_selected())
-            graph.add_sel_suspend_triangle_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
+            if selectable:
+                graph.add_sel_suspend_triangle_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                                 self.get_cpu(), self)
+            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):
@@ -350,13 +397,16 @@ class ResumeEvent(Event):
             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):
+    def render(self, graph, layer, prev_events, selectable=False):
         if layer == self.layer:
             prev_events[self] = None
-            graph.draw_resume_triangle_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
-                                               self.get_cpu(), self.is_selected())
-            graph.add_sel_resume_triangle_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
+            if selectable:
+                graph.add_sel_resume_triangle_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                                 self.get_cpu(), self)
+            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):
@@ -369,14 +419,15 @@ class CompleteEvent(Event):
     def scan(self, cur_cpu, switches):
         super(CompleteEvent, self).scan(cur_cpu, switches)
     
-    def render(self, graph, layer, prev_events):
+    def render(self, graph, layer, prev_events, selectable=False):
         if layer == Canvas.TOP_LAYER:
             prev_events[self] = None
-            graph.draw_completion_marker_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
-                                                 self.get_cpu(), self.is_selected())
-            graph.add_sel_completion_marker_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
+            if selectable:
+                graph.add_sel_completion_marker_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                                 self.get_cpu(), self)
-
+            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 SwitchAwayEvent(Event):
     def __init__(self, time, cpu):
@@ -412,10 +463,10 @@ class SwitchAwayEvent(Event):
         
         super(SwitchAwayEvent, self).scan(cur_cpu, switches)
             
-    def render(self, graph, layer, prev_events):
+    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)
+        self.corresp_start_event.render(graph, layer, prev_events, selectable)
         
 class SwitchToEvent(Event):
     def __init__(self, time, cpu):
@@ -442,17 +493,19 @@ class SwitchToEvent(Event):
                             
         super(SwitchToEvent, self).scan(cur_cpu, switches)
     
-    def render(self, graph, layer, prev_events):
-        if self.is_erroneous():
-            return # erroneous switch to
+    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:
             prev_events[self] = None
             cpu = self.get_cpu()
             task_no = self.get_job().get_task().get_task_no()
-            graph.draw_bar_at_time(self.get_time(), self.corresp_end_event.get_time(),
-                                   task_no, cpu, self.get_job().get_job_no(), self.is_selected())
-            graph.add_sel_bar_at_time(self.get_time(), self.corresp_end_event.get_time(),
+            if selectable:
+                graph.add_sel_bar_at_time(self.get_time(), self.corresp_end_event.get_time(),
                                      task_no, cpu, self)
+            else:
+                graph.draw_bar_at_time(self.get_time(), self.corresp_end_event.get_time(),
+                                   task_no, cpu, self.get_job().get_job_no(), self.is_selected())
         
 class ReleaseEvent(Event):
     def __init__(self, time, cpu):
@@ -465,13 +518,16 @@ class ReleaseEvent(Event):
     def scan(self, cur_cpu, switches):
         super(ReleaseEvent, self).scan(cur_cpu, switches)
         
-    def render(self, graph, layer, prev_events):
+    def render(self, graph, layer, prev_events, selectable=False):
         prev_events[self] = None
         if layer == Canvas.TOP_LAYER:
-            graph.draw_release_arrow_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
+            if selectable:
+                graph.add_sel_release_arrow_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
+                                            self)
+            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())
-            graph.add_sel_release_arrow_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
-                                             self)
+            
                                              
 class DeadlineEvent(Event):
     def __init__(self, time, cpu):
@@ -484,13 +540,16 @@ class DeadlineEvent(Event):
     def scan(self, cur_cpu, switches):
         super(DeadlineEvent, self).scan(cur_cpu, switches)
         
-    def render(self, graph, layer, prev_events):
+    def render(self, graph, layer, prev_events, selectable=False):
         prev_events[self] = None
         if layer == Canvas.TOP_LAYER:
-            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())
-            graph.add_sel_deadline_arrow_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
+            if selectable:
+                graph.add_sel_deadline_arrow_at_time(self.get_time(), self.get_job().get_task().get_task_no(),
                                               self)
+            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):
@@ -512,15 +571,18 @@ class InversionStartEvent(ErrorEvent):
         # the corresp_end_event should already be set
         super(InversionStartEvent, self).scan(cur_cpu, switches)
     
-    def render(self, graph, layer, prev_events):
+    def render(self, graph, layer, prev_events, selectable=False):
         if layer == Canvas.BOTTOM_LAYER:
             prev_events[self] = None
             cpu = self.get_cpu()
             task_no = self.get_job().get_task().get_task_no()
-            graph.draw_mini_bar_at_time(self.get_time(), self.corresp_end_event.get_time(),
-                                   task_no, cpu, self.get_job().get_job_no(), self.is_selected())
-            graph.add_sel_mini_bar_at_time(self.get_time(), self.corresp_end_event.get_time(),
+            if selectable:
+                graph.add_sel_mini_bar_at_time(self.get_time(), self.corresp_end_event.get_time(),
                                      task_no, cpu, self)
+            else:
+                graph.draw_mini_bar_at_time(self.get_time(), self.corresp_end_event.get_time(),
+                                   task_no, cpu, self.get_job().get_job_no(), self.is_selected())
+            
 
 class InversionEndEvent(ErrorEvent):
     def __init__(self, time):
@@ -549,23 +611,25 @@ class InversionEndEvent(ErrorEvent):
         
         super(InversionEndEvent, self).scan(cur_cpu, switches)
         
-    def render(self, graph, layer, prev_events):
+    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)
+        self.corresp_start_event.render(graph, layer, prev_events, selectable)
         
 class InversionDummy(DummyEvent):
-    def render(self, graph, layer, prev_events):
+    def render(self, graph, layer, prev_events, selectable=False):
         if self.corresp_start_event in prev_events:
             return # we have already been rendered
-        self.corresp_start_event.render(graph, layer, prev_events)
+        self.corresp_start_event.render(graph, layer, prev_events, selectable)
         
 class IsRunningDummy(DummyEvent):
-    def render(self, graph, layer, prev_events):
+    def render(self, graph, layer, prev_events, selectable=False):
         if self.corresp_start_event in prev_events:
             return # we have already been rendered
-        self.corresp_start_event.render(graph, layer, prev_events)
+        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}
+EVENT_LIST = {SuspendEvent : None, ResumeEvent : None, CompleteEvent : None,
+              SwitchAwayEvent : None, SwitchToEvent : None, ReleaseEvent : None,
+              DeadlineEvent : None, IsRunningDummy : None,
+              InversionStartEvent : None, InversionEndEvent : None,
+              InversionDummy : None}