1 files changed, 108 insertions, 26 deletions

diff --git a/parse/sched.py b/parse/sched.py
index 4933037..1033989 100644
--- a/parse/sched.py
+++ b/parse/sched.py
@@ -9,6 +9,21 @@ from common import recordtype,log_once
 from point import Measurement
 from ctypes import *
 
+LOSS_MSG = """Found task missing more than %d%% of its scheduling records.
+These won't be included in scheduling statistics!"""%(100*conf.MAX_RECORD_LOSS)
+SKIP_MSG = """Measurement '%s' has no non-zero values.
+Measurements like these are not included in scheduling statistics.
+If a measurement is missing, this is why."""
+SCALE_MSG = """Task in {} with config {} has < 1.0 scale!
+These scales are skipped in measurements."""
+
+# Data stored for each task
+TaskParams = namedtuple('TaskParams',  ['wcet', 'period', 'cpu', 'level'])
+TaskData   = recordtype('TaskData',    ['params', 'jobs', 'loads',
+                                        'blocks', 'misses', 'execs'])
+
+ScaleData = namedtuple('ScaleData', ['reg_tasks', 'base_tasks'])
+
 class TimeTracker:
     '''Store stats for durations of time demarcated by sched_trace records.'''
     def __init__(self):
@@ -55,9 +70,27 @@ class TimeTracker:
 
         self.next_job = record.job
 
-# Data stored for each task
-TaskParams = namedtuple('TaskParams',  ['wcet', 'period', 'cpu'])
-TaskData   = recordtype('TaskData',    ['params', 'jobs', 'blocks', 'misses'])
+
+class LeveledArray(object):
+    """Groups statistics by the level of the task to which they apply"""
+    def __init__(self):
+        self.name = name
+        self.vals = defaultdict(lambda: defaultdict(lambda:[]))
+
+    def add(self, name, level, value):
+        if type(value) != type([]):
+            value = [value]
+        self.vals[name][level] += value
+
+    def write_measurements(self, result):
+        for stat_name, stat_data in self.vals.iteritems():
+            for level, values in stat_data.iteritems():
+                if not values or not sum(values):
+                    log_once(SKIP_MSG, SKIP_MSG % stat_name)
+                    continue
+
+                name = "%s%s" % ("%s-" % level if level else "", stat_name)
+                result[name] = Measurement(name).from_array(arr)
 
 # Map of event ids to corresponding class and format
 record_map = {}
@@ -157,10 +190,12 @@ class SchedRecord(object):
 
 class ParamRecord(SchedRecord):
     FIELDS = [('wcet', c_uint32),  ('period', c_uint32),
-              ('phase', c_uint32), ('partition', c_uint8)]
+              ('phase', c_uint32), ('partition', c_uint8),
+              ('class', c_uint8),  ('level', c_uint8)]
 
     def process(self, task_dict):
-        params = TaskParams(self.wcet, self.period, self.partition)
+        params = TaskParams(self.wcet, self.period,
+                            self.partition, self.level)
         task_dict[self.pid].params = params
 
 class ReleaseRecord(SchedRecord):
@@ -197,8 +232,13 @@ register_record(7, CompletionRecord)
 register_record(8, BlockRecord)
 register_record(9, ResumeRecord)
 
+__all_dicts = {}
+
 def create_task_dict(data_dir, work_dir = None):
     '''Parse sched trace files'''
+    if data_dir in __all_dicts:
+        return __all_dicts[data_dir]
+
     bin_files   = conf.FILES['sched_data'].format(".*")
     output_file = "%s/out-st" % work_dir
 
@@ -211,7 +251,7 @@ def create_task_dict(data_dir, work_dir = None):
 
     # Save an in-english version of the data for debugging
     # This is optional and will only be done if 'st_show' is in PATH
-    if conf.BINS['st_show']:
+    if work_dir and conf.BINS['st_show']:
         cmd_arr = [conf.BINS['st_show']]
         cmd_arr.extend(bin_names)
         with open(output_file, "w") as f:
@@ -221,28 +261,24 @@ def create_task_dict(data_dir, work_dir = None):
     bin_paths = ["%s/%s" % (data_dir,f) for f in bin_names]
     read_data(task_dict, bin_paths)
 
-    return task_dict
+    __all_dicts[data_dir] = task_dict
 
-LOSS_MSG = """Found task missing more than %d%% of its scheduling records.
-These won't be included in scheduling statistics!"""%(100*conf.MAX_RECORD_LOSS)
-SKIP_MSG = """Measurement '%s' has no non-zero values.
-Measurements like these are not included in scheduling statistics.
-If a measurement is missing, this is why."""
+    return task_dict
 
 def extract_sched_data(result, data_dir, work_dir):
     task_dict = create_task_dict(data_dir, work_dir)
-    stat_data = defaultdict(list)
+    stat_data = LeveledArray()
 
-    # Group per-task values
     for tdata in task_dict.itervalues():
         if not tdata.params:
             # Currently unknown where these invalid tasks come from...
             continue
 
-        miss = tdata.misses
+        level = tdata.config.level
+        miss  = tdata.misses
 
         record_loss = float(miss.disjoints)/(miss.matches + miss.disjoints)
-        stat_data["record-loss"].append(record_loss)
+        stat_data("record-loss", level, record_loss)
 
         if record_loss > conf.MAX_RECORD_LOSS:
             log_once(LOSS_MSG)
@@ -251,17 +287,63 @@ def extract_sched_data(result, data_dir, work_dir):
         miss_ratio = float(miss.num) / miss.matches
         avg_tard = miss.avg * miss_ratio
 
-        stat_data["miss-ratio" ].append(miss_ratio)
+        stat_data("miss-ratio", level, miss_ratio)
+
+        stat_data("max-tard",   level, miss.max / tdata.params.period)
+        stat_data("avg-tard",   level, avg_tard / tdata.params.period)
+
+        stat_data("avg-block",  level, tdata.blocks.avg / NSEC_PER_MSEC)
+        stat_data("max-block",  level, tdata.blocks.max / NSEC_PER_MSEC)
+
+    stat_data.write_measurements(result)
+
+def extract_mc_data(result, data_dir, base_dir):
+    task_dict = get_task_data(data_dir)
+    base_dict = get_task_data(base_dir)
 
-        stat_data["max-tard"].append(miss.max / tdata.params.period)
-        stat_data["avg-tard"].append(avg_tard / tdata.params.period)
+    stat_data = LeveledArray()
 
-        stat_data["avg-block"].append(tdata.blocks.avg / NSEC_PER_MSEC)
-        stat_data["max-block"].append(tdata.blocks.max / NSEC_PER_MSEC)
+    # Only level B loads are measured
+    for tdata in filter(task_dict.iteritems(), lambda x: x.level == 'b'):
+        stat_data.add('load', tdata.config.level, tdata.loads)
 
-    # Summarize value groups
-    for name, data in stat_data.iteritems():
-        if not data or not sum(data):
-            log_once(SKIP_MSG, SKIP_MSG % name)
+    tasks_by_config = defaultdict(lambda: ScaleData([], []))
+
+    # Add task execution times in order of pid to tasks_by_config
+    for tasks, field in ((task_dict, 'reg_tasks'), (base_dict, 'base_tasks')):
+        # Sorted for tie breaking: if 3 regular tasks have the same config
+        # (so 3 base tasks also have the same config), match first pid regular
+        # with first pid base, etc. This matches tie breaking in kernel
+        for pid in sorted(tasks.keys()):
+            tdata = tasks[pid]
+
+        tlist  = getattr(tasks_by_config[tdata.params], field)
+        tlist += [tdata.execs]
+
+    # Write scaling factors
+    for config, scale_data in tasks_by_config:
+        if len(scale_data.reg_tasks) != len(scale_data.base_tasks):
+            # Can't make comparison if different numbers of tasks!
             continue
-        result[name] = Measurement(str(name)).from_array(data)
+
+        # Tuples of (regular task execution times, base task execution times)
+        # where each has the same configuration
+        all_pairs = zip(scale_data.reg_tasks, scale_data.base_tasks)
+
+        for reg_execs, base_execs in all_pairs:
+            if not reg_execs.max  or not reg_execs.avg or\
+               not base_execs.max or not base_execs.avg:
+                # This was an issue at some point, not sure if it still is
+                continue
+
+            max_scale = float(base_execs.max) / reg_execs.max
+            avg_scale = float(base_execs.avg) / reg_execs.avg
+
+            if (avg_scale < 1 or max_scale < 1) and config.level == "b":
+                log_once(SCALE_MSG, SCALE_MSG.format(data_dir, config))
+                continue
+
+            stat_data.add('max-scale', config.level, max_scale)
+            stat_data.add('avg-scale', config.level, avg_scale)
+
+    stat_data.write_measurements(result)