Track and print triggering events with inversions

2 files changed, 32 insertions, 10 deletions

diff --git a/unit_trace/gedf_test.py b/unit_trace/gedf_test.py
index 3f4e150..f3088ac 100644
--- a/unit_trace/gedf_test.py
+++ b/unit_trace/gedf_test.py
@@ -27,17 +27,27 @@ def gedf_test(stream):
     # is updated.
     last_time = None
 
+    # First event for the latest timestamp. This is used to match up
+    # inversion starts and ends with the first event from the previous
+    # timestamp, which is the first event that could have triggered
+    # the inversion start or end.
+    first_event_this_timestamp = 0
+
     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
 
+        # Bookkeeping iff the timestamp has moved forward.
         # 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.)
+        # (It is common to have records with simultaneous timestamps,
+        # so we only check when the time has moved forward)
+        # Also, need to update the first_event_this_timestamp variable
         if last_time is not None and last_time != record.when:
-            errors = _gedf_check(eligible,on_cpu,last_time,m)
+            errors = _gedf_check(eligible,on_cpu,last_time,m,
+                first_event_this_timestamp)
+            first_event_this_timestamp = record.id
             for error in errors:
                 yield error
 
@@ -89,25 +99,29 @@ class Job(object):
         self.inversion_start = None
         self.inversion_end = None
         self.inversion_start_id = None
+        self.inversion_start_triggering_event_id = 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):
     id = 0
-    def __init__(self, job, eligible, on_cpu):
+    def __init__(self, job, eligible, on_cpu,first_event_this_timestamp):
         Error.id += 1
         self.id = Error.id
         self.job = copy.copy(job)
         self.eligible = copy.copy(eligible)
         self.on_cpu = copy.copy(on_cpu)
         self.record_type = 'error'
+        self.triggering_event_id = first_event_this_timestamp
         if job.inversion_end is None:
             self.type_name = 'inversion_start'
             job.inversion_start_id = self.id
+            job.inversion_start_triggering_event_id = self.triggering_event_id
         else:
             self.type_name = 'inversion_end'
             self.inversion_start_id = job.inversion_start_id
+            self.inversion_start_triggering_event_id = job.inversion_start_triggering_event_id
 
 # Returns the position of a Job in a list, or None
 def _find_job(record,list):
@@ -117,7 +131,7 @@ def _find_job(record,list):
     return None
 
 # Return records for any inversion_starts and inversion_ends
-def _gedf_check(eligible,on_cpu,when,m):
+def _gedf_check(eligible,on_cpu,when,m,first_event_this_timestamp):
 
     # List of error records to be returned
     errors = []
@@ -142,13 +156,15 @@ def _gedf_check(eligible,on_cpu,when,m):
         # 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))
+            errors.append(Error(job, eligible, on_cpu,
+                first_event_this_timestamp))
 
         # 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))
+            errors.append(Error(job, eligible, on_cpu,
+                first_event_this_timestamp))
             job.inversion_start = None
             job.inversion_end = None
 
@@ -162,7 +178,8 @@ def _gedf_check(eligible,on_cpu,when,m):
         # 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))
+            errors.append(Error(job, eligible, on_cpu,
+                first_event_this_timestamp))
             job.inversion_start = None
             job.inversion_end = None
 
diff --git a/unit_trace/stdout_printer.py b/unit_trace/stdout_printer.py
index 4fea95a..a56acce 100644
--- a/unit_trace/stdout_printer.py
+++ b/unit_trace/stdout_printer.py
@@ -33,8 +33,9 @@ def _print_event(record):
     print "Time: %d" % (record.when)
 
 def _print_inversion_start(record):
-    print "Inversion Record IDs: (%d, U)" % (record.id)
     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)
@@ -48,8 +49,12 @@ def _print_inversion_start(record):
     print #newline
 
 def _print_inversion_end(record):
-    print "Inversion record IDs: (%d, %d)" % (record.inversion_start_id,record.id)
     print "Type: %s" % ("Inversion end")
+    print "Inversion record IDs: (%d, %d)" % (record.inversion_start_id,
+        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)
     print "Duration: %d" % (
         record.job.inversion_end - record.job.inversion_start)