This is the beginning of a very major refactoring of the tool.

Current features:
- Create a record stream from trace files
- Print the record stream to standard out
- TODO file
- README file
- run.py file to set up and execute the testing pipeline

11 files changed, 199 insertions, 659 deletions

diff --git a/README b/README
new file mode 100644
index 0000000..b2da190
--- /dev/null
+++ b/README
@@ -0,0 +1 @@
+See the LITMUS Wiki page for an explanation of this tool.
diff --git a/TODO b/TODO
new file mode 100644
index 0000000..41dc878
--- /dev/null
+++ b/TODO
@@ -0,0 +1,3 @@
+- Currently, trace.py reads all records from the first trace file, then all
+    records from the second, etc. Instead it should progress through all
+    files simultaneously, producing records in order based on timestamp.
diff --git a/run.py b/run.py
new file mode 100755
index 0000000..42def18
--- /dev/null
+++ b/run.py
@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+
+###############################################################################
+# Description
+###############################################################################
+
+# Use this file to set up and execute a testing pipeline
+# Sample pipeline provided
+
+
+###############################################################################
+# Imports
+###############################################################################
+
+import trace
+import text_print
+
+###############################################################################
+# Trace files
+###############################################################################
+
+g4 = [
+'/home/mollison/old/sta/traces/st-g4-0.bin',
+'/home/mollison/old/sta/traces/st-g4-1.bin',
+'/home/mollison/old/sta/traces/st-g4-2.bin',
+'/home/mollison/old/sta/traces/st-g4-3.bin'
+]
+
+###############################################################################
+# Pipeline
+###############################################################################
+
+stream = trace.get_trace_record_stream(g4)
+text_print.print_stream(stream)
diff --git a/test_driver/make_devices b/test_driver/make_devices
deleted file mode 100644
index 4d4554b..0000000
--- a/test_driver/make_devices
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/bin/bash
-
-#Creates device drivers for traces (litmus_log, ft_trace and sched_trace)
-#Taken from http://www.cs.unc.edu/~anderson/litmus-rt/doc/tracing.html 
-
-LITMUS_LOG_MAJOR=`grep litmus_log /proc/devices | awk '{print $1}'`
-FT_TRACE_MAJOR=`grep ft_trace /proc/devices | awk '{print $1}'`
-SCHED_TRACE_MAJOR=`grep sched_trace /proc/devices | awk '{print $1}'`
-
-mknod litmus_log c $LITMUS_LOG_MAJOR 0
-mknod ft_trace   c $FT_TRACE_MAJOR   0
-
-NUM_PROCS=$((`grep 'processor' /proc/cpuinfo | wc -l` - 1))
-
-for P in `seq 0 $NUM_PROCS`
-do
-    mknod "sched_trace$P" c  $SCHED_TRACE_MAJOR  $P
-done
diff --git a/test_driver/sample_test_case.py b/test_driver/sample_test_case.py
deleted file mode 100644
index 6cb886e..0000000
--- a/test_driver/sample_test_case.py
+++ /dev/null
@@ -1,9 +0,0 @@
-#Sample test case for the test driver.
-
-#Each element of the test_case list is a real-time executable task, with parameters.
-#For each task, we have a list: [location of executable,wcet,period,duration].
-
-test_case = [
-        ['/root/liblitmus/rtspin',10,100,1000]
-        ['/root/liblitmus/rtspin',10,100,1000]
-]
diff --git a/test_driver/test.py b/test_driver/test.py
deleted file mode 100755
index 87038a0..0000000
--- a/test_driver/test.py
+++ /dev/null
@@ -1,147 +0,0 @@
-#!/usr/bin/env python3
-
-##########
-#Settings#
-##########
-
-#liblitmus directory (You need to put the compiled liblitmus here)
-liblitmus_dir = '/root/liblitmus/'
-
-#ft_tools directory (You need to but the compiled ft_tools here)
-ft_tools_dir = '/root/ft_tools/'
-
-#device files directory (This script will set up the device files here)
-device_dir = '/root/device_files/'
-
-#recorded trace directory (This script will place recorded traces here)
-trace_dir = '/root/traces/'
-
-#desired scheduling policy, to be set by this script
-#options listed in /proc/litmus/plugins
-policy = 'GSN-EDF'
-
-#desired test case
-test_case_file = 'sample_test_case'
-
-#name of traces
-trace_name = 'driver'
-
-#Additional instructions:
-#    -Make sure you've chmod +x'd the make_devices file and kept it in the same
-#       dir as test.py
-#    -Make sure you've set up a test case
-
-###########
-# Imports #
-###########
-
-import subprocess 
-import os
-import time
-exec('from ' + test_case_file + ' import test_case')
-
-#################
-# Run the tests #
-#################
-
-def main():
-
-    #Determine directory of test.py
-    test_dir = os.getcwd()
-
-    #Set scheduling policy
-    print("Setting scheduling policy... ",end='')
-    ret = subprocess.getstatusoutput(
-        'echo ' + policy + ' > ' + '/proc/litmus/active_plugin')
-    if ret[0] == 0:
-        print("[SUCCESS]")
-    else:
-        print("[FAILURE], error was:")
-        print(str(ret[0]) + ': ' + ret[1])
-        exit()
-
-    #Check for execute permission on the make_devices script
-    print("Checking for permission to run make_devices... ",end='')
-    if not os.access('./make_devices',os.X_OK):
-        print("\nAttempting to chmod +x make_devices... ",end='')
-        ret = subprocess.getstatusoutput('chmod +x ./make_devices')
-        if ret[0]!=1:
-            print("[FAILURE], error was:")
-            print(str(ret[0]) + ': ' + ret[1])
-            exit()
-    print("[SUCCESS]")
-    
-    #Setup the device files for the traces
-    print("Creating device files. OK if they already exist.")
-    subprocess.Popen(test_dir + '/make_devices',cwd=device_dir)
-    time.sleep(1)
-
-    #Set up environment variables needed for st_trace script
-    print("Setting up environment variables... ",end='')
-    os.putenv('FTCAT', ft_tools_dir + 'ftcat')
-    os.putenv('FTDEV',device_dir + 'sched_trace')
-    print("[SUCCESS]")
-
-    #See if we can access and run st_trace
-    print("Checking for permission to run st_trace... ",end='')
-    if not os.access(ft_tools_dir + 'st_trace',os.X_OK):
-        print("\nAttempting to chmod +x st_trace... ",end='')
-        ret = subprocess.getstatusoutput('chmod +x ' + 
-                                         ft_tools_dir + 'st_trace')
-        if ret[0]!=1:
-            print("[FAILURE], error was:")
-            print(str(ret[0]) + ': ' + ret[1])
-            exit()
-    print("[SUCCESS]")
-
-    #Start sched_trace
-    print("Starting st_trace trace recorder... ",end='')
-    st_trace = subprocess.Popen([ft_tools_dir + 'st_trace',trace_name],
-                                cwd=trace_dir)
-    print("[SUCCESS]")
-
-    #We will get an error there, if the test.py program terminates.
-    #time.sleep(7)
-
-    #Start tasks in test_case
-    print("Launching tasks... ",end='')
-    for task in test_case:
-        subprocess.Popen([task[0],'-w',str(task[1]),str(task[2]),str(task[3])])
-    print("[SUCCESS]")
-
-    #Wait for tasks to suspend themselves
-    print("Waiting for tasks to suspend... ",end='')
-    time.sleep(3)
-    print("[SUCCESS]")
-
-    #Release the tasks
-    print("Releasing the tasks... ",end='')
-    ret = subprocess.getstatusoutput(liblitmus_dir + 'release_ts')
-    if ret[0] != 0:
-        print("[FAILURE], error was:")
-        print(str(ret[0]) + ': ' + ret[1])
-        exit()
-    print("[SUCCESS]")
-
-    #Wait for the tasks to complete. I still need to implement this.
-
-
-    #Current steps...
-    #Run st_trace (must tell it location of sched_trace device files exactly)
-    #Let it get set up, then suspend
-    #let it run in background with bg <job>
-    #Run rtspin 10 100 1000 twice; suspend, run in background
-    #Bring rtspins to foreground and stop them.
-    #Bring st_trace to foreground, hit enter to complete it.
-
-    #Need to try to do the above with rt_launch and then release_ts
-
-
-
-##############
-# start main #
-##############
-
-if __name__=='__main__':
-    main()
-
diff --git a/text_print.py b/text_print.py
new file mode 100644
index 0000000..7254b51
--- /dev/null
+++ b/text_print.py
@@ -0,0 +1,23 @@
+###############################################################################
+# Description
+###############################################################################
+
+# Prints records to standard out
+
+###############################################################################
+# Public functions
+###############################################################################
+
+def print_stream(stream):
+    for record in stream:
+        if record.record_type == "event":
+            _print_event(record)
+        print("")
+
+###############################################################################
+# Private functions
+###############################################################################
+
+def _print_event(record):
+    print("Job: {}.{}".format(record.pid,record.job))
+    print("Type: {}".format(record.type_name))
diff --git a/trace.py b/trace.py
new file mode 100644
index 0000000..1ceccae
--- /dev/null
+++ b/trace.py
@@ -0,0 +1,138 @@
+###############################################################################
+# Description
+###############################################################################
+
+# get_trace_record_stream(files) returns an iterator which produces records
+#     in order from the files given. (the param is a list of files.)
+
+
+###############################################################################
+# Imports
+###############################################################################
+
+import struct
+
+
+###############################################################################
+# Public functions
+###############################################################################
+
+# Generator function returning an iterable over records in a trace file.
+def get_trace_record_stream(files):
+    for file in files:
+        with open(file,'rb') as f:
+            while True:
+                data = f.read(24)
+                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()
+                Record = _dict2obj(record_dict)
+                Record.type_name = _get_type_name(type_num)
+                Record.record_type = "event"
+                yield Record
+
+###############################################################################
+# Private functions
+###############################################################################
+
+# Convert a dict into an object
+def _dict2obj(d):
+    class Obj: pass
+    o = Obj()
+    for key in d.keys():
+        o.__dict__[key] = d[key]
+    return o 
+
+###############################################################################
+# Trace record data types and accessor functions
+###############################################################################
+
+class StHeader:
+    format =  '<bbhi'
+    formatStr = struct.Struct(format)
+    keys = ['type','cpu','pid','job']
+    message = 'The header.'
+
+class StNameData:
+    format =  '16s'
+    formatStr = struct.Struct(StHeader.format + format)
+    keys = StHeader.keys + ['name']
+    message = 'The name of the executable of this process.'
+
+class StParamData:  
+    format =  'IIIc'
+    formatStr = struct.Struct(StHeader.format + format)
+    keys = StHeader.keys + ['wcet','period','phase','partition']
+    message = 'Regular parameters.'
+
+class StReleaseData:
+    format =  'QQ'
+    formatStr = struct.Struct(StHeader.format + format)
+    keys = StHeader.keys + ['release_time','deadline']
+    message = 'A job was/is going to be released.'
+
+#Not yet used by Sched Trace 
+class StAssignedData:
+    format =  'Qc'
+    formatStr = struct.Struct(StHeader.format + format)
+    keys = StHeader.keys + ['when','target']
+    message = 'A job was assigned to a CPU.'
+
+class StSwitchToData:
+    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:
+    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'
+    formatStr = struct.Struct(StHeader.format + format)
+    keys = StHeader.keys + ['when','forced?','flags']
+    message = 'A job completed.'
+
+class StBlockData:
+    format =  'Q'
+    formatStr = struct.Struct(StHeader.format + format)
+    keys = StHeader.keys + ['when']
+    message = 'A task blocks.'
+
+class StResumeData:
+    format =  'Q'
+    formatStr = struct.Struct(StHeader.format + format)
+    keys = StHeader.keys + ['when']
+    message = 'A task resumes.'
+
+class StSysReleaseData:
+    format =  'QQ'
+    formatStr = struct.Struct(StHeader.format + format)
+    keys = StHeader.keys + ['when','release']
+    message = 'All tasks have checked in, task system released by user'
+
+# Return the binary data type, given the type_num
+def _get_type(type_num):
+    types = [None,StNameData,StParamData,StReleaseData,StAssignedData,
+             StSwitchToData,StSwitchAwayData,StCompletionData,StBlockData,
+             StResumeData,StSysReleaseData]
+    return types[type_num]
+
+# Return the type name, given the type_num
+def _get_type_name(type_num):
+    type_names = [None,"name","params","release","assign","switch_to","switch_away",
+        "completion","block","resume","sys_release"]
+    return type_names[type_num]
diff --git a/trace_analyzer/README b/trace_analyzer/README
deleted file mode 100644
index 16450df..0000000
--- a/trace_analyzer/README
+++ /dev/null
@@ -1,21 +0,0 @@
-Sched Trace Analyzer
-
-############################
-General Information
-############################
-
-Examples of how to use this can be found in run.py.
-
-The general idea it that you use run.py to put in the commands you want to do,
-and then do something like ./run.py > out to write out the records.
-
-
-#############################
-Development Notes
-#############################
-
-Need to account for situation where there is a tie in deadline which spans the
-topN category.
-
-Might think about adding in hooks, so you do the trace, then add in the hook to
-see the state at the place you're curious about.
diff --git a/trace_analyzer/run.py b/trace_analyzer/run.py
deleted file mode 100755
index 80ae257..0000000
--- a/trace_analyzer/run.py
+++ /dev/null
@@ -1,99 +0,0 @@
-#!/usr/bin/env python3
-import sta
-
-######################################
-# Sched Trace Analyzer LaunchPad     #
-######################################
-
-def main():
-    #myEDF()
-    macTrace()
-    #myTrace()
-    #switchToTrace()
-    #releaseTrace()
-    #oneCPU()
-
-def oneCPU():
-    trace = sta.Trace(g6_list)
-    trace.filter('cpu==0')
-    trace.sort('when')
-    trace.print_count(True)
-    trace.print_records()
-
-def myEDF():
-    test = sta.EDF(g6_list,hooks=[37917786934190])
-    #test = sta.EDF(g6_list)
-    test.run_test()
-
-def myTrace():
-    trace = sta.Trace(g6_list)
-    trace.sort('when',alt='release_time')
-    trace.filter('type==2')
-    trace.print_count(True)
-    trace.print_records()
-
-def macTrace():
-    trace = sta.Trace(mac2_list)
-    trace.sort('when',alt='release_time')
-    trace.print_count(True)
-    trace.print_records()
-
-def switchToTrace():
-    events_trace = sta.Trace(g6_list)
-    events_trace.filter('type==5')
-    events_trace.sort('when')
-    events_trace.print_count(True)
-    events_trace.print_records()
-
-def releaseTrace():
-    events_trace = sta.Trace(g6_list)
-    events_trace.filter('type==3')
-    events_trace.sort('release_time')
-    events_trace.print_count(True)
-    events_trace.print_records()
-
-def sampleTrace():
-    """A sample trace"""
-    trace.filter('pid==4129')
-    trace.filter('when>1323753839')
-    trace.filter('when<1331677799')
-    trace.sort('when')
-    trace.print_count(True)
-    trace.print_records()
-
-
-######################################
-# Put lists of your trace files here #
-######################################
-
-path = '/home/mollison/sta/traces/'
-
-g6_list = [
-path + 'st-g6-0.bin',
-path + 'st-g6-1.bin',
-path + 'st-g6-2.bin',
-path + 'st-g6-3.bin']
-
-g5_list = [
-path + 'st-g5-0.bin',
-path + 'st-g5-1.bin',
-path + 'st-g5-2.bin',
-path + 'st-g5-3.bin']
-
-x19_list = [
-path + 'st-x19-0.bin',
-path + 'st-x19-1.bin',
-path + 'st-x19-2.bin',
-path + 'st-x19-3.bin']
-
-mac2_list = [
-path + 'st-mac2-0.bin']
-
-
-
-##############
-# start main #
-##############
-
-if __name__=='__main__':
-    main()
diff --git a/trace_analyzer/sta.py b/trace_analyzer/sta.py
deleted file mode 100755
index 4269037..0000000
--- a/trace_analyzer/sta.py
+++ /dev/null
@@ -1,365 +0,0 @@
-#!/usr/bin/env python3
-
-
-##################
-#    Imports     #
-##################
-
-import sys
-import struct
-import copy
-
-##################
-# Trace class    #
-##################
-class Trace:
-    """Object representing a trace (i.e. set of records)"""
-
-    def __init__(self,files):
-        """Initialize the Trace object with an iterator"""
-        self.iter = self.make_iter(files) 
-
-    def make_iter(self, files):
-        """Make the iterator for this Trace object"""
-        for file in files:
-            f = open(file,'rb')
-            while True:
-                data = f.read(24)
-                try:
-                    typenum = struct.unpack_from('b',data)[0]
-                except struct.error: 
-                    #We read to the end of the file
-                    f.close()
-                    break
-                type = get_type(typenum)
-                try:
-                    values = struct.unpack_from(StHeader.format + 
-                        type.format,data)
-                    record = dict(zip(type.keys,values))
-                except struct.error:
-                    f.close()
-                    print("Invalid record detected, stopping.")
-                    exit()
-                yield record
-
-    def filter(self, criteria):
-        """Apply a filter to the trace"""
-
-        #Determine if they want to filter by >, <, !=, or ==
-        comp = None
-        seps = ['>','<','==','!=']
-        for sep in seps:
-            if criteria.find(sep) > 0: 
-                comp = sep
-        if not comp:
-            print("Your filter is invalid: " + criteria)
-            exit()
-
-        #Apply the filter
-        field, comp, value = criteria.partition(comp)
-        test = "rec['" + field + "']" + comp + "int(" + value + ")"
-        def func(rec):
-            try:
-                if eval(test):
-                    return True
-                else:
-                    return False
-            except KeyError:
-                return False
-        self.iter = filter(func, self.iter)
-
-    def sort(self, key, key2=None, alt=None):
-        """Return the records in sorted order.
-        key = the key to sort by.
-        key2 = secondary value to sort by, optional
-        alt = alternate key if 'key' does not exist.
-        """
-        def sortfunc(record):
-            score = 0
-            if key in record:
-                score += record[key]
-                if key2 in record:
-                    score = float(str(score) + '.' + str(record[key2]))
-            if score==0 and alt in record:
-                score = record[alt]
-            return score
-        self.iter = sorted(self.iter, key=sortfunc)
-
-    def slice(self, start, end):
-        """Slice the trace iterator"""
-        self.iter = list(self.iter)[start:end]
-
-    def remove_side_effects(self, type1, type2):
-        """Remove records of type2 immediately following records of type1"""
-        self.iter = list(self.iter)
-        i = 0
-        while i < len(self.iter) - 1:
-            if self.iter[i]['type'] == type1 and self.iter[i+1]['type']==type2:
-                del self.iter[i+1]
-            i += 1
-
-    def print_records(self):
-        """Prints all records in the trace"""
-        for record in self.iter:
-            print(50*'=')
-            print(get_type(record['type']).message)
-            for k,v in record.items():
-                print(k +":", v)
-
-    def print_count(self,verbose=False):
-        """Prints the number of records in the trace."""
-        self.iter = list(self.iter)
-        print("Total Count: " + str(len(self.iter)))
-        if verbose:
-            counts = {1:0,2:0,3:0,4:0,5:0,6:0,7:0,8:0,9:0,10:0}
-            for record in list(self.iter):
-                type = record['type']
-                counts[type] += 1
-            for key in counts.keys():
-                print(get_type(key).__name__ + 
-                      ': ' + str(counts[key]))
-        print("")
-
-    def getStr(record,omitTime=False):
-        """Return the representation of a record in the format
-        time: (task, job)"""
-        time = None
-        if 'when' in record:
-            time = record['when']
-        else:
-            time = record['release_time']
-        if not omitTime:
-            return "{0}: ({1},{2})".format(time,record['pid'],record['job'])
-        else:
-            return "({0},{1})".format(record['pid'],record['job'])
-
-    def getTime(record):
-        """Return the time value from a record -- when, or release-time"""
-        if 'when' in record.keys():
-            return record['when']
-        else:
-            return record['release_time']
-
-
-##################
-# EDF   class    #
-##################
-
-class EDF:
-    
-    def __init__(self,trace_files, tolerance=150000, N=4, hooks=[]):
-        self.trace_files = trace_files
-        self.tolerance = tolerance
-        self.jobs = []
-        self.N = N #number of cores
-        self.now = 0
-        self.hooks = hooks
-
-    def run_test(self):
-        trace = Trace(self.trace_files)
-        trace.sort('when',alt='release_time')
-
-        for record in trace.iter:
-            
-            #Update now
-            if 'when' in record:
-                self.now = record['when']
-            elif 'release_time' in record:
-                self.now = record['release_time']
-
-            if self.now in self.hooks:
-                self.print_jobs()
-
-            #Process record
-            if record['type'] == 3:
-                if self.is_duplicate_release(record): continue
-                job = EDF.Job()
-                job.deadline = record['deadline']
-                job.release_time = record['release_time']
-                job.job = record['job']
-                job.pid = record['pid']
-                self.jobs.append(job)
-                print('{0}: {1} was released'.format(self.now,job.get_name()))
-            elif record['type'] == 5:
-                job = self.get_job(record['pid'],record['job'])
-                if job:
-                    job.running = True
-                else:
-                    continue
-                print('{0}: {1} was switched to'
-                      .format(self.now,job.get_name()))
-            elif record['type'] == 6:
-                job = self.get_job(record['pid'],record['job'])
-                if job:
-                    job.running = False
-                else:
-                    continue
-                print('{0}: {1} was switched away'
-                      .format(self.now,job.get_name()))
-            elif record['type'] == 7:
-                job = self.get_job(record['pid'],record['job'])
-                if job:
-                    self.jobs.remove(job)
-                else:
-                    continue
-                print('{0}: {1} completed'
-                      .format(self.now,job.get_name()))
-            else:
-                continue
-
-            #Sort jobs by deadline
-            self.jobs = sorted(self.jobs,key=lambda job: job.deadline)
-            
-            if self.now in self.hooks:
-                self.print_jobs()
-
-            #Check for inversions (and end-of inversions) in the top N jobs
-            for job in self.jobs[0:self.N]:
-                job.topN = True
-                if job.running == False:
-                    if job.inversion_start_time==0:
-                        job.inversion_start_time=self.now
-                    if self.check_tie(job):
-                        job.inversion_start_time=0
-                elif job.running == True:
-                    if job.inversion_start_time > 0:
-                        self.check_error(job)
-                        job.inversion_start_time = 0
-
-            #Check for end-of-inversions in the other jobs
-            for job in self.jobs[self.N:]:
-                if job.topN == True:
-                    job.topN = False
-                    self.check_error(job)
-                    job.inversion_start_time = 0
-
-    def check_error(self, job):
-        if job.inversion_start_time == 0: return
-        if self.now - job.inversion_start_time > self.tolerance:
-            print(' ' * 16 + job.get_name() + 
-                  ' was inverted for {0} time units,'
-                  .format(self.now - job.inversion_start_time))
-            print(' '*26 + 'since {0}'.format(job.inversion_start_time))
-
-    def get_job(self, pid, job):
-        for x in self.jobs:
-            if x.pid == pid and x.job == job:
-                return x
-
-    def is_duplicate_release(self, record):
-        """Make sure we don't get duplicate releases"""
-        job = record['job']
-        pid = record['pid']
-        for x in self.jobs:
-            if x.job == job and x.pid == pid:
-                return True
-        return False
-
-    def check_tie(self, job):
-        """Returns True if there is another job with the same deadline that is
-        running"""
-        for x in self.jobs:
-            if x.deadline == job.deadline and x.running == True:
-                return True
-        return False
-
-    class Job:
-        def __init__(self):
-            self.release_time = 0
-            self.deadline = 0
-            self.job = 0
-            self.pid = 0
-            self.running = False
-            self.topN = False
-            self.inversion_start_time = 0
-
-        def get_name(self):
-            return '({0},{1})'.format(self.pid,self.job)
-
-    def print_jobs(self):
-        print('---Jobs---')
-        for job in self.jobs:
-            print(job.get_name() + '{0} {1}'.format(job.running, job.deadline))
-        print('----------')
-
-####################################
-# Types for binary data conversion #
-####################################
-
-import struct
-
-class StHeader:
-    format =  '<bbhi'
-    formatStr = struct.Struct(format)
-    keys = ['type','cpu','pid','job']
-    message = 'The header.'
-
-class StNameData:
-    format =  '16s'
-    formatStr = struct.Struct(StHeader.format + format)
-    keys = StHeader.keys + ['name']
-    message = 'The name of the executable of this process.'
-
-class StParamData:  
-    format =  'IIIc'
-    #format =  'ccccc'
-    formatStr = struct.Struct(StHeader.format + format)
-    keys = StHeader.keys + ['wcet','period','phase','partition']
-    message = 'Regular parameters.'
-
-class StReleaseData:
-    format =  'QQ'
-    formatStr = struct.Struct(StHeader.format + format)
-    keys = StHeader.keys + ['release_time','deadline']
-    message = 'A job was/is going to be released.'
-
-#Not yet used by Sched Trace 
-class StAssignedData:
-    format =  'Qc'
-    formatStr = struct.Struct(StHeader.format + format)
-    keys = StHeader.keys + ['when','target']
-    message = 'A job was assigned to a CPU.'
-
-class StSwitchToData:
-    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:
-    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'
-    formatStr = struct.Struct(StHeader.format + format)
-    keys = StHeader.keys + ['when','forced?','flags']
-    message = 'A job completed.'
-
-class StBlockData:
-    format =  'Q'
-    formatStr = struct.Struct(StHeader.format + format)
-    keys = StHeader.keys + ['when']
-    message = 'A task blocks.'
-
-class StResumeData:
-    format =  'Q'
-    formatStr = struct.Struct(StHeader.format + format)
-    keys = StHeader.keys + ['when']
-    message = 'A task resumes.'
-
-class StSysReleaseData:
-    format =  'QQ'
-    formatStr = struct.Struct(StHeader.format + format)
-    keys = StHeader.keys + ['when','release']
-    message = 'All tasks have checked in, task system released by user'
-
-def get_type(type_num):
-    """Return the binary data type, given the type_num"""
-    types = [None,StNameData,StParamData,StReleaseData,StAssignedData,
-             StSwitchToData,StSwitchAwayData,StCompletionData,StBlockData,
-             StResumeData,StSysReleaseData]
-    return types[type_num]
-