3 files changed, 68 insertions, 9 deletions

diff --git a/parse/dir_map.py b/parse/dir_map.py
index 319a5de..499c712 100644
--- a/parse/dir_map.py
+++ b/parse/dir_map.py
@@ -44,7 +44,7 @@ class DirMap(object):
                     if not base_type in measurement:
                         continue
                     # Ex: wcet/avg/max/vary-type/other-stuff.csv
-                    path  = [ stat, summary_type, base_type, "vary-%s" % vary ]
+                    path   = [ stat, summary_type, base_type, "vary-%s" % vary ]
                     result = measurement[base_type]
 
                     self.__update_node(path, keys, (vary_value, result))
@@ -68,7 +68,7 @@ class DirMap(object):
             if node.values:
                 # Leaf
                 with open("/".join(path), "w") as f:
-                    arr = [",".join([str(b) for b in n]) for n in node.values]
+                    arr = [", ".join([str(b) for b in n]) for n in sorted(node.values, key=lambda node: int(node[0]))]
                     f.write("\n".join(arr) + "\n")
             elif not os.path.isdir(out_path):
                 os.mkdir(out_path)
diff --git a/parse/sched.py b/parse/sched.py
index bbf6e10..65df8ac 100644
--- a/parse/sched.py
+++ b/parse/sched.py
@@ -15,7 +15,7 @@ import pprint
 
 from collections import namedtuple,defaultdict
 from operator import methodcaller
-from point import Measurement,Type
+from point import Measurement,Type,ExpPoint
 
 PARAM_RECORD = r"(?P<RECORD>" +\
   r"PARAM *?(?P<PID>\d+)\/.*?" +\
@@ -43,6 +43,7 @@ COMPLETION_RECORD = r"(?P<RECORD>" +\
 
 TaskConfig = namedtuple('TaskConfig', ['cpu','wcet','period','type','level'])
 Task = namedtuple('Task', ['pid', 'config', 'run'])
+SchedReturn = namedtuple('SchedReturn', ['util', 'wcet_scales'])
 
 class LeveledArray(object):
     """
@@ -193,7 +194,8 @@ def extract_variance(task_dict, data, exp_point):
             raise Exception("Invalid completion record, missed: %d:"
                             "\n\t%s\n\t%s" % (missed[pid], match.groupdict(),
                                               match.group("RECORD")))
-        completions[pid] += [duration]
+        if duration or not completions[pid]:
+            completions[pid] += [duration]
 
     for pid, durations in completions.iteritems():
         m = Measurement(pid).from_array(durations)
@@ -257,11 +259,21 @@ def get_base_stats(base_file):
     saved_stats[base_file] = result
     return result
 
+def compute_util(task_dict):
+    util = 0
+    for task in task_dict.itervalues():
+        if task.config.level.lower() == "b":
+            util += float(task.config.wcet) / task.config.period
+    return util
+
 def extract_scaling_data(task_dict, data, result, base_file):
     # Generate trees of tasks with matching configurations
     data_stats = config_exit_stats(task_dict, data)
     base_stats = get_base_stats(base_file)
 
+    util = compute_util(task_dict)
+    by_wcet = defaultdict(lambda:[])
+
     # Scaling factors are calculated by matching groups of tasks with the same
     # config, then comparing task-to-task exec times in order of PID within
     # each group
@@ -269,7 +281,8 @@ def extract_scaling_data(task_dict, data, result, base_file):
     avg_scales = LeveledArray("avg-scaling")
 
     for config in data_stats:
-        if len(data_stats[config]) != len(base_stats[config]):
+        # if len(data_stats[config]) != len(base_stats[config]):
+        if len(data_stats[config]) >1 or len(base_stats[config]) > 1:
             # Quit, we are missing a record and can't guarantee
             # a task-to-task comparison
             continue
@@ -282,14 +295,25 @@ def extract_scaling_data(task_dict, data, result, base_file):
             avg_scale = float(base_stat[Type.Avg]) / float(data_stat[Type.Avg])
             max_scale = float(base_stat[Type.Max]) / float(data_stat[Type.Max])
 
+            if (avg_scale < 1 or max_scale < 1) and config.level.lower() == "b":
+                print("Task with config {} has sub 1.0 scaling factors!".format(config))
+                continue
+
             task = task_dict[data_stat.id]
 
             avg_scales.add(task, avg_scale)
             max_scales.add(task, max_scale)
 
+            name = "scaling-exp-{}".format(config.level)
+            loop_data = {Type.Avg:avg_scale, Type.Max:max_scale, Type.Var:0}
+            loop_exp = ExpPoint("scaling-id",{name: Measurement("", loop_data)})
+            by_wcet[config.wcet] += [loop_exp]
+
     avg_scales.write_measurements(result)
     max_scales.write_measurements(result)
 
+    return SchedReturn(util, by_wcet)
+
 def extract_sched_data(data_file, result, base_file):
     with open(data_file, 'r') as f:
         data = f.read()
@@ -300,8 +324,9 @@ def extract_sched_data(data_file, result, base_file):
         extract_tardy_vals(task_dict, data, result)
         extract_variance(task_dict, data, result)
     except Exception as e:
-        print("Error in %s" % data_file)
         raise e
 
     if (base_file):
-        extract_scaling_data(task_dict, data, result, base_file)
+        return extract_scaling_data(task_dict, data, result, base_file)
+    else:
+        return None
diff --git a/parse_exps.py b/parse_exps.py
index 87d0783..6a07ebc 100755
--- a/parse_exps.py
+++ b/parse_exps.py
@@ -16,6 +16,8 @@ from optparse import OptionParser
 from parse.point import ExpPoint
 from parse.tuple_table import ColMap,TupleTable
 
+# TODO: make 2-level graph optional
+
 def parse_args():
     # TODO: convert data-dir to proper option, clean 'dest' options
     parser = OptionParser("usage: %prog [options] [data_dir]...")
@@ -107,6 +109,17 @@ def gen_exp_data(exp_dirs, base_conf, col_map, force):
     sys.stderr.write('\n')
     return (plain_exps, scaling_bases)
 
+PAGE_SIZE=4092
+PROCS=4
+def compute_loops(util, dist, cost, wss):
+    scale = PROCS * dist / util
+    cost *= scale
+    pages = wss / PAGE_SIZE
+    per_loop = .023 * pages
+    loops = int(cost / per_loop) + 1
+    loops = loops + (5 - loops % 5)
+    return loops
+
 def main():
     opts, args = parse_args()
 
@@ -129,8 +142,14 @@ def main():
         for param in opts.ignore.split(","):
             col_map.try_remove(param)
 
+    # Begin coupling
+    loop_map = copy.deepcopy(col_map)
+    loop_map.try_remove('num_tasks')
+    loop_map.force_add('loops')
+
     base_table   = TupleTable(base_map) # For tracking 'base' experiments
     result_table = TupleTable(col_map)  # For generating output
+    loop_table   = TupleTable(loop_map) # For by-reuse scaling factor
 
     # Used to find matching scaling_base for each experiment
     for base in scaling_bases:
@@ -153,8 +172,17 @@ def main():
                 base = base_table.get_exps(base_params)[0]
 
             # Write deadline misses / tardiness into result
-            st.extract_sched_data(exp.data_files.st, result,
-                                  base.data_files.st if base else None)
+            sret = st.extract_sched_data(exp.data_files.st, result,
+                                           base.data_files.st if base else None)
+            # Terrible
+            if sret:
+                for wcet, points in sret.wcet_scales.iteritems():
+                    loop_params = copy.deepcopy(exp.params)
+                    # loops = compute_loops(sret.util, float(exp.params['hrt_dist']),
+                    #                       wcet, float(exp.params['wss']))
+                    # loop_params['loops'] = loops# * int(exp.params['wss'])
+                    for point in points:
+                        loop_table.add_exp(loop_params, point)
 
         result_table.add_exp(exp.params, result)
 
@@ -168,14 +196,20 @@ def main():
         sh.rmtree(opts.out)
 
     result_table.reduce()
+    loop_table.reduce()
 
     sys.stderr.write("Writing result...\n")
     if opts.write_map:
         # Write summarized results into map
         result_table.write_map(opts.out)
+        if base_conf:
+            loop_table.write_map(opts.out)
     else:
         # Write out csv directories for all variable params
         result_table.write_csvs(opts.out)
+        if base_conf:
+            loop_table.write_csvs(opts.out)
+
 
 if __name__ == '__main__':
     main()