Track avg graph size, taskset size. D.P. for job split

1 files changed, 45 insertions, 15 deletions

diff --git a/ecrts14/ecrts14.py b/ecrts14/ecrts14.py
index 9955227..ff772b5 100755
--- a/ecrts14/ecrts14.py
+++ b/ecrts14/ecrts14.py
@@ -57,12 +57,12 @@ NAMED_PERIODS_US = {
 #based off of a 24-core system
 # fewer graphs = harder partitioning
 NAMED_NUM_GRAPHS = {
-    'uni-many'   : graph.uniform(24, 24*4),
-    'uni-medium' : graph.uniform(12, 48),
+    'uni-many'   : graph.uniform(24, 24*3),
+    'uni-medium' : graph.uniform(12, 24),
     'uni-few'    : graph.uniform(1,12),
 
-    'bimo-many'   : graph.binomial(24, 24*4),
-    'bimo-medium' : graph.binomial(12, 48),
+    'bimo-many'   : graph.binomial(24, 24*3),
+    'bimo-medium' : graph.binomial(12, 24),
     'bimo-few'    : graph.binomial(1,12),
 }
 
@@ -81,13 +81,15 @@ NAMED_HEIGHT_FACTORS = {
 NAMED_FAN = {
     'none'        : graph.uniform(1,1),
     'uniform_3'   : graph.uniform(1,3),
+    'uniform_6'   : graph.uniform(1,6),
     'geometric_3' : graph.geometric(1,3),
+    'geometric_6' : graph.geometric(1,3),
 }
 
 NAMED_EDGE_HOP = {
     'none'       : graph.uniform(1,1),
     'uniform_3'  : graph.uniform(1,3),
-    'uniform_deep'  : graph.uniform(1,100),
+    'uniform_deep' : graph.uniform(1,100),
     'geometric_3': graph.geometric(1,3),
 }
 
@@ -116,7 +118,7 @@ TESTS = [
 #MAX_SAMPLES = 2
 #MIN_SAMPLES = 200
 #MAX_SAMPLES = 500
-MIN_SAMPLES = 500
+MIN_SAMPLES = 1000
 MAX_SAMPLES = 10000
 MAX_CI      = 0.05
 CONFIDENCE  = 0.95
@@ -285,7 +287,9 @@ def process_dp(_dp):
     
     __avg_sched = defaultdict(float)
 
+    __avg_ts_size = defaultdict(float)
     __avg_nr_graphs = defaultdict(float)
+    __avg_graph_size = defaultdict(float)
     __avg_k = defaultdict(float)
     __avg_latencies = defaultdict(float)
     __avg_tard_ratios = defaultdict(float)
@@ -302,6 +306,7 @@ def process_dp(_dp):
 
         num_graphs = len(graphs)
         avg_depth = sum([g.depth for g in graphs])/float(num_graphs)
+        avg_graph_size = sum([len(g.nodes) for g in graphs])/float(num_graphs)
         hrt_ideal_response_times = map(graph.compute_hrt_ideal_response_time, graphs)
 
         this_task_set = {}
@@ -326,7 +331,7 @@ def process_dp(_dp):
             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']])
+        num_method_sched = sum([1 for sched_data in this_task_set.itervalues() if sched_data['sched'] == True])
         all_sched = True if num_method_sched == n_methods else False
 
         # process the results
@@ -341,6 +346,8 @@ def process_dp(_dp):
                 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):
+                    if ideal_latency == 0.0:
+                        print 'ecrts14.py: bad latency. latency values:',sched_data
                     avg_tard_ratio += (latency / ideal_latency)
                     avg_hrt_tard_ratio += (latency / hrt_latency)
                 avg_tard_ratio /= float(num_graphs)
@@ -351,7 +358,9 @@ def process_dp(_dp):
                 __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_ts_size[method] = update_mean(__avg_ts_size[method], n_all_sched, len(ts))
                 __avg_nr_graphs[method] = update_mean(__avg_nr_graphs[method], n_all_sched, num_graphs)
+                __avg_graph_size[method] = update_mean(__avg_graph_size[method], n_all_sched, avg_graph_size)
                 __avg_k[method] = update_mean(__avg_k[method], n_all_sched, avg_depth)
 
         if all_sched:
@@ -363,10 +372,12 @@ def process_dp(_dp):
             __avg_latencies[method] = -1.0
             __avg_tard_ratios[method] = -1.0
             __avg_hrt_ratios[method] = -1.0
+            __avg_ts_size[method] = 0.0
             __avg_nr_graphs[method] = 0.0
+            __avg_graph_size[method] = 0.0
             __avg_k[method] = 0.0
 
-    return __avg_sched, __avg_latencies, __avg_tard_ratios, __avg_hrt_ratios, __avg_nr_graphs, __avg_k
+    return __avg_sched, __avg_latencies, __avg_tard_ratios, __avg_hrt_ratios, __avg_ts_size, __avg_nr_graphs, __avg_graph_size, __avg_k
 
 def process_design_points(args):
     try:
@@ -375,7 +386,7 @@ 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):
-                (avg_sched, avg_lat, avg_tard_ratio, avg_hrt_tard_ratio, avg_nr_graphs, avg_k) = process_dp(dp)
+                (avg_sched, avg_lat, avg_tard_ratio, avg_hrt_tard_ratio, avg_ts_size, avg_nr_graphs, avg_size, avg_k) = process_dp(dp)
 
                 sched_data = {}
                 for m, _, _ in TESTS:
@@ -384,7 +395,9 @@ def process_design_points(args):
                     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_ts_size = avg_ts_size[m]
                     results.avg_nr_graphs = avg_nr_graphs[m]
+                    results.avg_graph_size = avg_size[m]
                     results.avg_k = avg_k[m]
                     sched_data[m] = results
 
@@ -400,6 +413,17 @@ def process_design_points(args):
 def valid(dp):
     return True
 
+# TODO:
+#XXX 1. Track average graph size.
+#XXX 2. Increase minimum number of task sets
+#XXX 3. Remove 'mean' overhead type
+#XXX 4. Explore more branchy graphs
+#XXX 5. Pick one heur_aggress value (0.75)
+#XXX 6. Add wss parameters.
+#XXX 7. Remove polluters (for now).
+# 8. Why are graphs so shallow?
+#XXX 9. Job splitting
+
 def main():
     random.seed(12345)
 
@@ -432,26 +456,29 @@ def main():
 #        exp.nr_clusters = [1, 4, 12, 24]
         exp.nr_clusters = [1, 4, 12, 24]
         exp.host = ['ludwig']
+#        exp.polluters = [False, True]
         exp.polluters = [False]
         exp.ovh_type = ['max']
 
         # task parameters
         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.task_util = ['uni-light', 'uni-medium']
         exp.period =    ['uni-long']
+#        exp.job_splitting = [True, False]
+        exp.job_splitting = [True]
         exp.wcycle =    [0]
 
         # graph parameters
-        exp.num_graphs =     ['bimo-few', 'bimo-medium']
+        exp.num_graphs =     ['uni-few', 'uni-medium']
 #        exp.depth_factor =   ['uni-medium']
-        exp.depth_factor =   ['uni-short', 'uni-tall']
+        exp.depth_factor =   ['uni-short', 'uni-medium', 'uni-tall']
         exp.node_placement = ['binomial']
-        exp.fan_out =        ['geometric_3']
+        exp.fan_out =        ['uniform_3', 'uniform_6']
         exp.edge_distance =  ['geometric_3']
-        exp.wss =            ['bimo-medium']
+        exp.wss =            ['uni-light', 'uni-medium', 'bimo-medium']
         exp.fan_in_cap =     [3]
-        exp.heur_aggressiveness = [0.6, 0.75, 0.9]
+        exp.heur_aggressiveness = [0.75]
 
         design_points = [dp for dp in DesignPointGenerator(exp, is_valid = valid)]
 
@@ -464,6 +491,9 @@ def main():
     if args.pretend or args.initonly:
         exit(0)
 
+    if args.worker:
+        print "Running as worker process."
+
     total_nr_processed = 0
     if args.processors > 1:
         pool = Pool(processes = args.processors)