Added option to ignore environment issues and rewrote part of the generation scripts for easier generator creation.

6 files changed, 93 insertions, 49 deletions

diff --git a/common.py b/common.py
index cba31bf..a26ac94 100644
--- a/common.py
+++ b/common.py
@@ -50,6 +50,12 @@ def get_config_option(option):
     else:
         raise IOError("No config file exists!")
 
+def try_get_config_option(option, default):
+    try:
+        get_config_option(option)
+    except:
+        return default
+
 def recordtype(typename, field_names, default=0):
     ''' Mutable namedtuple. Recipe from George Sakkis of MIT.'''
     field_names = tuple(map(str, field_names))
@@ -127,10 +133,7 @@ def load_params(fname):
     with open(fname, 'r') as f:
         data = f.read()
     try:
-        parsed = eval(data)
-        # Convert to defaultdict
-        for k in parsed:
-            params[k] = str(parsed[k])
+        params = eval(data)
     except Exception as e:
         raise IOError("Invalid param file: %s\n%s" % (fname, e))
 
diff --git a/gen/edf_generators.py b/gen/edf_generators.py
index c7267f7..9bf6b8f 100644
--- a/gen/edf_generators.py
+++ b/gen/edf_generators.py
@@ -1,15 +1,20 @@
 import generator as gen
 import random
-import schedcat.generator.tasks as tasks
+
+TP_TBASE = """#for $t in $task_set
+{} $t.cost $t.period
+#end for"""
+TP_GLOB_TASK = TP_TBASE.format("")
+TP_PART_TASK = TP_TBASE.format("-p $t.cpu")
 
 class EdfGenerator(gen.Generator):
     '''Creates sporadic task sets with the most common Litmus options.'''
     def __init__(self, name, templates, options, params):
         super(EdfGenerator, self).__init__(name, templates,
-                                           self.__make_options(params) + options,
+                                           self.__make_options() + options,
                                            params)
 
-    def __make_options(self, params):
+    def __make_options(self):
         '''Return generic EDF options.'''
         return [gen.Generator._dist_option('utils', ['uni-medium'],
                                            gen.NAMED_UTILIZATIONS,
@@ -26,23 +31,12 @@ class EdfGenerator(gen.Generator):
         udist = self._create_dist('utilization',
                                   exp_params['utils'],
                                   gen.NAMED_UTILIZATIONS)
-        tg = tasks.TaskGenerator(period=pdist, util=udist)
 
-        ts = []
-        tries = 0
-        while len(ts) != exp_params['num_tasks'] and tries < 5:
-            ts = tg.make_task_set(max_tasks = exp_params['num_tasks'])
-            tries += 1
-        if len(ts) != exp_params['num_tasks']:
-            print("Failed to create task set with parameters: %s" % exp_params)
+        ts = self._create_taskset(exp_params, pdist, udist)
 
         self._customize(ts, exp_params)
 
-        exp_params['task_set'] = ts
-        self._write_schedule(exp_params)
-
-        del exp_params['task_set']
-        del exp_params['num_tasks']
+        self._write_schedule(dict(exp_params.items() + ('task_set', ts)))
         self._write_params(exp_params)
 
     def _customize(self, taskset, exp_params):
@@ -53,7 +47,7 @@ class EdfGenerator(gen.Generator):
 class PartitionedGenerator(EdfGenerator):
     def __init__(self, name, templates, options, params):
         super(PartitionedGenerator, self).__init__(name,
-            templates + [gen.TP_PART_TASK], options, params)
+            templates + [TP_PART_TASK], options, params)
 
     def _customize(self, taskset, exp_params):
         start = 1 if exp_params['release_master'] else 0
@@ -78,5 +72,5 @@ class CedfGenerator(PartitionedGenerator):
 
 class GedfGenerator(EdfGenerator):
     def __init__(self, params={}):
-        super(GedfGenerator, self).__init__("GSN-EDF", [gen.TP_GLOB_TASK],
+        super(GedfGenerator, self).__init__("GSN-EDF", [TP_GLOB_TASK],
                                             [], params)
diff --git a/gen/generator.py b/gen/generator.py
index 8c3048b..3a6524d 100644
--- a/gen/generator.py
+++ b/gen/generator.py
@@ -1,10 +1,11 @@
 import gen.rv as rv
 import os
+import pprint
+import schedcat.generator.tasks as tasks
 import shutil as sh
 
 from Cheetah.Template import Template
-from collections import namedtuple
-from common import get_config_option,num_cpus
+from common import get_config_option,num_cpus,recordtype
 from config.config import DEFAULTS,PARAMS
 from gen.dp import DesignPointGenerator
 from parse.col_map import ColMapBuilder
@@ -21,6 +22,7 @@ NAMED_UTILIZATIONS = {
     'uni-light'     : rv.uniform(0.001, 0.1),
     'uni-medium'    : rv.uniform(  0.1, 0.4),
     'uni-heavy'     : rv.uniform(  0.5, 0.9),
+    'uni-mixed'     : rv.uniform(0.001, .4),
 
     'exp-light'     : rv.exponential(0, 1, 0.10),
     'exp-medium'    : rv.exponential(0, 1, 0.25),
@@ -36,15 +38,12 @@ NAMED_UTILIZATIONS = {
 
 '''Components of Cheetah template for schedule file'''
 TP_RM = """#if $release_master
-release_master{1}
+release_master{0}
 #end if"""
-TP_TBASE = """#for $t in $task_set
-{} $t.cost $t.period
-#end for"""
-TP_GLOB_TASK = TP_TBASE.format("")
-TP_PART_TASK = TP_TBASE.format("-p $t.cpu")
 
-GenOption = namedtuple('GenOption', ['name', 'types', 'default', 'help'])
+GenOptionT = recordtype('GenOption', ['name', 'types', 'default', 'help', 'hidden'])
+def GenOption(name, types, default, help, hidden = False):
+    return GenOptionT(name, types, default, help, hidden)
 
 class Generator(object):
     '''Creates all combinations @options specified by @params.
@@ -92,36 +91,65 @@ class Generator(object):
     def _create_dist(self, name, value, named_dists):
         '''Attempt to create a distribution representing the data in @value.
         If @value is a string, use it as a key for @named_dists.'''
-        name = "%s distribution" % name
         # A list of values
         if type(value) == type([]):
             map(lambda x : self.__check_value(name, x, [float, int]), value)
             return rv.uniform_choice(value)
         elif type(value) in [float, int]:
             return lambda : value
-        elif value in named_dists:
+        elif named_dists and value in named_dists:
             return named_dists[value]
         else:
             raise ValueError("Invalid %s value: %s" % (name, value))
 
+    def _create_taskset(self, params, periods, utils, max_util = None):
+        tg = tasks.TaskGenerator(period=periods, util=utils)
+        ts = []
+        tries = 0
+        while len(ts) != params['num_tasks'] and tries < 100:
+            ts = tg.make_task_set(max_tasks = params['num_tasks'], max_util=max_util)
+            tries += 1
+        if len(ts) != params['num_tasks']:
+            print(("Only created task set of size %d < %d for params %s. " +
+                   "Switching to light utilization.") %
+                  (len(ts), params['num_tasks'], params))
+            print("Switching to light util. This usually means the " +
+                  "utilization distribution is too agressive.")
+            return self._create_taskset(params, periods, NAMED_UTILIZATIONS['uni-light'],
+                                        max_util)
+        return ts
+