12 files changed, 525 insertions, 20 deletions

diff --git a/common.py b/common.py
index 0990cfe..ad3c418 100644
--- a/common.py
+++ b/common.py
@@ -1,9 +1,14 @@
+import os
+import re
+import subprocess
 import sys
+
 from collections import defaultdict
 from textwrap import dedent
 
 def get_executable(prog, hint, optional=False):
-    import os
+    '''Search for @prog in system PATH. Print @hint if no binary is found.'''
+
     def is_exe(fpath):
         return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
 
@@ -19,12 +24,29 @@ def get_executable(prog, hint, optional=False):
 
     if not optional:
         sys.stderr.write("Cannot find executable '%s' in PATH. This is a part "
-                         "of '%s' which should be added to PATH to run." %
+                         "of '%s' which should be added to PATH to run.\n" %
                          (prog, hint))
         sys.exit(1)
     else:
         return None
 
+def get_config_option(option):
+    '''Search for @option in installed kernel config (if present).
+    Raise an IOError if the kernel config isn't found in /boot/.'''
+    uname = subprocess.check_output(["uname", "-r"])[-1]
+    fname = "/boot/config-%s" % uname
+
+    if os.path.exists(fname):
+        config_regex = "^CONFIG_{}=(?P<val>.*)$".format(option)
+        match = re.search(config_regex, open(fname, 'r').read())
+        if not match:
+            return None
+        else:
+            return match.group("val")
+
+    else:
+        raise IOError("No config file exists!")
+
 def recordtype(typename, field_names, default=0):
     ''' Mutable namedtuple. Recipe from George Sakkis of MIT.'''
     field_names = tuple(map(str, field_names))
diff --git a/config/config.py b/config/config.py
index 3282705..d463999 100644
--- a/config/config.py
+++ b/config/config.py
@@ -17,18 +17,20 @@ BINS = {'rtspin'    : get_executable('rtspin', 'liblitmus'),
 FILES = {'ft_data'    : 'ft.bin',
          'linux_data' : 'trace.dat',
          'sched_data' : 'st-{}.bin',
-         'log_data'   : 'trace.slog',}
+         'log_data'   : 'trace.slog'}
 
 '''Default parameter names in params.py.'''
-PARAMS = {'sched'  : 'scheduler',
-          'dur'    : 'duration',
-          'kernel' : 'uname',
-          'cycles' : 'cpu-frequency'}
+# TODO: add check for config options
+PARAMS = {'sched'  : 'scheduler',     # Scheduler used by run_exps
+          'dur'    : 'duration',      # Duration of tests in run_exps
+          'kernel' : 'uname',         # Regex of required OS name in run_exps
+          'cycles' : 'cpu-frequency', # Frequency run_exps was run with
+          'tasks'  : 'tasks'          # Number of tasks
+          }
 
-'''Default values for program parameters.'''
+'''Default values for program options.'''
 DEFAULTS = {'params_file' : 'params.py',
             'sched_file'  : 'sched.py',
-            'exps_file'   : 'exps.py',
             'duration'    : 10,
             'spin'                : 'rtspin',
             'cycles'      : 2000}
diff --git a/gen/__init__.py b/gen/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/gen/__init__.py
diff --git a/gen/dp.py b/gen/dp.py
new file mode 100644
index 0000000..0ac8cce
--- /dev/null
+++ b/gen/dp.py
@@ -0,0 +1,33 @@
+from __future__ import division
+
+class DesignPointGenerator(object):
+    '''Iterates over all combinations of values specified in options.
+    Shamelessly stolen (and simplified) from bcw.'''
+    def __init__(self, options):
+        self.point_idx = 0  # Current point
+        self.options = options
+        self.total = 1
+        for x in options.itervalues():
+            self.total *= len(x)
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        while True:
+            if self.point_idx == self.total:
+                raise StopIteration
+            else:
+                point = {}
+
+                divisor = 1
+                for key in sorted(self.options.keys()):
+                    size = len(self.options[key])
+
+                    option_idx = int(self.point_idx / divisor) % size
+                    point[key] = self.options[key][option_idx]
+
+                    divisor *= size
+                self.point_idx += 1
+
+                return point
diff --git a/gen/generators.py b/gen/generators.py
new file mode 100644
index 0000000..2fc77a7
--- /dev/null
+++ b/gen/generators.py
@@ -0,0 +1,257 @@
+from Cheetah.Template import Template
+from collections import namedtuple
+from common import get_config_option
+from config.config import DEFAULTS
+from gen.dp import DesignPointGenerator
+from parse.tuple_table import ColMap
+
+import gen.rv as rv
+import os
+import random
+import run.litmus_util as lu
+import schedcat.generator.tasks as tasks
+import shutil as sh
+
+NAMED_PERIODS = {
+    'harmonic'            : rv.uniform_choice([25, 50, 100, 200]),
+    'uni-short'           : rv.uniform_int( 3,  33),
+    'uni-moderate'        : rv.uniform_int(10, 100),
+    'uni-long'            : rv.uniform_int(50, 250),
+}
+
+NAMED_UTILIZATIONS = {
+    'uni-very-light': rv.uniform(0.0001, 0.001),
+    'uni-light'     : rv.uniform(0.001, 0.1),
+    'uni-medium'    : rv.uniform(  0.1, 0.4),
+    'uni-heavy'     : rv.uniform(  0.5, 0.9),
+
+    'exp-light'     : rv.exponential(0, 1, 0.10),
+    'exp-medium'    : rv.exponential(0, 1, 0.25),
+    'exp-heavy'     : rv.exponential(0, 1, 0.50),
+
+    'bimo-light'    : rv.multimodal([(rv.uniform(0.001, 0.5), 8),
+                                     (rv.uniform(  0.5, 0.9), 1)]),
+    'bimo-medium'   : rv.multimodal([(rv.uniform(0.001, 0.5), 6),
+                                     (rv.uniform(  0.5, 0.9), 3)]),
+    'bimo-heavy'    : rv.multimodal([(rv.uniform(0.001, 0.5), 4),
+                                     (rv.uniform(  0.5, 0.9), 5)]),
+}
+
+# Cheetah templates for schedule files
+TP_CLUSTER = "plugins/C-EDF/cluster{$level}"
+TP_RM = """#if $release_master
+release_master{1}
+#end if"""
+TP_TBASE = """#for $t in $task_set
+{}$t.cost $t.period
+#end for"""
+TP_PART_TASK = TP_TBASE.format("-p $t.cpu ")
+TP_GLOB_TASK = TP_TBASE.format("")
+
+GenOption = namedtuple('GenOption', ['name', 'types', 'default', 'help'])
+
+class BaseGenerator(object):
+    '''Creates sporadic task sets with the most common Litmus options.'''
+    def __init__(self, name, templates, options, params):
+        self.options = self.__make_options() + options
+
+        self.__setup_params(params)
+
+        self.params   = params
+        self.template = "\n".join([TP_RM] + templates)
+        self.name     = name
+
+    def __make_options(self):
+        '''Return generic Litmus options.'''
+
+        # Guess defaults using the properties of this computer
+        cpus = lu.num_cpus()
+        try:
+            config = get_config_option("RELEASE_MASTER") and True
+        except:
+            config = False
+        release_master = list(set([False, config]))
+
+        list_types = [str, float, type([])]
+
+        return [GenOption('cpus', int, [cpus],
+                          'Number of processors on target system.'),
+                GenOption('num_tasks', int, range(cpus, 5*cpus, cpus),
+                          'Number of tasks per experiment.'),
+                GenOption('utils', list_types + NAMED_UTILIZATIONS.keys(),
+                          ['uni-medium'],'Task utilization distributions.'),
+                GenOption('periods', list_types + NAMED_PERIODS.keys(),
+