Update runtests.py

- Terminate fatally in trace_reader if out-of-order records produced.
    Thus, we no longer need this unit test.
- Fix another unit test which had broken.

2 files changed, 22 insertions, 17 deletions

diff --git a/runtests.py b/runtests.py
index 1ae29f4..c235e2e 100755
--- a/runtests.py
+++ b/runtests.py
@@ -20,36 +20,28 @@ import os
 ###############################################################################
 
 files = [
-'./sample_traces/st-g4-0.bin',
-'./sample_traces/st-g4-1.bin',
-'./sample_traces/st-g4-2.bin',
-'./sample_traces/st-g4-3.bin',
+'./sample_traces/st-g6-0.bin',
+'./sample_traces/st-g6-1.bin',
+'./sample_traces/st-g6-2.bin',
+'./sample_traces/st-g6-3.bin',
 ]
 
 ###############################################################################
 # Tests
 ###############################################################################
 
-# Does the trace reader sort files by time correctly?
-def test1():
-    stream = trace_reader.trace_reader(files)
-    last_time = 0
-    for item in stream:
-        if last_time > item.when:
-            return "[FAIL]"
-        last_time = item.when
-    return "[SUCCESS]"
-
 # Does our fancy trace reader get the same number of files as our naive one?
 # (See naive_trace_reader.py for further explanation)
-def test2():
+def test1():
     stream = trace_reader.trace_reader(files)
     num_records = len(list(stream))
     stream = naive_trace_reader.trace_reader(files)
     naive_num_records = len(list(stream))
-    if num_records != naive_num_records:
+
+    # We need a +1 here because the fancy reader produces a 'meta' record
+    # indicating the number of CPUs
+    if num_records != naive_num_records + 1:
         return "[FAIL]"
     return "[SUCCESS]"
 
 print("Test 1: {}".format(test1()))
-print("Test 2: {}".format(test2()))
diff --git a/trace_reader.py b/trace_reader.py
index 2e5f65d..e18547e 100644
--- a/trace_reader.py
+++ b/trace_reader.py
@@ -53,12 +53,19 @@ def trace_reader(files):
 
     # 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
+    # This cannot guarantee records are produced in order, but it makes it
+    # 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])) 
     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
+    # fatally if they are not.
+    last_time = None
+
     # Keep pulling records as long as we have a buffer
     while len(file_iter_buff) > 0:
 
@@ -87,6 +94,12 @@ def trace_reader(files):
                 del file_iter_buff[buff_to_refill]
                 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
+
         # Yield the record
         yield earliest