This commit of unit-trace converts it to Python2 from Python3, so that it

can operate with the visualizer, which uses Python2.

7 files changed, 120 insertions, 119 deletions

diff --git a/gedf_test.py b/gedf_test.py
index 5a3c0c4..8457901 100644
--- a/gedf_test.py
+++ b/gedf_test.py
@@ -80,7 +80,7 @@ def gedf_test(stream):
 ###############################################################################
 
 # Internal representation of a Job
-class Job():
+class Job(object):
     def __init__(self, record):
         self.pid = record.pid
         self.job = record.job
@@ -89,10 +89,10 @@ class Job():
         self.inversion_start = None
         self.inversion_end = None
     def __str__(self):
-        return "({}.{}:{})".format(self.pid,self.job,self.deadline)
+        return "(%d.%d:%d)" % (self.pid,self.job,self.deadline)
 
 # G-EDF errors: the start or end of an inversion
-class Error():
+class Error(object):
     def __init__(self, job, eligible, on_cpu):
         self.job = copy.copy(job)
         self.eligible = copy.copy(eligible)
diff --git a/naive_trace_reader.py b/naive_trace_reader.py
index 9a59353..0f117b8 100644
--- a/naive_trace_reader.py
+++ b/naive_trace_reader.py
@@ -26,38 +26,38 @@ import struct
 # Generator function returning an iterable over records in a trace file.
 def trace_reader(files):
     for file in files:
-        with open(file,'rb') as f:
-            while True:
-                data = f.read(RECORD_HEAD_SIZE)
-                try:
-                    type_num = struct.unpack_from('b',data)[0]
-                except struct.error: 
-                    break #We read to the end of the file
-                type = _get_type(type_num)
-                try:
-                    values = struct.unpack_from(StHeader.format + 
-                        type.format,data)
-                    record_dict = dict(zip(type.keys,values))
-                except struct.error:
-                    f.close()
-                    print("Invalid record detected, stopping.")
-                    exit()
-
-                # 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)
-
-                # All records should have a 'record type' field.
-                # e.g. these are 'event's as opposed to 'error's
-                record.record_type = "event"
-
-                # If there is no timestamp, set the time to 0
-                if 'when' not in record.__dict__.keys():
-                    record.when = 0
-
-                yield record
+        f = open(file,'rb')
+        while True:
+            data = f.read(RECORD_HEAD_SIZE)
+            try:
+                type_num = struct.unpack_from('b',data)[0]
+            except struct.error: 
+                break #We read to the end of the file
+            type = _get_type(type_num)
+            try:
+                values = struct.unpack_from(StHeader.format + 
+                    type.format,data)
+                record_dict = dict(zip(type.keys,values))
+            except struct.error:
+                f.close()
+                print "Invalid record detected, stopping."
+                exit()
+                
+            # 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)
+
+            # All records should have a 'record type' field.
+            # e.g. these are 'event's as opposed to 'error's
+            record.record_type = "event"
+
+            # If there is no timestamp, set the time to 0
+            if 'when' not in record.__dict__.keys():
+                record.when = 0
+
+            yield record
 
 ###############################################################################
 # Private functions
@@ -83,68 +83,68 @@ def _dict2obj(d):
 
 RECORD_HEAD_SIZE = 24
 
-class StHeader:
+class StHeader(object):
     format =  '<bbhi'
     formatStr = struct.Struct(format)
     keys = ['type','cpu','pid','job']
     message = 'The header.'
 
-class StNameData:
+class StNameData(object):
     format =  '16s'
     formatStr = struct.Struct(StHeader.format + format)
     keys = StHeader.keys + ['name']
     message = 'The name of the executable of this process.'
 
-class StParamData:  
+class StParamData(object):  
     format =  'IIIc'
     formatStr = struct.Struct(StHeader.format + format)
     keys = StHeader.keys + ['wcet','period','phase','partition']
     message = 'Regular parameters.'
 
-class StReleaseData:
+class StReleaseData(object):
     format =  'QQ'
     formatStr = struct.Struct(StHeader.format + format)
     keys = StHeader.keys + ['when','deadline']
     message = 'A job was/is going to be released.'
 
 #Not yet used by Sched Trace 
-class StAssignedData:
+class StAssignedData(object):
     format =  'Qc'
     formatStr = struct.Struct(StHeader.format + format)
     keys = StHeader.keys + ['when','target']
     message = 'A job was assigned to a CPU.'
 
-class StSwitchToData:
+class StSwitchToData(object):
     format =  'QI'
     formatStr = struct.Struct(StHeader.format + format)
     keys = StHeader.keys + ['when','exec_time']
     message = 'A process was switched to on a given CPU.'
 
-class StSwitchAwayData:
+class StSwitchAwayData(object):
     format =  'QI'
     formatStr = struct.Struct(StHeader.format + format)
     keys = StHeader.keys + ['when','exec_time']
     message = 'A process was switched away on a given CPU.'
 
-class StCompletionData:
-    format =  'Q3x?c'
+class StCompletionData(object):
+    format =  'Q3xcc'
     formatStr = struct.Struct(StHeader.format + format)
     keys = StHeader.keys + ['when','forced?','flags']
     message = 'A job completed.'
 
-class StBlockData:
+class StBlockData(object):
     format =  'Q'
     formatStr = struct.Struct(StHeader.format + format)
     keys = StHeader.keys + ['when']
     message = 'A task blocks.'
 
-class StResumeData:
+class StResumeData(object):
     format =  'Q'
     formatStr = struct.Struct(StHeader.format + format)
     keys = StHeader.keys + ['when']
     message = 'A task resumes.'
 
-class StSysReleaseData:
+class StSysReleaseData(object):
     format =  'QQ'
     formatStr = struct.Struct(StHeader.format + format)
     keys = StHeader.keys + ['when','release']
diff --git a/runtests.py b/runtests.py
index c235e2e..88dddf4 100755
--- a/runtests.py
+++ b/runtests.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/python
 
 ###############################################################################
 # Description
@@ -44,4 +44,4 @@ def test1():
         return "[FAIL]"
     return "[SUCCESS]"
 
-print("Test 1: {}".format(test1()))
+print "Test 1: %s" % (test1())
diff --git a/sample_script.py b/sample_script.py
index 6fdb6cc..c3b7843 100755
--- a/sample_script.py
+++ b/sample_script.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/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
diff --git a/stats.py b/stats.py
index d61be6f..34a842f 100644
--- a/stats.py
+++ b/stats.py
@@ -28,7 +28,7 @@ def stats(stream):
         avg_inversion = int(sum_inversions / num_inversions)
     else:
         avg_inversion = 0
-    class Obj(): pass
+    class Obj(object): pass
     rec = Obj()
     rec.record_type = "meta"
     rec.type_name = "stats"
diff --git a/stdout_printer.py b/stdout_printer.py
index 5bbcead..f8d9a84 100644
--- a/stdout_printer.py
+++ b/stdout_printer.py
@@ -20,50 +20,50 @@ def stdout_printer(stream):
             _print_inversion_end(record)
         else:
             continue
-        print("")
+        print ""
 
 ###############################################################################
 # Private functions
 ###############################################################################
 
 def _print_event(record):
-    print("Job: {}.{}".format(record.pid,record.job))
-    print("Type: {}".format(record.type_name))
-    print("Time: {}".format(record.when))
+    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: {}".format("Inversion start"))
-    print("Time: {}".format(record.job.inversion_start))
-    print("Job: {}.{}".format(record.job.pid,record.job.job))
-    print("Deadline: {}".format(record.job.deadline))
-    print("Eligible: ",end="")
+    print "Type: %s" % ("Inversion start")
+    print "Time: %d" % (record.job.inversion_start)
+    print "Job: %d.%d" % (record.job.pid,record.job.job)
+    print "Deadline: %d" % (record.job.deadline)
+    print "Eligible: ",
     for job in record.eligible:
-        print(str(job) + " ",end="")
-    print("")
-    print("On CPU: ",end="")
+        print str(job) + " ",
+    print
+    print "On CPU: ",
     for job in record.on_cpu:
-        print(str(job) + " ",end="")
-    print("") #newline
+        print str(job) + " ",
+    print #newline
 
 def _print_inversion_end(record):
-    print("Type: {}".format("Inversion end"))
-    print("Time: {}".format(record.job.inversion_end))
-    print("Duration: {}".format(
-        record.job.inversion_end - record.job.inversion_start))
-    print("Job: {}.{}".format(record.job.pid,record.job.job))
-    print("Deadline: {}".format(record.job.deadline))
-    print("Eligible: ",end="")
+    print "Type: %s" % ("Inversion end")
+    print "Time: %d" % (record.job.inversion_end)
+    print "Duration: %d" % (
+        record.job.inversion_end - record.job.inversion_start)
+    print "Job: %d.%d" % (record.job.pid,record.job.job)
+    print "Deadline: %d" % (record.job.deadline)
+    print "Eligible: ",
     for job in record.eligible:
-        print(str(job) + " ",end="")
-    print("")
-    print("On CPU: ",end="")
+        print str(job) + " ",
+    print
+    print "On CPU: ",
     for job in record.on_cpu:
-        print(str(job) + " ",end="")
-    print("") #newline
+        print str(job) + " ",
+    print #newline
 
 def _print_stats(record):
-    print("Inversion statistics")
-    print("Num inversions: {}".format(record.num_inversions))
-    print("Min inversion: {}".format(record.min_inversion))
-    print("Max inversion: {}".format(record.max_inversion))
-    print("Avg inversion: {}".format(record.avg_inversion))
+    print "Inversion statistics" 
+    print "Num inversions: %d" % (record.num_inversions)
+    print "Min inversion: %d" % (record.min_inversion)
+    print "Max inversion: %d" % (record.max_inversion)
+    print "Avg inversion: %d" % (record.avg_inversion)
diff --git a/trace_reader.py b/trace_reader.py
index e18547e..a4ff964 100644
--- a/trace_reader.py
+++ b/trace_reader.py
@@ -49,7 +49,7 @@ def trace_reader(files):
     for file in files:
         file_iter = _get_file_iter(file)
         file_iters.append(file_iter)
-        file_iter_buff.append([next(file_iter)])
+        file_iter_buff.append([file_iter.next()])
 
     # 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
@@ -57,7 +57,7 @@ def trace_reader(files):
     # overwhelmingly probably.
     for x in range(0,len(file_iter_buff)):
         for y in range(0,100):
-            file_iter_buff[x].append(next(file_iters[x])) 
+            file_iter_buff[x].append(file_iters[x].next()) 
     for x in range(0,len(file_iter_buff)):
         file_iter_buff[x] = sorted(file_iter_buff[x],key=lambda rec: rec.when)
 
@@ -83,7 +83,7 @@ def trace_reader(files):
         # Try to append a new record to the buffer (if there is another) and
         #     then keep the buffer sorted
         try:
-            file_iter_buff[buff_to_refill].append(next(file_iters[buff_to_refill]))
+            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)
 
@@ -109,42 +109,42 @@ def trace_reader(files):
 
 # Returns an iterator to pull records from a file
 def _get_file_iter(file):
-    with open(file,'rb') as f:
-        while True:
-            data = f.read(RECORD_HEAD_SIZE)
-            try:
-                type_num = struct.unpack_from('b',data)[0]
-            except struct.error: 
-                break #We read to the end of the file
-            type = _get_type(type_num)
-            try:
-                values = struct.unpack_from(StHeader.format + 
-                    type.format,data)
-                record_dict = dict(zip(type.keys,values))
-            except struct.error:
-                f.close()
-                print("Invalid record detected, stopping.")
-                exit()
-
-            # 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)
-
-            # All records should have a 'record type' field.
-            # e.g. these are 'event's as opposed to 'error's
-            record.record_type = "event"
-
-            # If there is no timestamp, set the time to 0
-            if 'when' not in record.__dict__.keys():
-                record.when = 0
-
-            yield record
+    f = open(file,'rb')
+    while True:
+        data = f.read(RECORD_HEAD_SIZE)
+        try:
+            type_num = struct.unpack_from('b',data)[0]
+        except struct.error: 
+            break #We read to the end of the file
+        type = _get_type(type_num)
+        try:
+            values = struct.unpack_from(StHeader.format + 
+                type.format,data)
+            record_dict = dict(zip(type.keys,values))
+        except struct.error:
+            f.close()
+            print "Invalid record detected, stopping."
+            exit()
+
+        # 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)
+
+        # All records should have a 'record type' field.
+        # e.g. these are 'event's as opposed to 'error's
+        record.record_type = "event"
+
+        # 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
 def _dict2obj(d):
-    class Obj: pass
+    class Obj(object): pass
     o = Obj()
     for key in d.keys():
         o.__dict__[key] = d[key]
@@ -206,7 +206,8 @@ class StSwitchAwayData:
     message = 'A process was switched away on a given CPU.'
 
 class StCompletionData:
-    format =  'Q3x?c'
+    #format =  'Q3x?c'
+    format = 'Q3xcc'
     formatStr = struct.Struct(StHeader.format + format)
     keys = StHeader.keys + ['when','forced?','flags']
     message = 'A job completed.'