EDF test seems much better, now getting 2329 corrects and 190 errors in

g6

2 files changed, 40 insertions, 23 deletions

diff --git a/run.py b/run.py
index 624acdf..5fcdb83 100755
--- a/run.py
+++ b/run.py
@@ -20,7 +20,7 @@ def oneCPU():
     trace.print_records()
 
 def myEDF():
-    test = sta.EDF(g6_list)
+    test = sta.EDF(g6_list,0)
     test.run_test()
 
 def myTrace():
diff --git a/sta.py b/sta.py
index 8c457ae..f3d5408 100755
--- a/sta.py
+++ b/sta.py
@@ -131,9 +131,10 @@ class Trace:
 class EDF:
     """Object representing an EDF test"""
     
-    def __init__(self,trace_files):
+    def __init__(self,trace_files, fudge_factor=0):
         """Create an EDF test"""
         self.trace_files = trace_files
+        self.fudge_factor = fudge_factor
         self.errors = 0
         self.corrects = 0
 
@@ -156,44 +157,44 @@ class EDF:
             if record['type'] == 3:
                 if not self.check_duplicate_release(record):
                     self.runnables.append(record)
-                    debug("Added {0} to runnables"
+                    debug("{0} became runnable"
                           .format(Trace.getStr(record)))
-                    debug(record)
 
             #Switch Tos
             elif record['type'] == 5:
                 release_record = EDF.pop_job(record, self.runnables)
                 self.runnings.append(release_record)
-                debug("Added {0} to runnings"
-                      .format(Trace.getStr(release_record)))
-                debug(release_record)
-                if self.check_deadline(release_record):
-                    print("Valid")
+                check_tuple = self.check_deadline(release_record)
+                if check_tuple[0] == True:
+                    debug("{0} became running (VALID)"
+                          .format(Trace.getStr(release_record)))
                     self.corrects += 1
                 else:
-                    print("Invalid")
+                    debug('='*50)
+                    debug("{0} became running (INVALID)"
+                          .format(Trace.getStr(release_record)))
+                    debug('Deadline of {0} greater than deadline of {1} in the following record:'
+                          .format(release_record['deadline'],
+                                  check_tuple[1]['deadline']))
+                    debug(check_tuple[1])
+                    debug('='*50)
                     self.errors += 1
 
             #Switch Aways
             elif record['type'] == 6:
                 release_record = EDF.pop_job(record, self.runnings)
                 if release_record:
-                    debug("Removed {0} from runnings"
-                          .format(Trace.getStr(release_record)))
-                    debug(release_record)
                     self.runnables.append(release_record)
-                    debug("Added {0} to runnables"
+                    debug('{0} went from running to runnable'
                           .format(Trace.getStr(release_record)))
-                    debug(release_record)
 
             #Completions
             elif record['type'] == 7:
                release_record = EDF.pop_job(record,self.runnings)
                if not release_record:
                    release_record = EDF.pop_job(record,self.runnables)
-               debug("Completed {0}, removed from runnings"
+               debug('{0} completed'
                      .format(Trace.getStr(release_record)))
-               debug(release_record)
 
         print('Corrects: {0}'.format(self.corrects))
         print('Errors  : {0}'.format(self.errors))
@@ -212,14 +213,30 @@ class EDF:
     def check_deadline(self, record):
         """Check to see if a release record has an equal or earlier deadline
         than all those that are runnable"""
+
+        #Set up the variables we will need
         minDeadline = None
-        for record in self.runnables:
-            if minDeadline == None or record['deadline'] < minDeadline:
-                minDeadline = record['deadline']
-        if minDeadline == None or minDeadline >= record['deadline']:
-            return True
+        lowest_deadline_record = None
+        diff = None
+
+        #Find the minimum deadline in runnables and the associated record
+        for record2 in self.runnables:
+            if minDeadline == None or record2['deadline'] < minDeadline:
+                minDeadline = record2['deadline']
+                lowest_deadline_record  = record2
+
+        #Compute the difference btw. the one we sheduled and the minimum
+        #   in runnables
+        if minDeadline == None:
+            diff = 0
+        else:
+            diff = record['deadline'] - minDeadline
+
+        #Determine if the difference is acceptable
+        if diff <= self.fudge_factor:
+            return (True,lowest_deadline_record)
         else:
-            return False 
+            return (False,lowest_deadline_record)
 
     def check_duplicate_release(self, record):
         """Make sure we don't get duplicate releases"""