7 files changed, 85 insertions, 85 deletions

diff --git a/unit_trace/latest.py b/unit_trace/latest.py
index 38676a0..4effced 100644
--- a/unit_trace/latest.py
+++ b/unit_trace/latest.py
@@ -10,8 +10,8 @@
 
 def latest(stream, latest):
     for record in stream:
-        if record.record_type=="event":
-            if record.id > latest:
+        if record['record_type']=="event":
+            if record['id'] > latest:
                 break
             else:
                 yield record
diff --git a/unit_trace/progress.py b/unit_trace/progress.py
index d0f0482..90f2c2c 100644
--- a/unit_trace/progress.py
+++ b/unit_trace/progress.py
@@ -27,13 +27,13 @@ def progress(stream):
     count = 0
 
     for record in stream:
-        if record.record_type=="event":
+        if record['record_type']=="event":
             count += 1
         if (count % 1000) == 0 and count > 0:
             sys.stderr.write(("Parsed %d event records\n") % (count))
-        if record.record_type=="meta" and record.type_name=="trace_files":
+        if record['record_type']=="meta" and record['type_name']=="trace_files":
             bytes = 0
-            for file in record.files:
+            for file in record['files']:
                 bytes += int(os.path.getsize(file))
             sys.stderr.write(("Total bytes  : %d\n") % (bytes))
             # 192 bits per event record, 8 bits per byte
diff --git a/unit_trace/stdout_printer.py b/unit_trace/stdout_printer.py
index b70b31a..004d9cf 100644
--- a/unit_trace/stdout_printer.py
+++ b/unit_trace/stdout_printer.py
@@ -10,13 +10,14 @@
 
 def stdout_printer(stream):
     for record in stream:
-        if record.record_type == "event":
+        if record['record_type'] == "event":
             _print_event(record)
-        elif record.record_type == "meta" and record.type_name == "stats":
+        elif record['record_type'] == "meta" and record['type_name'] == "stats":
             _print_stats(record)
-        elif record.record_type == "error" and record.type_name == 'inversion_start':
+        elif record['record_type'] == "error" and \
+                record['type_name'] == "inversion_start":
             _print_inversion_start(record)
-        elif record.record_type == "error" and record.type_name == 'inversion_end':
+        elif record['record_type'] == "error" and record['type_name'] == "inversion_end":
             _print_inversion_end(record)
         else:
             continue
@@ -27,46 +28,45 @@ def stdout_printer(stream):
 ###############################################################################
 
 def _print_event(record):
-    print "Event ID: %d" % (record.id)
-    print "Job: %d.%d" % (record.pid,record.job)
-    print "Type: %s" % (record.type_name)
-    print "Time: %d" % (record.when)
+    print "Event ID: %d" % (record['id'])
+    print "Job: %d.%d" % (record['pid'],record['job'])
+    print "Type: %s" % (record['type_name'])
+    print "Time: %d" % (record['when'])
 
 def _print_inversion_start(record):
     print "Type: %s" % ("Inversion start")
-    print "Inversion Record IDs: (%d, U)" % (record.id)
-    print "Triggering Event IDs: (%d, U)" % (record.triggering_event_id)
-    print "Time: %d" % (record.job.inversion_start)
-    print "Job: %d.%d" % (record.job.pid,record.job.job)
-    print "Deadline: %d" % (record.job.deadline)
+    print "Inversion Record IDs: (%d, U)" % (record['id'])
+    print "Triggering Event IDs: (%d, U)" % (record['triggering_event_id'])
+    print "Time: %d" % (record['job']['inversion_start'])
+    print "Job: %d.%d" % (record['job']['pid'],record['job']['job'])
+    print "Deadline']: %d" % (record['job']['deadline'])
     print "Off CPU: ",
-    for job in record.off_cpu:
+    for job in record['off_cpu']:
         print str(job) + " ",
     print
     print "On CPU: ",
-    for job in record.on_cpu:
+    for job in record['on_cpu']:
         print str(job) + " ",
     print #newline
 
 def _print_inversion_end(record):
     print "Type: %s" % ("Inversion end")
-    print "Inversion record IDs: (%d, %d)" % (record.inversion_start_id,
-        record.id)
+    print "Inversion record IDs: (%d, %d)" % (record['inversion_start'],
+        record['id'])
     print("Triggering Event IDs: (%d, %d)" %
-        (record.inversion_start_triggering_event_id,
-        record.triggering_event_id))
-    print "Time: %d" % (record.job.inversion_end)
+        (record['inversion_start'], record['triggering_event_id']))
+    print "Time: %d" % (record['job']['inversion_end'])
     # NOTE: Here, we assume nanoseconds as the time unit.
     # May have to be changed in the future.
     print "Duration: %f ms" % (
-        float(record.job.inversion_end - record.job.inversion_start)/1000000)
-    print "Job: %d.%d" % (record.job.pid,record.job.job)
-    print "Deadline: %d" % (record.job.deadline)
+        float(record['job']['inversion_end'] - record['job']['inversion_start'])/1000000)
+    print "Job: %d.%d" % (record['job']['pid'],record['job']['job'])
+    print "Deadline']: %d" % (record['job']['deadline'])
     print "Off CPU: ",
-    for job in record.off_cpu:
+    for job in record['off_cpu']:
         print str(job) + " ",
     print
     print "On CPU: ",
-    for job in record.on_cpu:
+    for job in record['on_cpu']:
         print str(job) + " ",
     print #newline
diff --git a/unit_trace/trace_reader.py b/unit_trace/trace_reader.py
index a4c3c05..7ab6083 100644
--- a/unit_trace/trace_reader.py
+++ b/unit_trace/trace_reader.py
@@ -27,6 +27,7 @@
 
 import struct
 import sys
+import mmap
 
 
 ###############################################################################
@@ -38,18 +39,11 @@ def trace_reader(files):
 
     # Yield a record containing the input files
     # This is used by progress.py to calculate progress
-    class Obj: pass
-    record = Obj()
-    record.record_type = "meta"
-    record.type_name = "trace_files"
-    record.files = files
+    record = dict(record_type='meta', type_name='trace_files', files=files)
     yield record
 
     # Yield a record indicating the number of CPUs, used by the G-EDF test
-    record = Obj()
-    record.record_type = "meta"
-    record.type_name = "num_cpus"
-    record.num_cpus = len(files)
+    record = dict(record_type='meta', type_name='num_cpus', num_cpus=len(files))
     yield record
 
     # Create iterators for each file and a buffer to store records in
@@ -80,8 +74,8 @@ def trace_reader(files):
                 file_iter_buff[x].append(file_iters[x].next())
         except StopIteration:
             pass
-    for x in range(0,len(file_iter_buff)):
-        file_iter_buff[x] = sorted(file_iter_buff[x],key=lambda rec: rec.when)
+    # for x in range(0,len(file_iter_buff)):
+    #     file_iter_buff[x] = sorted(file_iter_buff[x],key=lambda rec: rec['when'])
 
     # Remember the time of the last record. This way, we can make sure records
     # truly are produced in monotonically increasing order by time and terminate
@@ -98,7 +92,7 @@ def trace_reader(files):
         earliest = -1
         buff_to_refill = -1
         for x in range(0,len(file_iter_buff)):
-            if earliest==-1 or file_iter_buff[x][0].when < earliest.when:
+            if earliest==-1 or file_iter_buff[x][0]['when'] < earliest['when']:
                 earliest = file_iter_buff[x][0]
                 buff_to_refill = x
 
@@ -109,8 +103,8 @@ def trace_reader(files):
         #     then keep the buffer sorted
         try:
             file_iter_buff[buff_to_refill].append(file_iters[buff_to_refill].next())
-            file_iter_buff[buff_to_refill] = sorted(file_iter_buff[buff_to_refill],
-                key=lambda rec: rec.when)
+            # file_iter_buff[buff_to_refill] = sorted(file_iter_buff[buff_to_refill],
+            #     key=lambda rec: rec['when'])
 
         # If there aren't any more records, fine. Unless the buffer is also empty.
         # If that is the case, delete the buffer.
@@ -120,14 +114,14 @@ def trace_reader(files):
                 del file_iters[buff_to_refill]
 
         # 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")
-        else:
-            last_time = earliest.when
+        if last_time is not None and earliest['when'] < last_time:
+        #     exit("FATAL ERROR: trace_reader.py: out-of-order record produced")
+        # else:
+            last_time = earliest['when']
 
         # Give the record an id number
         id += 1
-        earliest.id = id
+        earliest['id'] = id
 
         # Yield the record
         yield earliest
@@ -135,10 +129,12 @@ def trace_reader(files):
 ###############################################################################
 # Private functions
 ###############################################################################
-
+import traceback
 # Returns an iterator to pull records from a file
 def _get_file_iter(file):
-    f = open(file,'rb')
+    f = open(file,'r+b')
+    f = mmap.mmap(f.fileno(), 0)
+
     while True:
         data = f.read(RECORD_HEAD_SIZE)
         try:
@@ -154,26 +150,23 @@ def _get_file_iter(file):
         try:
             values = struct.unpack_from(StHeader.format +
                 type.format,data)
-            record_dict = dict(zip(type.keys,values))
-        except struct.error:
+            record = dict(zip(type.keys,values))
+        except:
             f.close()
             sys.stderr.write("Skipping record that does not match proper" +
                 " struct formatting\n")
             continue
 
-        # Convert the record_dict into an object
-        record = _dict2obj(record_dict)
-
         # Give it a type name (easier to work with than type number)
-        record.type_name = _get_type_name(type_num)
+        record['type_name'] = _get_type_name(type_num)
 
         # All records should have a 'record type' field.
         # e.g. these are 'event's as opposed to 'error's
-        record.record_type = "event"
+        record['record_type'] = "event"
 
         # If there is no timestamp, set the time to 0
-        if 'when' not in record.__dict__.keys():
-            record.when = 0
+        if 'when' not in record.keys():
+            record['when'] = 0
 
         yield record
 
diff --git a/unit_trace/viz/convert.py b/unit_trace/viz/convert.py
index d19bc73..f9f6793 100644
--- a/unit_trace/viz/convert.py
+++ b/unit_trace/viz/convert.py
@@ -16,8 +16,8 @@ def get_type_num(type):
     return nums[type]
 
 def _get_job_from_record(sched, record):
-    tname = _pid_to_task_name(record.pid)
-    job_no = record.job
+    tname = _pid_to_task_name(record['pid'])
+    job_no = record['job']
     if tname not in sched.get_tasks():
         sched.add_task(Task(tname, []))
     if job_no not in sched.get_tasks()[tname].get_jobs():
@@ -31,53 +31,57 @@ def convert_trace_to_schedule(stream):
     def noop():
         pass
 
+    print "Converting"
+
     num_cpus, stream = _find_num_cpus(stream)
     sched = Schedule('sched', num_cpus)
     for record in stream:
-        #if record.record_type == 'meta':
-        #    if record.type_name == 'num_cpus':
+        #if record['record_type'] == 'meta':
+        #    if record['type_name'] == 'num_cpus':
         #        sched = Schedule('sched', record.num_cpus)
         #    continue
-        if record.record_type == 'event':
+        if record['record_type'] == 'event':
             job = _get_job_from_record(sched, record)
-            cpu = record.cpu
+            cpu = record['cpu']
 
-            if not hasattr(record, 'deadline'):
-                record.deadline = None
+            # if not hasattr(record, 'deadline'):
+            #     record['deadline'] = None
 
             actions = {
                 'name' : (noop),
                 'params' : (noop),
                 'release' : (lambda :
-                (job.add_event(ReleaseEvent(record.when, cpu)),
-                job.add_event(DeadlineEvent(record.deadline, cpu)))),
+                (job.add_event(ReleaseEvent(record['when'], cpu)),
+                job.add_event(DeadlineEvent(record['deadline'], cpu)))),
                 'switch_to' : (lambda :
-                job.add_event(SwitchToEvent(record.when, cpu))),
+                job.add_event(SwitchToEvent(record['when'], cpu))),
                 'switch_away' : (lambda :
-                job.add_event(SwitchAwayEvent(record.when, cpu))),
+                job.add_event(SwitchAwayEvent(record['when'], cpu))),
                 'assign' : (noop),
                 'completion' : (lambda :
-                job.add_event(CompleteEvent(record.when, cpu))),
+                job.add_event(CompleteEvent(record['when'], cpu))),
                 'block' : (lambda :
-                job.add_event(SuspendEvent(record.when, cpu))),
+                job.add_event(SuspendEvent(record['when'], cpu))),
                 'resume' : (lambda :
-                job.add_event(ResumeEvent(record.when, cpu))),
+                job.add_event(ResumeEvent(record['when'], cpu))),
                 'sys_release' : (noop)
             }
 
-            actions[record.type_name]()
+            actions[record['type_name']]()
 
-        elif record.record_type == 'error':
-            job = _get_job_from_record(sched, record.job)
+        elif record['record_type'] == 'error':
+            job = _get_job_from_record(sched, record['job'])
 
             actions = {
                 'inversion_start' : (lambda :
-                job.add_event(InversionStartEvent(record.job.inversion_start))),
+                job.add_event(InversionStartEvent(record['job'].inversion_start))),
                 'inversion_end' : (lambda :
-                job.add_event(InversionEndEvent(record.job.inversion_end)))
+                job.add_event(InversionEndEvent(record['job'].inversion_end)))
             }
 
-            actions[record.type_name]()
+            actions[record['type_name']]()
+
+    print "Done converting"
 
     return sched
 
@@ -91,9 +95,9 @@ def _find_num_cpus(stream):
     stream_list = []
     for record in stream:
         stream_list.append(record)
-        if record.record_type == 'event':
-            if record.cpu > max:
-                max = record.cpu
+        if record['record_type'] == 'event':
+            if record['cpu'] > max:
+                max = record['cpu']
 
     def recycle(l):
         for record in l:
diff --git a/unit_trace/viz/schedule.py b/unit_trace/viz/schedule.py
index 542524b..a009733 100644
--- a/unit_trace/viz/schedule.py
+++ b/unit_trace/viz/schedule.py
@@ -6,6 +6,7 @@ a high-level representation of a schedule that can be converted to, say, a
 graphic."""
 
 from graph import *
+from collections import *
 import util
 
 import copy
@@ -58,7 +59,6 @@ class TimeSlotArray(object):
         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)
-
         if self.min_slot is None or slot < self.min_slot:
             self.min_slot = slot
         if self.max_slot is None or slot > self.max_slot:
@@ -223,6 +223,7 @@ class Schedule(object):
         return (self.start, self.end)
 
     def scan(self, time_per_maj):
+        print "Scanning"
         self.start = None
         self.end = None
 
@@ -254,6 +255,7 @@ class Schedule(object):
 
         # add events that correspond to the tasks and CPUS, at the very beginning
         self.time_slot_array.add_item_dummies(self)
+        print "Done scanning"
 
     def add_task(self, task):
         if task.name in self.tasks:
diff --git a/unit_trace/viz/visualizer.py b/unit_trace/viz/visualizer.py
index e80b764..ac56cf7 100755
--- a/unit_trace/viz/visualizer.py
+++ b/unit_trace/viz/visualizer.py
@@ -10,6 +10,7 @@ import gtk
 
 def visualizer(stream, time_per_maj):
     sched = convert.convert_trace_to_schedule(stream)
+    print "No for real"
     sched.scan(time_per_maj)
 
     task_renderer = renderer.Renderer(sched)