1) store latency info. 2) heur. aggress. dp param

Two changes. (1) Compute comparative latency information
for task sets that are schedulable under all partitioning
methods. (2) Make heuristic aggressiveness a design point
parameter.

1 files changed, 98 insertions, 57 deletions

diff --git a/ecrts14/ecrts14.py b/ecrts14/ecrts14.py
index 85c2ff6..9955227 100755
--- a/ecrts14/ecrts14.py
+++ b/ecrts14/ecrts14.py
@@ -107,15 +107,17 @@ TESTS = [
     (1, "MaximizeParallelism", tests.test_partition_parallel),
     (2, "CacheAware", tests.test_partition_cache_aware),
     (3, "CacheAwareEdges", tests.test_partition_cache_aware_edges),
-#    ("MaximizeParallelismCacheAware", tests.test_partition_parallel2)
     (4, "CacheAwareBFSEdges", tests.test_partition_cache_aware_bfs),
     (5, "CacheAwareDFSEdges", tests.test_partition_cache_aware_dfs)
+#    (6, "MaximizeParallelismCacheAware", tests.test_partition_parallel2)
 ]
 
-MIN_SAMPLES = 200
-MAX_SAMPLES = 500
-#MIN_SAMPLES = 1000
-#MAX_SAMPLES = 10000
+#MIN_SAMPLES = 2
+#MAX_SAMPLES = 2
+#MIN_SAMPLES = 200
+#MAX_SAMPLES = 500
+MIN_SAMPLES = 500
+MAX_SAMPLES = 10000
 MAX_CI      = 0.05
 CONFIDENCE  = 0.95
 
@@ -281,64 +283,90 @@ def process_dp(_dp):
     dp.sched = 'edf'
     dp.walk = 'seq'
     
-    results = defaultdict(float)
-
-#    avg_nr_graphs = defaultdict(float)
-#    avg_graph_k   = defaultdict(float)
-    avg_latencies = defaultdict(float)
-    avg_ideal_ratios = defaultdict(float)
-    avg_hrt_ratios = defaultdict(float)
-    nsched = defaultdict(int)
-    
+    __avg_sched = defaultdict(float)
+
+    __avg_nr_graphs = defaultdict(float)
+    __avg_k = defaultdict(float)
+    __avg_latencies = defaultdict(float)
+    __avg_tard_ratios = defaultdict(float)
+    __avg_hrt_ratios = defaultdict(float)
+
+    n_methods = len(TESTS)
     n = 0
+    n_all_sched = 0
 
     overheads = get_overheads(dp, dp.system)
-    
-    while not complete(results, n):
+
+    while not complete(__avg_sched, n):
         ts, graphs, subts = create_pgm_task_set(dp)
 
-#        hrt_ideal_response_times = map(graph.compute_hrt_ideal_response_time, graphs)
-#        num_graphs = len(graphs)
+        num_graphs = len(graphs)
+        avg_depth = sum([g.depth for g in graphs])/float(num_graphs)
+        hrt_ideal_response_times = map(graph.compute_hrt_ideal_response_time, graphs)
+
+        this_task_set = {}
 
         if dp.nr_clusters != 1:
             for method, _, test in TESTS:
-                result, processed_ts = test(ts, graphs, subts, dp, overheads)
-                if result:
-#                    ideal_response_times = map(graph.compute_ideal_response_time, graphs)
-#                    srt_response_times = map(graph.bound_graph_response_time, graphs)
-#                    ideal_ratio = 0.0
-#                    hrt_ratio = 0.0
-#                    for i, h, s in zip(ideal_response_times, hrt_ideal_response_times, srt_response_times):
-#                        ideal_ratio += s/i
-#                        hrt_ratio += s/h
-#
-#                    ideal_ratio /= num_graphs
-#                    hrt_ratio /= num_graphs
-#                    avg_latency = sum(srt_response_times)/num_graphs
-#                    avg_latencies[method] = update_mean(avg_latencies[method], nsched[method], avg_latency)
-#                    avg_ideal_ratios[method] = update_mean(avg_ideal_ratios[method], nsched[method], ideal_ratio)
-#                    avg_hrt_ratios[method] = update_mean(avg_hrt_ratios[method], nsched[method], hrt_ratio)
-                    nsched[method] += 1
-                results[method] = update_mean(results[method], n, result)
-
-        # if there is no partitioning, then same results hold for all tests
+                is_sched, processed_ts = test(ts, graphs, subts, dp, overheads)
+                this_method = {}
+                this_method['sched'] = is_sched
+                if is_sched:
+                    this_method['latencies'] = map(graph.bound_graph_response_time, graphs)
+                    this_method['ideal_latencies'] = map(graph.compute_ideal_response_time, graphs)
+                this_task_set[method] = this_method
         else:
-            result, processed_ts = TESTS[0][2](ts, graphs, subts, dp, overheads)
-            if result:
-                for method, name, test in TESTS:
-                    nsched[method] += 1
-            for method, name, test in TESTS:
-                results[method] = update_mean(results[method], n, result)
-
+            # global. no partitioning. all methods equivelent
+            is_sched, processed_ts = TESTS[0][2](ts, graphs, subts, dp, overheads)
+            this_method = {}
+            this_method['sched'] = is_sched
+            if is_sched:
+                this_method['latencies'] = map(graph.bound_graph_response_time, graphs)
+                this_method['ideal_latencies'] = map(graph.compute_ideal_response_time, graphs)
+            for method, _, _ in TESTS:
+                this_task_set[method] = this_method
+
+        num_method_sched = sum([1 for sched_data in this_task_set.itervalues() if sched_data['sched']])
+        all_sched = True if num_method_sched == n_methods else False
+
+        # process the results
+
+        for method, sched_data in this_task_set.iteritems():
+            is_sched = sched_data['sched']
+            __avg_sched[method] = update_mean(__avg_sched[method], n, is_sched)
+
+            # only include latency data for task sets that were schedulable for all methods
+            if all_sched:
+                avg_latency = sum(sched_data['latencies'])/float(num_graphs)
+                avg_tard_ratio = 0.0
+                avg_hrt_tard_ratio = 0.0
+                for latency, ideal_latency, hrt_latency in zip(sched_data['latencies'], sched_data['ideal_latencies'], hrt_ideal_response_times):
+                    avg_tard_ratio += (latency / ideal_latency)
+                    avg_hrt_tard_ratio += (latency / hrt_latency)
+                avg_tard_ratio /= float(num_graphs)
+                avg_hrt_tard_ratio /= float(num_graphs)
+
+                __avg_latencies[method] = update_mean(__avg_latencies[method], n_all_sched, avg_latency)
+                __avg_tard_ratios[method] = update_mean(__avg_tard_ratios[method], n_all_sched, avg_tard_ratio)
+                __avg_hrt_ratios[method] = update_mean(__avg_hrt_ratios[method], n_all_sched, avg_hrt_tard_ratio)
+
+                # we could share these values across all methods
+                __avg_nr_graphs[method] = update_mean(__avg_nr_graphs[method], n_all_sched, num_graphs)
+                __avg_k[method] = update_mean(__avg_k[method], n_all_sched, avg_depth)
+
+        if all_sched:
+            n_all_sched += 1
         n += 1
 
-#    for method, _, _ in TESTS:
-#        if nsched[method] == 0:
-#            avg_latencies[method] = -1.0
-#            avg_ideal_ratios[method] = -1.0
-#            avg_hrt_ratios[method] = -1.0
+    if n_all_sched == 0:
+        for method, _, _ in TESTS:
+            __avg_latencies[method] = -1.0
+            __avg_tard_ratios[method] = -1.0
+            __avg_hrt_ratios[method] = -1.0
+            __avg_nr_graphs[method] = 0.0
+            __avg_k[method] = 0.0
 
-    return results, avg_latencies, avg_ideal_ratios, avg_hrt_ratios
+    return __avg_sched, __avg_latencies, __avg_tard_ratios, __avg_hrt_ratios, __avg_nr_graphs, __avg_k
 
 def process_design_points(args):
     try:
@@ -347,13 +375,25 @@ def process_design_points(args):
         while True:
             dp = db.get_design_point(db_name)
             if dp and not db.already_processed(dp, db_name = db_name):
-                (sched, avg_lat, avg_idl_rat, avg_hrt_rat) = process_dp(dp)
-                db.store_sched_results(db_name, dp, sched)
+                (avg_sched, avg_lat, avg_tard_ratio, avg_hrt_tard_ratio, avg_nr_graphs, avg_k) = process_dp(dp)
+
+                sched_data = {}
+                for m, _, _ in TESTS:
+                    results = storage()
+                    results.avg_sched = avg_sched[m]
+                    results.avg_latency = avg_lat[m]
+                    results.avg_tard_ratio = avg_tard_ratio[m]
+                    results.avg_hrt_tard_ratio = avg_hrt_tard_ratio[m]
+                    results.avg_nr_graphs = avg_nr_graphs[m]
+                    results.avg_k = avg_k[m]
+                    sched_data[m] = results
+
+                db.store_sched_results(db_name, dp, sched_data)
                 nr_processed += 1
             else:
                 break
     except lite.OperationalError:
-        print "FUCK!"
+        print "CRAP. Database Error!"
         print traceback.format_exc()
     return nr_processed
 
@@ -390,14 +430,14 @@ def main():
         # system parameters
         exp.processors = [int(cpus)]
 #        exp.nr_clusters = [1, 4, 12, 24]
-        exp.nr_clusters = [1, 4, 12]
+        exp.nr_clusters = [1, 4, 12, 24]
         exp.host = ['ludwig']
         exp.polluters = [False]
         exp.ovh_type = ['max']
 
         # task parameters
-        step_size = 0.2
-        exp.sys_util =  [float(v) for v in arange(6.0, cpus+step_size, step_size)]
+        step_size = 0.1
+        exp.sys_util =  [float(v) for v in arange(step_size, cpus+step_size, step_size)]
         exp.task_util = ['uni-medium']
         exp.period =    ['uni-long']
         exp.wcycle =    [0]
@@ -411,6 +451,7 @@ def main():
         exp.edge_distance =  ['geometric_3']
         exp.wss =            ['bimo-medium']
         exp.fan_in_cap =     [3]
+        exp.heur_aggressiveness = [0.6, 0.75, 0.9]
 
         design_points = [dp for dp in DesignPointGenerator(exp, is_valid = valid)]