Merge branch 'wip-gary' of ssh://cvs.cs.unc.edu/cvs/proj/litmus/repo/unit-trace into wip-gary

Conflicts:
	README
	reader/sample_script.py
	visualizer.py

11 files changed, 890 insertions, 185 deletions

diff --git a/README b/README
new file mode 100644
index 0000000..4c1b772
--- /dev/null
+++ b/README
@@ -0,0 +1,105 @@
+See the LITMUS Wiki page for a general explanation of this tool.
+
+unit_trace consists of two modules and a core. The ``core'' is basically
+a bunch of code, implemented as Python iterators, which converts the
+raw trace data into a sequence of record objects, implemented in
+Python. The modules are:
+
+1) A simple module that outputs the contents of each record to
+stdout. This module, along with most of the core, can be found in the
+reader/ directory. There is a sample script -- look at
+sample_script.py in the reader/ directory (it's pretty
+self-explanatory). Note that Mac is the one who coded most of the
+this, though I can probably try to answer any questions about it since
+I've had to go in there from time to time.
+
+2) The visualizer. Now, the GUI as it stands is very basic -- it's
+basically just a shell for the core visualizer component. How to open
+a file is obvious -- but note that you can open several files at a
+time (since more often than not a trace consists of more than one
+file, typically one for each CPU).
+
+Most of the code for this is in the viz/ directory, but to run it, the
+file you want to execute is visualizer.py (in the main directory).
+
+A few notes on how to use the GUI:
+
+-- How to scroll is pretty obvious, though I still need to implement
+   keypresses (very trivial, but when making a GUI component from
+   scratch it always seems like there are a million little things that
+   you need to do :)
+
+-- You can view either by task or by CPU; click the tabs at the top.
+
+-- Mousing over the items (not the axes, though, since those are
+   pretty self-explanatory) gives you information about the item that
+   you moused over, displayed at the bottom.
+
+-- You can select items. You can click them individually, one at a
+   time, or you can drag or ctrl-click to select multiple.
+
+-- What you have selected is independent of what mode (task or CPU)
+   you are operating in. So if you are curious, say, when a certain
+   job is running compared to other jobs on the same CPU, you can
+   click a job in task mode and then switch to CPU mode, and it will
+   remain selected.
+
+-- Right-click to get a menu of all the items you have selected (in
+   the future this menu will be clickable, so that you can get the
+   information about an item in its own window).
+
+-- It is a bit laggy when lots of stuff is on the screen at once. This
+   should be fairly easy to optimize, if I have correctly identified
+   the problem, but it's not a huge issue (it's not _that_ slow).
+
+But wait, there's more:
+
+-- As of now unit-trace has no way to determine the algorithm that was
+   used on the trace you're loading. This is important since certain
+   sections of code work only with G-EDF in particular. The point of
+   having this special code is either to filter out bogus data or to
+   generate extra information about the schedule (e.g. priority
+   inversions). Of course, you can leave these extra steps out and
+   it will still work, but you might get extra ``bogus'' information
+   generated by the tracer or you might not get all the information
+   you want.
+
+-- To add or remove these extra steps, take a look at visualizer.py
+   and sample_script.py. You will see some code like this:
+
+   stream = reader.trace_reader.trace_reader(file_list)
+   #stream = reader.sanitizer.sanitizer(stream)
+   #stream = reader.gedf_test.gedf_test(stream)
+   
+   Uncommenting those lines will run the extra steps in the pipeline.
+   The sanitizer filters out some bogus data (stuff like ``pid 0''),
+   but so far it's only been coded for a select number of traces.
+   gedf_test generates extra information about G-EDF schedules
+   (the traces that are named st-g?-?.bin). If you try to run
+   gedf_test on anything else, it will most likely fail.
+
+-- What traces are you going to use? Well, you will probably want to
+   use your own, but there are some samples you can try in the traces/
+   directory (a couple of them do give error messages, however).
+
+How to install:
+
+You should type
+
+git clone -b wip-gary ssh://cvs.cs.unc.edu/cvs/proj/litmus/repo/unit-trace.git
+
+to check out the repository. Note that you shouldn't check out the
+master branch, as it's pretty outdated. It's all Python so far, so no
+compiling or anything like that is necessary.
+
+Requirements:
+
+You're going to need Python 2.5 to run this. You'll also need to
+install the pycairo and pygtk libraries. If anyone has questions about
+how to do this or what these are, ask me.
+
+Miscellanies:
+
+Of course, let me know if you find any bugs (I'm sure there are
+plenty, though, since this is fairly alpha software), if you're
+unable to run it, or if you have any questions.
\ No newline at end of file
diff --git a/gedf_test.py~ b/gedf_test.py~
new file mode 100644
index 0000000..2381dad
--- /dev/null
+++ b/gedf_test.py~
@@ -0,0 +1,164 @@
+###############################################################################
+# Description
+###############################################################################
+
+# G-EDF Test
+
+###############################################################################
+# Imports
+###############################################################################
+#test
+
+import copy
+
+
+###############################################################################
+# Public Functions
+###############################################################################
+
+def gedf_test(stream):
+
+    # Two lists to model the system: tasks occupying a CPU and tasks eligible
+    # to do so. Also, m = the number of CPUs.
+    eligible = []
+    on_cpu = []
+    m = None
+
+    # Time of the last record we saw. Only run the G-EDF test when the time
+    # is updated.
+    last_time = None
+
+    for record in stream:
+        if record.record_type != "event":
+            if record.record_type == "meta" and record.type_name == "num_cpus":
+                m = record.num_cpus
+            continue
+
+        # Check for inversion starts and ends and yield them.
+        # Only to the check when time has moved forward.
+        # (It is common to have records with simultaneous timestamps.)
+        if last_time is not None and last_time != record.when:
+            errors = _gedf_check(eligible,on_cpu,record.when,m)
+            for error in errors:
+                yield error
+
+        # Add a newly-released Job to the eligible queue
+        if record.type_name == 'release':
+            eligible.append(Job(record))
+
+        # Move a Job from the eligible queue to on_cpu
+        elif record.type_name == 'switch_to':
+            pos = _find_job(record,eligible)
+            job = eligible[pos]
+            del eligible[pos]
+            on_cpu.append(job)
+
+        # Mark a Job as completed.
+        # The only time a Job completes when it is not on a
+        # CPU is when it is the last job of the task.
+        elif record.type_name == 'completion':
+            pos = _find_job(record,on_cpu)
+            if pos is not None:
+                on_cpu[pos].is_complete = True
+            else:
+                pos = _find_job(record,eligible)
+                del eligible[pos]
+
+        # A job is switched away from a CPU. If it has
+        # been marked as complete, remove it from the model.
+        elif record.type_name == 'switch_away':
+            pos = _find_job(record,on_cpu)
+            job = on_cpu[pos]
+            del on_cpu[pos]
+            if job.is_complete == False:
+                eligible.append(job)
+
+        last_time = record.when
+        yield record
+
+###############################################################################
+# Private Functions
+###############################################################################
+
+# Internal representation of a Job
+class Job(object):
+    def __init__(self, record):
+        self.pid = record.pid
+        self.job = record.job
+        self.deadline = record.deadline
+        self.is_complete = False
+        self.inversion_start = None
+        self.inversion_end = None
+    def __str__(self):
+        return "(%d.%d:%d)" % (self.pid,self.job,self.deadline)
+
+# G-EDF errors: the start or end of an inversion
+class Error(object):
+    def __init__(self, job, eligible, on_cpu):
+        self.job = copy.copy(job)
+        self.eligible = copy.copy(eligible)
+        self.on_cpu = copy.copy(on_cpu)
+        self.record_type = 'error'
+        if job.inversion_end is None:
+            self.type_name = 'inversion_start'
+        else:
+            self.type_name = 'inversion_end'
+
+# Returns the position of a Job in a list, or None
+def _find_job(record,list):
+    for i in range(0,len(list)):
+        if list[i].pid == record.pid and list[i].job == record.job:
+            return i
+    return None
+
+# Return records for any inversion_starts and inversion_ends
+def _gedf_check(eligible,on_cpu,when,m):
+
+    # List of error records to be returned
+    errors = []
+
+    # List of all jobs that are not complete
+    all = []
+    for x in on_cpu:
+        if x.is_complete is not True:
+            all.append(x)
+    all += eligible
+
+    # Sort by on_cpu and then by deadline. sort() is guaranteed to be stable.
+    # Thus, this gives us jobs ordered by deadline with preference to those
+    # actually running.
+    all.sort(key=lambda x: 0 if (x in on_cpu) else 1)
+    all.sort(key=lambda x: x.deadline)
+
+    # Check those that actually should be running
+    for x in range(0,min(m,len(all))):
+        job = all[x]
+
+        # It's not running and an inversion_start has not been recorded
+        if job not in on_cpu and job.inversion_start is None:
+            job.inversion_start = when
+            errors.append(Error(job, eligible, on_cpu))
+
+        # It is running and an inversion_start exists (i.e. it it still
+        # marked as being inverted)
+        elif job in on_cpu and job.inversion_start is not None:
+            job.inversion_end = when
+            errors.append(Error(job, eligible, on_cpu))
+            job.inversion_start = None
+            job.inversion_end = None
+
+    # Check those that actually should not be running
+    for x in range(m,len(all)):
+        job = all[x]
+
+        # It actually is running. We don't care.
+
+        # It isn't running, but an inversion_start exists (i.e. it is still
+        # marked as being inverted)
+        if job not in on_cpu and job.inversion_start is not None:
+            job.inversion_end = when
+            errors.append(Error(job, eligible, on_cpu))
+            job.inversion_start = None
+            job.inversion_end = None
+
+    return errors
diff --git a/reader/sample_script.py b/reader/sample_script.py
new file mode 100755
index 0000000..676cfac
--- /dev/null
+++ b/reader/sample_script.py
@@ -0,0 +1,41 @@
+#!/usr/bin/python
+
+# This is a sample script for using the tool. I would recommend copying
+# this and modifying it to suit your needs for a particular test. Make
+# sure you redirect the output to a file (e.g. ./sample_script.py > output).
+
+# Import the modules we need. You should not need to know about
+# their internals.
+import trace_reader
+import sanitizer
+import gedf_test
+import stats
+import stdout_printer
+
+# Specify your trace files
+g6 = [
+'../traces/st-g6-0.bin',
+'../traces/st-g6-1.bin',
+'../traces/st-g6-2.bin',
+'../traces/st-g6-3.bin',
+]
+
+# Here is an example of a custom filter function.
+# It will remove from the error stream all inversion_end records indicating
+# an inversion of less than 4000000 time units. Thus, you can grep through
+# the output looking 'Inversion end' and find only errors for particularly
+# long inversions. This is commented out in the pipeline (below) since you
+# probably don't want it in general.
+def my_filter(record):
+    if record.record_type == 'error' and record.type_name == 'inversion_end':
+        if record.job.inversion_end - record.job.inversion_start < 4000000:
+            return False
+    return True
+
+# Pipeline
+stream = trace_reader.trace_reader(g6)   # Read events from traces
+stream = sanitizer.sanitizer(stream)     # Remove garbage events
+stream = gedf_test.gedf_test(stream)     # Produce G-EDF error records
+stream = stats.stats(stream)             # Produce a statistics record
+#stream = filter(my_filter, stream)      # Filter some records before printing
+stdout_printer.stdout_printer(stream)    # Print records to stdout
diff --git a/unit_trace/viz/__init__.py b/unit_trace/viz/__init__.py
index 5f8d000..ab141e1 100644
--- a/unit_trace/viz/__init__.py
+++ b/unit_trace/viz/__init__.py
@@ -6,6 +6,10 @@ import gtk
 import convert
 
 gobject.signal_new('set-scroll-adjustments', viewer.GraphArea, gobject.SIGNAL_RUN_FIRST,
-                       None, (gtk.Adjustment, gtk.Adjustment))
+                        None, (gtk.Adjustment, gtk.Adjustment))
 gobject.signal_new('update-event-description', viewer.GraphArea, gobject.SIGNAL_RUN_FIRST,
-                       None, (gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT))
+                        None, (gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT))
+gobject.signal_new('request-context-menu', viewer.GraphArea, gobject.SIGNAL_RUN_FIRST,
+                        None, (gtk.gdk.Event, gobject.TYPE_PYOBJECT))
+gobject.signal_new('request-renderer-change', viewer.MainWindow, gobject.SIGNAL_RUN_FIRST,
+                        None, (gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT))
diff --git a/unit_trace/viz/convert.py b/unit_trace/viz/convert.py
index deb50c8..f37dd27 100644
--- a/unit_trace/viz/convert.py
+++ b/unit_trace/viz/convert.py
@@ -79,7 +79,7 @@ def convert_trace_to_schedule(stream):
             }
         
             actions[record.type_name]()
-            
+    
     return sched
     
 def _pid_to_task_name(pid):
diff --git a/unit_trace/viz/draw.py b/unit_trace/viz/draw.py
index c3ab756..c30ffe7 100644
--- a/unit_trace/viz/draw.py
+++ b/unit_trace/viz/draw.py
@@ -84,31 +84,40 @@ class ImageSurface(Surface):
 
 class Pattern(object):
     DEF_STRIPE_SIZE = 10
+    MAX_FADE_WIDTH = 250
     
     def __init__(self, color_list, stripe_size=DEF_STRIPE_SIZE):
         self.color_list = color_list
         self.stripe_size = stripe_size
          
     def render_on_canvas(self, canvas, x, y, width, height, fade=False):
+        fade_span = min(width, Pattern.MAX_FADE_WIDTH)
+        
         if len(self.color_list) == 1:
             if fade:
-                canvas.fill_rect_fade(x, y, width, height, (1.0, 1.0, 1.0), \
+                canvas.fill_rect_fade(x, y, fade_span, height, (1.0, 1.0, 1.0), \
                     self.color_list[0])
             else:
                 canvas.fill_rect(x, y, width, height, self.color_list[0])
             
+            if width > Pattern.MAX_FADE_WIDTH:
+                    canvas.fill_rect(x + Pattern.MAX_FADE_WIDTH, y, width - Pattern.MAX_FADE_WIDTH,
+                                     height, self.color_list[0])
         else:
             n = 0
             bottom = y + height
             while y < bottom:
-                linear = cairo.LinearGradient(x, y, x + width, math.min(y + self.stripe_size, bottom))
                 i = n % len(self.color_list)
                 if fade:
-                    canvas.fill_rect_fade(x, y, width, min(self.stripe_size, bottom - y), (1.0, 1.0, 1.0), \
-                        self.color_list[i])
+                    canvas.fill_rect_fade(x, y, fade_span, \
+                        min(self.stripe_size, bottom - y), (1.0, 1.0, 1.0), self.color_list[i])
                 else:
                     canvas.fill_rect(x, y, width, min(self.stripe_size, bottom - y), self.color_list[i])
                 
+                if width > Pattern.MAX_FADE_WIDTH:
+                    canvas.fill_rect(x + Pattern.MAX_FADE_WIDTH, y, width - Pattern.MAX_FADE_WIDTH,
+                                     min(self.stripe_size, bottom - y), self.color_list[i])
+                    
                 y += self.stripe_size
                 n += 1
         
@@ -129,6 +138,8 @@ class Canvas(object):
     
     LAYERS = (BOTTOM_LAYER, MIDDLE_LAYER, TOP_LAYER)
     
+    NULL_PATTERN = -1
+    
     SQRT3 = math.sqrt(3.0)
     
     def __init__(self, width, height, item_clist, bar_plist, surface):
@@ -470,28 +481,32 @@ class Canvas(object):
     def add_sel_resume_triangle(self, x, y, height, event):
         self.add_sel_region(SelectableRegion(x - height / 2.0, y, height / 2.0, height, event))
         
-    def clear_selectable_regions(self):
-        self.selectable_regions = {}
+    def clear_selectable_regions(self, real_x, real_y, width, height):
+        x = real_x + self.surface.virt_x
+        y = real_y + self.surface.virt_y
+        for event in self.selectable_regions.keys():
+            if self.selectable_regions[event].intersects(x, y, width, height):
+                del self.selectable_regions[event]
         
     def add_sel_region(self, region):
         self.selectable_regions[region.get_event()] = region
         
-    def get_selected_regions(self, real_x, real_y):
+    def get_selected_regions(self, real_x, real_y, width, height):
         x = real_x + self.surface.virt_x
         y = real_y + self.surface.virt_y
     
         selected = {}
         for event in self.selectable_regions:
             region = self.selectable_regions[event]
-            if region.contains(x, y):
+            if region.intersects(x, y, width, height):
                 selected[event] = region
         
         return selected
         
-    def whiteout(self):
+    def whiteout(self, real_x, real_y, width, height):
         """Overwrites the surface completely white, but technically doesn't delete anything"""
-        self.fill_rect(self.surface.virt_x, self.surface.virt_y, self.surface.width,
-                       self.surface.height, (1.0, 1.0, 1.0))
+        self.fill_rect(self.surface.virt_x + real_x, self.surface.virt_y + real_y, width,
+                       height, (1.0, 1.0, 1.0))
             
     def get_item_color(self, n):
         """Gets the nth color in the item color list, which are the colors used to draw the items
@@ -505,7 +520,9 @@ class Canvas(object):
         fill in the bars. Note that there are conceptually infinitely
         many patterns because the patterns repeat -- that is, we just mod out by the size of the pattern
         list when indexing."""
-        return self.bar_plist[n % len(self.bar_plist)]
+        if n < 0:
+            return self.bar_plist[-1]
+        return self.bar_plist[n % (len(self.bar_plist) - 1)]
 
 class CairoCanvas(Canvas):
     """This is a basic class that stores and draws on a Cairo surface,
@@ -679,8 +696,8 @@ class SelectableRegion(object):
     def get_event(self):
         return self.event
     
-    def contains(self, x, y):
-        return self.x <= x <= self.x + self.width and self.y <= y <= self.y + self.height
+    def intersects(self, x, y, width, height):
+        return x <= self.x + self.width and x + width >= self.x and y <= self.y + self.height and y + height >= self.y
         
 class Graph(object):
     DEF_BAR_PLIST = [Pattern([(0.0, 0.9, 0.9)]), Pattern([(0.9, 0.3, 0.0)]), Pattern([(0.9, 0.7, 0.0)]),
@@ -691,9 +708,15 @@ class Graph(object):
     
     def __init__(self, CanvasType, surface, start_time, end_time, y_item_list, attrs=GraphFormat(),
                  item_clist=DEF_ITEM_CLIST, bar_plist=DEF_BAR_PLIST):
+        # deal with possibly blank schedules
+        if start_time is None:
+            start_time = 0
+        if end_time is None:
+            end_time = 0
+         
         if start_time > end_time:
             raise ValueError("Litmus is not a time machine")
-        
+            
         self.attrs = attrs
         self.start_time = start_time
         self.end_time = end_time
@@ -720,6 +743,7 @@ class Graph(object):
                 extra_width = cur_width
             
         width += extra_width
+        
         self.origin = (extra_width + GraphFormat.WIDTH_PAD / 2.0, height - GraphFormat.HEIGHT_PAD / 2.0)
         
         self.width = width
@@ -730,8 +754,8 @@ class Graph(object):
         
         self.canvas = CanvasType(width, height, item_clist, bar_plist, surface)
     
-    def get_selected_regions(self, real_x, real_y):
-        return self.canvas.get_selected_regions(real_x, real_y)
+    def get_selected_regions(self, real_x, real_y, width, height):
+        return self.canvas.get_selected_regions(real_x, real_y, width, height)
                 
     def get_width(self):
         return self.width
@@ -739,6 +763,9 @@ class Graph(object):
     def get_height(self):
         return self.height
     
+    def get_origin(self):
+        return self.origin
+        
     def get_attrs(self):
         return self.attrs
     
@@ -788,12 +815,12 @@ class Graph(object):
     def ycoor_to_item_no(self, y):
         return int((y - self.origin[1] + self._get_y_axis_height()) // self.attrs.y_item_size) 
     
-    def get_offset_params(self):
-        start_time = self.xcoor_to_time(self.canvas.surface.virt_x)
-        end_time = self.xcoor_to_time(self.canvas.surface.virt_x + self.canvas.surface.width)
+    def get_offset_params(self, real_x, real_y, width, height):
+        start_time = self.xcoor_to_time(self.canvas.surface.virt_x + real_x)
+        end_time = self.xcoor_to_time(self.canvas.surface.virt_x + real_x + width)
         
-        start_item = self.ycoor_to_item_no(self.canvas.surface.virt_y)
-        end_item = 1 + self.ycoor_to_item_no(self.canvas.surface.virt_y + self.canvas.surface.height)
+        start_item = self.ycoor_to_item_no(self.canvas.surface.virt_y + real_y)
+        end_item = 1 + self.ycoor_to_item_no(self.canvas.surface.virt_y + real_y + height)
         
         return (start_time, end_time, start_item, end_item)
     
@@ -802,7 +829,7 @@ class Graph(object):
         self.draw_x_axis_with_labels_at_time(start_time, end_time)
         self.draw_y_axis_with_labels()
             
-    def render_surface(self, sched, list_type):
+    def render_surface(self, sched, real_x, real_y, width, height, selectable=False):
         raise NotImplementedError
     
     def render_all(self, schedule):
@@ -919,21 +946,24 @@ class Graph(object):
         raise NotImplementedError
             
 class TaskGraph(Graph):
-    def render_surface(self, sched):
-        self.canvas.whiteout()
-        self.canvas.clear_selectable_regions()
+    def render_surface(self, sched, real_x, real_y, width, height, selectable=False):
+        if not selectable:
+            self.canvas.whiteout(real_x, real_y, width, height)
+        else:
+            self.canvas.clear_selectable_regions(real_x, real_y, width, height)
         
-        start_time, end_time, start_item, end_item = self.get_offset_params()
+        start_time, end_time, start_item, end_item = self.get_offset_params(real_x, real_y, width, height)
         
-        self.draw_skeleton(start_time, end_time, start_item, end_item)
+        if not selectable:
+            self.draw_skeleton(start_time, end_time, start_item, end_item)
         
         for layer in Canvas.LAYERS:
             prev_events = {}
             for event in sched.get_time_slot_array().iter_over_period(
                         start_time, end_time, start_item, end_item,
                         schedule.TimeSlotArray.TASK_LIST, schedule.EVENT_LIST):
-                event.render(self, layer, prev_events)
-                    
+                event.render(self, layer, prev_events, selectable)
+        
     def draw_suspend_triangle_at_time(self, time, task_no, cpu_no, selected=False):
         height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
         x = self._get_time_xpos(time)
@@ -1046,7 +1076,7 @@ class TaskGraph(Graph):
         width = self._get_bar_width(start_time, end_time)
         height = self._get_mini_bar_height()
         
-        self.canvas.draw_mini_bar(x, y, width, height, cpu_no, selected)
+        self.canvas.draw_mini_bar(x, y, width, height, Canvas.NULL_PATTERN, selected)
         
         if job_no is not None:
             x += GraphFormat.MINI_BAR_LABEL_OFS
@@ -1063,35 +1093,42 @@ class TaskGraph(Graph):
         self.canvas.add_sel_mini_bar(x, y, width, height, event)
         
 class CpuGraph(Graph):
-    def render_surface(self, sched):
-        self.canvas.whiteout()
-        self.canvas.clear_selectable_regions()
+    def render_surface(self, sched, real_x, real_y, width, height, selectable=False):
+        if not selectable:
+            self.canvas.whiteout(real_x, real_y, width, height)
+        else:
+            self.canvas.clear_selectable_regions(real_x, real_y, width, height)
         
-        start_time, end_time, start_item, end_item = self.get_offset_params()
+        start_time, end_time, start_item, end_item = self.get_offset_params(real_x, real_y, width, height)
         
-        self.draw_skeleton(start_time, end_time, start_item, end_item)
+        if not selectable:
+            self.draw_skeleton(start_time, end_time, start_item, end_item)
         
         event_list = dict(schedule.EVENT_LIST)
         
-        del event_list[schedule.ReleaseEvent]
-        del event_list[schedule.DeadlineEvent]
+        bottom_events = [schedule.ReleaseEvent, schedule.DeadlineEvent, schedule.InversionStartEvent,
+                         schedule.InversionEndEvent, schedule.InversionDummy]
+            
+        for event in bottom_events:
+            del event_list[event]
         
         for layer in Canvas.LAYERS:
             prev_events = {}
             for event in sched.get_time_slot_array().iter_over_period(
                         start_time, end_time, start_item, end_item,
                         schedule.TimeSlotArray.CPU_LIST, schedule.EVENT_LIST):
-                event.render(self, layer, prev_events)
+                event.render(self, layer, prev_events, selectable)
         
         if end_item >= len(self.y_item_list):
-            # we are far down enough that we should render the releases and deadlines
+            # we are far down enough that we should render the releases and deadlines and inversions,
+            # which appear near the x-axis
             for layer in Canvas.LAYERS:
                 prev_events = {}
                 for event in sched.get_time_slot_array().iter_over_period(
-                        start_time, end_time, start_item, end_item,
+                        start_time, end_time, 0, sched.get_num_cpus(),
                         schedule.TimeSlotArray.CPU_LIST,
-                        (schedule.ReleaseEvent, schedule.DeadlineEvent)):
-                    event.render(self, layer, prev_events)
+                        bottom_events):
+                    event.render(self, layer, prev_events, selectable)
                 
     def render(self, schedule, start_time=None, end_time=None):
         if end_time < start_time:
@@ -1145,9 +1182,10 @@ class CpuGraph(Graph):
         self.canvas.draw_completion_marker(x, y, height, selected)
     
     def add_sel_completion_marker_at_time(self, time, task_no, cpu_no, event):
-        height = self._get_bar_height() * GraphFormat.BLOCK_TRIANGLE_FACTOR
+        height = self._get_bar_height() * GraphFormat.COMPLETION_MARKER_FACTOR
+        
         x = self._get_time_xpos(time)
-        y = self._get_item_ypos(cpu_no) + self._get_bar_height() / 2.0 - height / 2.0
+        y = self._get_item_ypos(cpu_no) + self._get_bar_height() - height
         
         self.canvas.add_sel_completion_marker(x, y, height, event)
             
@@ -1169,7 +1207,7 @@ class CpuGraph(Graph):
                                           AlignMode.CENTER, AlignMode.BOTTOM)
     
     def add_sel_release_arrow_at_time(self, time, task_no, event):
-        height = self._get_bar_height() * GraphFormat.BIG_ARROW_FACTOR
+        height = self._get_bar_height() * GraphFormat.SMALL_ARROW_FACTOR
         
         x = self._get_time_xpos(time)
         y = self.origin[1] - height
@@ -1194,7 +1232,7 @@ class CpuGraph(Graph):
                                           AlignMode.CENTER, AlignMode.BOTTOM)
     
     def add_sel_deadline_arrow_at_time(self, time, task_no, event):
-        height = self._get_bar_height() * GraphFormat.BIG_ARROW_FACTOR
+        height = self._get_bar_height() * GraphFormat.SMALL_ARROW_FACTOR
         
         x = self._get_time_xpos(time)
         y = self.origin[1] - height
@@ -1226,18 +1264,18 @@ class CpuGraph(Graph):
         width = self._get_bar_width(start_time, end_time)
         height = self._get_bar_height()
         
-        self.canvas.add_sel_region(SelectableRegion(x, y, width, height, event))
+        self.canvas.add_sel_bar(x, y, width, height, event)
     
     def draw_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, job_no=None, selected=False):
         if start_time > end_time:
             raise ValueError("Litmus is not a time machine")
             
         x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(cpu_no) - self._get_mini_bar_ofs()
+        y = self._get_item_ypos(len(self.y_item_list))
         width = self._get_bar_width(start_time, end_time)
         height = self._get_mini_bar_height()
         
-        self.canvas.draw_mini_bar(x, y, width, height, cpu_no, selected)
+        self.canvas.draw_mini_bar(x, y, width, height, task_no, selected)
         
         if job_no is not None:
             x += GraphFormat.MINI_BAR_LABEL_OFS
@@ -1247,8 +1285,8 @@ class CpuGraph(Graph):
                 
     def add_sel_mini_bar_at_time(self, start_time, end_time, task_no, cpu_no, event):
         x = self._get_time_xpos(start_time)
-        y = self._get_item_ypos(cpu_no) - self._get_mini_bar_ofs()
+        y = self._get_item_ypos(len(self.y_item_list))
         width = self._get_bar_width(start_time, end_time)
         height = self._get_mini_bar_height()
         
-        self.canvas.add_sel_mini_bar(x, y, width, height, cpu_no, selected)
+        self.canvas.add_sel_mini_bar(x, y, width, height, event)
diff --git a/unit_trace/viz/format.py b/unit_trace/viz/format.py
index fed39f0..6469467 100644
--- a/unit_trace/viz/format.py
+++ b/unit_trace/viz/format.py
@@ -23,7 +23,7 @@ class GraphFormat(object):
     probably don't care about most of them anyway)."""
     
     GRID_COLOR = (0.7, 0.7, 0.7)
-    HIGHLIGHT_COLOR = (0.8, 0.0, 0.0)
+    HIGHLIGHT_COLOR = (0.85, 0.0, 0.0)
     BORDER_COLOR = (0.0, 0.0, 0.0)
     LITE_BORDER_COLOR = (0.4, 0.4, 0.4)
     
diff --git a/unit_trace/viz/schedule.py b/unit_trace/viz/schedule.py
index f842c8d..ae7284b 100644
--- a/unit_trace/viz/schedule.py
+++ b/unit_trace/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,55 +21,78 @@ 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 j in range(0, num):
+                # 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).
+                for i in range(0, num):
+                    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.start) // 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.array[time_slot][TimeSlotArray.TASK_LIST][task_no][event.__class__] = event
-        self.array[time_slot][TimeSlotArray.CPU_LIST][cpu][event.__class__] = event
-        
+        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)
+            
         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._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:
+            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)
+        start_slot = self.get_time_slot(start)
+        end_slot = self.get_time_slot(end) + 2
         
         start_no = max(0, start_no)
         end_no = min(self.list_sizes[list_type] - 1, end_no)
         
-        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 no in range(start_no, end_no + 1):
+            for type in event_types:
+                for slot in range(start_slot, end_slot):
+                    if slot in self.array[list_type][no][type]:
+                        for event in self.array[list_type][no][type][slot]:
+                            yield event
     
 class Schedule(object):
     """The total schedule (task system), consisting of a certain number of
@@ -75,36 +102,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 +167,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 +311,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 +349,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 +378,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 +403,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 +425,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 +469,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 +499,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 +524,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 +546,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 +577,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 +617,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}
diff --git a/unit_trace/viz/trace_reader.py b/unit_trace/viz/trace_reader.py
index a4ff964..831a06e 100644
--- a/unit_trace/viz/trace_reader.py
+++ b/unit_trace/viz/trace_reader.py
@@ -27,7 +27,12 @@
 
 import struct
 
-
+###############################################################################
+# Class definitions
+###############################################################################
+class InvalidRecordError(Exception):
+    pass
+    
 ###############################################################################
 # Public functions
 ###############################################################################
@@ -49,15 +54,19 @@ def trace_reader(files):
     for file in files:
         file_iter = _get_file_iter(file)
         file_iters.append(file_iter)
-        file_iter_buff.append([file_iter.next()])
-
+        file_iter_buff.append([])
+        
     # We keep 100 records in each buffer and then keep the buffer sorted
     # This is because records may have been recorded slightly out of order
     # This cannot guarantee records are produced in order, but it makes it
     # overwhelmingly probably.
     for x in range(0,len(file_iter_buff)):
         for y in range(0,100):
-            file_iter_buff[x].append(file_iters[x].next()) 
+            try:
+                file_iter_buff[x].append(file_iters[x].next()) 
+            except StopIteration:
+                break
+    
     for x in range(0,len(file_iter_buff)):
         file_iter_buff[x] = sorted(file_iter_buff[x],key=lambda rec: rec.when)
 
@@ -96,7 +105,7 @@ def trace_reader(files):
 
         # Check for monotonically increasing time
         if last_time is not None and earliest.when < last_time:
-            exit("FATAL ERROR: trace_reader.py: out-of-order record produced")
+            raise InvalidRecordError("out-of-order record produced")
         else:
             last_time = earliest.when
 
@@ -112,10 +121,12 @@ def _get_file_iter(file):
     f = open(file,'rb')
     while True:
         data = f.read(RECORD_HEAD_SIZE)
+        if data == '':
+            break
         try:
             type_num = struct.unpack_from('b',data)[0]
         except struct.error: 
-            break #We read to the end of the file
+            raise InvalidRecordError("Invalid record detected, stopping.")
         type = _get_type(type_num)
         try:
             values = struct.unpack_from(StHeader.format + 
@@ -123,8 +134,7 @@ def _get_file_iter(file):
             record_dict = dict(zip(type.keys,values))
         except struct.error:
             f.close()
-            print "Invalid record detected, stopping."
-            exit()
+            raise InvalidRecordError("Invalid record detected, stopping.")
 
         # Convert the record_dict into an object
         record = _dict2obj(record_dict)
@@ -139,7 +149,7 @@ def _get_file_iter(file):
         # If there is no timestamp, set the time to 0
         if 'when' not in record.__dict__.keys():
             record.when = 0
-
+        
         yield record
 
 # Convert a dict into an object
@@ -235,6 +245,8 @@ def _get_type(type_num):
     types = [None,StNameData,StParamData,StReleaseData,StAssignedData,
              StSwitchToData,StSwitchAwayData,StCompletionData,StBlockData,
              StResumeData,StSysReleaseData]
+    if type_num >= len(types) or type_num < 0:
+        raise InvalidRecordError("Invalid record detected, stopping.")
     return types[type_num]
 
 # Return the type name, given the type_num (this is simply a convenience to
@@ -242,4 +254,6 @@ def _get_type(type_num):
 def _get_type_name(type_num):
     type_names = [None,"name","params","release","assign","switch_to",
         "switch_away","completion","block","resume","sys_release"]
+    if type_num >= len(type_names) or type_num < 0:
+        raise InvalidRecordError("Invalid record detected, stopping.")
     return type_names[type_num]
diff --git a/unit_trace/viz/viewer.py b/unit_trace/viz/viewer.py
index a695473..ee5c230 100644
--- a/unit_trace/viz/viewer.py
+++ b/unit_trace/viz/viewer.py
@@ -3,20 +3,36 @@
 """GUI stuff."""
 
 from schedule import *
+
 from renderer import *
 
 import pygtk
 import gtk
 import gobject
+
+class GraphContextMenu(gtk.Menu):
+    MAX_STR_LEN = 80
     
+    def __init__(self, selected):
+        super(GraphContextMenu, self).__init__()
+        
+        for event in selected:
+            string = str(event)
+            if len(string) > GraphContextMenu.MAX_STR_LEN - 3:
+                string = string[:GraphContextMenu.MAX_STR_LEN - 3] + '...'
+            item = gtk.MenuItem(string)
+            self.append(item)
+            item.show()
+            
 class GraphArea(gtk.DrawingArea):
-    DAREA_WIDTH_REQ = 500
-    DAREA_HEIGHT_REQ = 300
-    HORIZ_PAGE_SCROLL_FACTOR = 4.8
+    HORIZ_PAGE_SCROLL_FACTOR = 10.8
     HORIZ_STEP_SCROLL_FACTOR = 0.8
     VERT_PAGE_SCROLL_FACTOR = 3.0
     VERT_STEP_SCROLL_FACTOR = 0.5
     
+    SELECT_THICKNESS = 1.5
+    SELECT_COLOR = (0.85, 0.0, 0.0)
+    
     def __init__(self, renderer):
         super(GraphArea, self).__init__()
         
@@ -27,26 +43,45 @@ class GraphArea(gtk.DrawingArea):
         self.width = 0
         self.height = 0
         
-        self.now_selected = []
-        
         self.set_set_scroll_adjustments_signal('set-scroll-adjustments')
         
-        self.add_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.POINTER_MOTION_HINT_MASK)
+        self.add_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.POINTER_MOTION_HINT_MASK |
+                        gtk.gdk.BUTTON_RELEASE_MASK)
+        
+        self.left_button_start_coor = None
+        self.select_rect = None
+        self.ctrl_clicked = False
         
         self.connect('expose-event', self.expose)
         self.connect('size-allocate', self.size_allocate)
         self.connect('set-scroll-adjustments', self.set_scroll_adjustments)
         self.connect('button-press-event', self.button_press)
+        self.connect('button-release-event', self.button_release)
         self.connect('motion-notify-event', self.motion_notify)
         
-        self.set_size_request(GraphArea.DAREA_WIDTH_REQ, GraphArea.DAREA_HEIGHT_REQ)
-        
     def expose(self, widget, event, data=None):
         ctx = widget.window.cairo_create()
         graph = self.renderer.get_graph()
         graph.update_view(self.cur_x, self.cur_y, self.width, self.height, ctx)
-        graph.render_surface(self.renderer.get_schedule())
+        graph.render_surface(self.renderer.get_schedule(), 0, 0, self.width, self.height)
         
+        # render dragging rectangle, if there is one
+        if self.select_rect is not None:
+            x, y, width, height = self.select_rect
+            thickness = GraphArea.SELECT_THICKNESS
+            color = GraphArea.SELECT_COLOR
+            
+            ctx.rectangle(x, y, width, height)            
+            ctx.set_line_width(thickness)
+            ctx.set_source_rgb(color[0], color[1], color[2])
+            ctx.stroke()
+    
+    def get_renderer(self):
+        return self.renderer
+        
+    def get_graph(self):
+        return self.renderer.get_graph()
+            
     def set_scroll_adjustments(self, widget, horizontal, vertical, data=None):
         graph = self.renderer.get_graph()
         width = graph.get_width()
@@ -55,9 +90,11 @@ class GraphArea(gtk.DrawingArea):
         self.horizontal = horizontal
         self.vertical = vertical
         self.config_scrollbars(self.cur_x, self.cur_y)
-                                 
-        self.horizontal.connect('value-changed', self.horizontal_value_changed)
-        self.vertical.connect('value-changed', self.vertical_value_changed)
+        
+        if self.horizontal is not None:                         
+            self.horizontal.connect('value-changed', self.horizontal_value_changed)
+        if self.vertical is not None:
+            self.vertical.connect('value-changed', self.vertical_value_changed)
         
     def horizontal_value_changed(self, adjustment):
         self.cur_x = min(adjustment.value, self.renderer.get_graph().get_width())
@@ -85,7 +122,7 @@ class GraphArea(gtk.DrawingArea):
         
         if self.horizontal is not None:
             self.horizontal.set_all(hvalue, 0.0, width, graph.get_attrs().maj_sep * GraphArea.HORIZ_STEP_SCROLL_FACTOR,
-                                 graph.get_attrs().maj_sep * GraphArea.HORIZ_PAGE_SCROLL_FACTOR, self.width)
+                                graph.get_attrs().maj_sep * GraphArea.HORIZ_PAGE_SCROLL_FACTOR, self.width)
         if self.vertical is not None:
             self.vertical.set_all(vvalue, 0.0, height, graph.get_attrs().y_item_size * GraphArea.VERT_STEP_SCROLL_FACTOR,
                                 graph.get_attrs().y_item_size * GraphArea.VERT_PAGE_SCROLL_FACTOR, self.height) 
@@ -101,7 +138,9 @@ class GraphArea(gtk.DrawingArea):
         msg = None
         
         graph = self.renderer.get_graph()
-        just_selected = graph.get_selected_regions(motion_event.x, motion_event.y)
+        
+        graph.render_surface(self.renderer.get_schedule(), motion_event.x, motion_event.y, 0, 0, True)
+        just_selected = graph.get_selected_regions(motion_event.x, motion_event.y, 0, 0)
         if not just_selected:
             msg = ''
             the_event = None
@@ -116,78 +155,270 @@ class GraphArea(gtk.DrawingArea):
             msg = str(the_event)
         
         self.emit('update-event-description', the_event, msg)
+        
+        if self.left_button_start_coor is not None:
+            selected = {}
+            if self.ctrl_clicked:
+                selected = dict(self.last_selected)
+                
+            # dragging a rectangle
+            x = min(self.left_button_start_coor[0], motion_event.x)
+            y = min(self.left_button_start_coor[1], motion_event.y)
+            width = abs(self.left_button_start_coor[0] - motion_event.x)
+            height = abs(self.left_button_start_coor[1] - motion_event.y)
+            
+            graph.render_surface(self.renderer.get_schedule(), x, y, width, height, True)
+            selected.update(graph.get_selected_regions(x, y, width, height))
+            self.renderer.get_schedule().set_selected(selected)
+    
+            self.select_rect = (x, y, width, height)
             
+            self._dirty()
+        
     def button_press(self, widget, button_event, data=None):
         graph = self.renderer.get_graph()
         
+        self.ctrl_clicked = button_event.state & gtk.gdk.CONTROL_MASK
+        
         if button_event.button == 1:
-            just_selected = graph.get_selected_regions(button_event.x, button_event.y)
+            self.left_button_start_coor = (button_event.x, button_event.y)
+            graph.render_surface(self.renderer.get_schedule(), \
+                                 button_event.x, button_event.y, 0, 0, True)
+            
+            just_selected = graph.get_selected_regions(button_event.x, button_event.y, 0, 0)
             
             max_layer = self._find_max_layer(just_selected)
             
+            new_now_selected = None
+            if self.ctrl_clicked:
+                new_now_selected = self.renderer.get_schedule().get_selected()
+            else:
+                new_now_selected = {}
+                
             # only select those events which were in the top layer (it's
             # not intuitive to click something and then have something
             # below it get selected). Also, clicking something that
-            # is selected deselects it
-            new_now_selected = {}
+            # is selected deselects it, if it's the only thing selected
             for event in just_selected:
                 if event.get_layer() == max_layer:
-                    if not event.is_selected():
+                    val = True
+                    now_selected = self.renderer.get_schedule().get_selected()
+                    if (len(now_selected) == 1 or self.ctrl_clicked) and event in now_selected:
+                        val = not event.is_selected
+                    if val:
                         new_now_selected[event] = None
-                    event.set_selected(not event.is_selected())
-                    break
+                    elif event in new_now_selected:
+                        del new_now_selected[event]
+                    break # only pick one event when just clicking
             
-            for event in self.now_selected:
-                if event not in new_now_selected:
-                    event.set_selected(False)
-                    
-            self.now_selected = new_now_selected
+            self.renderer.get_schedule().set_selected(new_now_selected)
+            self.last_selected = dict(new_now_selected)
             
-            rect = gtk.gdk.Rectangle(0, 0, self.width, self.height)
-            self.window.invalidate_rect(rect, True)
-                
+            self._dirty()
+        elif button_event.button == 3:
+            self._release_band()
+            self.emit('request-context-menu', button_event, self.renderer.get_schedule().get_selected())
+                                    
+    def button_release(self, widget, button_event, data=None):
+        self.ctrl_clicked = False
+        self.last_selected = dict(self.renderer.get_schedule().get_selected())
+        
+        if button_event.button == 1:
+            self._release_band()
+    
+    def _release_band(self):
+        old_select_rect = self.select_rect
+        self.left_button_start_coor = None
+        self.select_rect = None
+        if old_select_rect is not None:
+            self._dirty()
+                            
+    def _dirty(self, x=None, y=None, width=None, height=None):
+        if x is None:
+            x = 0
+        if y is None:
+            y = 0
+        if width is None:
+            width = self.width
+        if height is None:
+            height = self.height
+        rect = gtk.gdk.Rectangle(x, y, width, height)
+        self.window.invalidate_rect(rect, True)
+                 
 class GraphWindow(gtk.ScrolledWindow):    
     def __init__(self, renderer):
         super(GraphWindow, self).__init__(None, None)
         
+        self.add_events(gtk.gdk.KEY_PRESS_MASK)
+        
+        self.ctr = 0
+        self.connect('key-press-event', self.key_press)
+                                
         self.garea = GraphArea(renderer)
         self.add(self.garea)
         self.garea.show()
     
+    def key_press(self, widget, key_event):
+        hadj = self.get_hadjustment()
+        vadj = self.get_vadjustment()
+        if hadj is None or vadj is None:
+            return
+            
+        hupper = hadj.get_upper()
+        hlower = hadj.get_lower()
+        hpincr = hadj.get_page_increment()
+        hsincr = hadj.get_step_increment()
+        hpsize = hadj.get_page_size()
+        hval = hadj.get_value()
+        vupper = vadj.get_upper()
+        vlower = vadj.get_lower()
+        vval = vadj.get_value()
+        vpincr = vadj.get_page_increment()
+        vsincr = vadj.get_step_increment()
+        vpsize = vadj.get_page_size()
+        
+        ctrl_clicked = key_event.state & gtk.gdk.CONTROL_MASK
+        
+        adj_tuple = {'up' :     (vadj, -vsincr, 0, vval, max),
+                     'ctrl-up' :    (vadj, -vpincr, 0, vval, max),
+                     'down' :   (vadj, vsincr, vupper - vpsize, vval, min),
+                     'ctrl-down' :  (vadj, vpincr, vupper - vpsize, vval, min),
+                     'left' :   (hadj, -hsincr, 0, hval, max),
+                     'ctrl-left' :  (hadj, -hpincr, 0, hval, max),
+                     'right' :  (hadj, hsincr, hupper - hpsize, hval, min),
+                     'ctrl-right' : (hadj, hpincr, hupper - hpsize, hval, min)}
+                     
+        keystr = None
+        keymap = {gtk.keysyms.Up : 'up', gtk.keysyms.Down : 'down',
+                  gtk.keysyms.Left : 'left', gtk.keysyms.Right : 'right'}
+        if key_event.keyval in keymap:        
+            keystr = keymap[key_event.keyval]
+                  
+        if ctrl_clicked:
+            keystr = 'ctrl-' + keystr
+            
+        if keystr is not None:
+            adj, inc, lim, val, extr = adj_tuple[keystr]
+            adj.set_value(extr(val + inc, lim))
+            
+        return True
+        
     def get_graph_area(self):
         return self.garea
                         
-class MainWindow(object):
-    def __init__(self, renderer):
-        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
+class MainWindow(gtk.Window):
+    WINDOW_WIDTH_REQ = 500
+    WINDOW_HEIGHT_REQ = 300
+    
+    def __init__(self, request_renderer_change):
+        super(MainWindow, self).__init__(gtk.WINDOW_TOPLEVEL)
         
-        self.window.connect('delete_event', self.delete_event)
-        self.window.connect('destroy', self.destroy)
+        self.connect('delete_event', self.delete_event)
+        self.connect('destroy', self.die)
+    
+        self.connect('request-renderer-change', request_renderer_change)
+        
+        self.file_menu = gtk.Menu()
+        self.open_item = gtk.MenuItem('_Open', True)
+        self.open_item.connect('activate', self.open_item_activate)
+        self.file_menu.append(self.open_item)
+        self.open_item.show()
+        
+        self.quit_item = gtk.MenuItem('_Quit', True)
+        self.quit_item.connect('activate', self.quit_item_activate)
+        self.quit_item.show()
+        self.file_menu.append(self.quit_item)
+        
+        self.file_item = gtk.MenuItem('_File', True)
+        self.file_item.set_submenu(self.file_menu)
+        self.file_item.show()
+        
+        self.menu_bar = gtk.MenuBar()
+        self.menu_bar.append(self.file_item)
+        
+        self.menu_bar.show()
         
         self.vbox = gtk.VBox(False, 0)
         
-        self.gwindow = GraphWindow(renderer)
-        self.gwindow.get_graph_area().connect('update-event-description',
-            self.update_event_description)
-        self.gwindow.show()
+        self.notebook = gtk.Notebook()
+        
+        self.notebook.last_page = -1
+        self.notebook.connect('switch-page', self.switch_page)
+            
+        self.notebook.show()
         
         self.desc_label = gtk.Label('')
         self.desc_label.set_justify(gtk.JUSTIFY_LEFT)
         self.desc_label.show()
         
-        self.vbox.pack_start(self.gwindow, True, True, 0)
+        self.vbox.pack_start(self.menu_bar, False, False, 0)
+        self.vbox.pack_start(self.notebook, True, True, 0)
         self.vbox.pack_start(self.desc_label, False, False, 0)
         self.vbox.show()
         
-        self.window.add(self.vbox)
-        self.window.show()
-   
+        self.add(self.vbox)
+        
+        self.set_size_request(MainWindow.WINDOW_WIDTH_REQ, MainWindow.WINDOW_HEIGHT_REQ)
+        
+        self.show()
+
+    def connect_widgets(self, garea):
+        garea.connect('update-event-description', self.update_event_description)      
+        garea.connect('request-context-menu', self.request_context_menu)
+    
+    def set_renderers(self, renderers):
+        for i in range(0, self.notebook.get_n_pages()):
+            self.notebook.remove_page(0)
+        for title in renderers:
+            gwindow = GraphWindow(renderers[title])
+            self.connect_widgets(gwindow.get_graph_area())
+            gwindow.show()
+            self.notebook.append_page(gwindow, gtk.Label(title))
+        
+    def switch_page(self, widget, page, page_num):
+        if self.notebook.get_nth_page(self.notebook.last_page) is not None:
+            hadj = self.notebook.get_nth_page(self.notebook.last_page).get_hadjustment()
+            old_value = hadj.get_value()
+            old_ofs = self.notebook.get_nth_page(self.notebook.last_page).get_graph_area().get_graph().get_origin()[0]
+            new_ofs = self.notebook.get_nth_page(page_num).get_graph_area().get_graph().get_origin()[0]
+            new_value = old_value - old_ofs + new_ofs
+            hadj.set_value(new_value)
+        
+        self.notebook.last_page = page_num
+        
     def update_event_description(self, widget, event, msg):
         self.desc_label.set_text(msg)
     
+    def request_context_menu(self, widget, gdk_event, selected):
+        button = 0
+        if hasattr(gdk_event, 'button'):
+           button = gdk_event.button
+        time = gdk_event.time
+        
+        menu = GraphContextMenu(selected)
+        menu.popup(None, None, None, button, time)
+        
+    def open_item_activate(self, widget):
+        dialog = gtk.FileChooserDialog('Open File', self,
+                                   gtk.FILE_CHOOSER_ACTION_OPEN,
+                                   (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
+                                               gtk.STOCK_OPEN, gtk.RESPONSE_ACCEPT))
+        dialog.set_select_multiple(True)
+            
+        if dialog.run() == gtk.RESPONSE_ACCEPT:
+            filenames = dialog.get_filenames()
+            dialog.destroy()
+            self.emit('request-renderer-change', filenames, None)
+        else:
+            dialog.destroy()
+        
+        
+    def quit_item_activate(self, widget):
+        self.destroy()
+            
     def delete_event(self, widget, event, data=None):
         return False
         
-    def destroy(self, widget, data=None):
+    def die(self, widget, data=None):
         gtk.main_quit()
     
diff --git a/visualizer.py b/visualizer.py
new file mode 100755
index 0000000..43d74a8
--- /dev/null
+++ b/visualizer.py
@@ -0,0 +1,38 @@
+#!/usr/bin/python
+
+"""Runs the visualizer."""
+
+import convert
+import reader
+import viz
+
+import gtk
+
+TIME_PER_MAJ = 10000000
+MAX_NUM_SLOTS = 10000
+
+def request_renderer_change(widget, file_list, params):
+    try:      
+        stream = reader.trace_reader.trace_reader(file_list)
+        #stream = reader.sanitizer.sanitizer(stream)
+        #stream = reader.gedf_test.gedf_test(stream)
+        sched = convert.convert_trace_to_schedule(stream)
+    except reader.trace_reader.InvalidRecordError, e:
+        dialog = gtk.MessageDialog(widget, gtk.DIALOG_DESTROY_WITH_PARENT,
+                 gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, str(e))
+        dialog.run()
+        dialog.destroy()
+        return
+        
+    sched.scan(TIME_PER_MAJ, MAX_NUM_SLOTS)
+    
+    task_renderer = viz.renderer.Renderer(sched)
+    task_renderer.prepare_task_graph(attrs=viz.format.GraphFormat(time_per_maj=TIME_PER_MAJ))
+    cpu_renderer = viz.renderer.Renderer(sched)
+    cpu_renderer.prepare_cpu_graph(attrs=viz.format.GraphFormat(time_per_maj=TIME_PER_MAJ))
+    widget.set_renderers({'Tasks' : task_renderer, 'CPUs' : cpu_renderer})
+    
+if __name__ == '__main__':   
+    window = viz.viewer.MainWindow(request_renderer_change)
+    gtk.main()
+