Manual merge of Namhoon's PGM exp generation

This patch merges in the work Namhoon did to support
PGM-based task set experiments.

7 files changed, 414 insertions, 30 deletions

diff --git a/config/config.py b/config/config.py
index 976974a..f2d068c 100644
--- a/config/config.py
+++ b/config/config.py
@@ -38,7 +38,8 @@ PARAMS = {'sched'   : 'scheduler',       # Scheduler used by run_exps
 
 '''Default values for program options.'''
 DEFAULTS = {'duration'    : 10,
-            'prog'        : 'rtspin',
+#            'prog'        : 'rtspin',
+            'prog'        : 'pgmrt',
             'out-gen'     : 'exps',
             'out-run'     : 'run-data',
             'out-parse'   : 'parse-data',
diff --git a/gen/__init__.py b/gen/__init__.py
index 654ac19..58f5cfa 100644
--- a/gen/__init__.py
+++ b/gen/__init__.py
@@ -1,7 +1,8 @@
 import generator as gen
 import edf_generators as edf
 
-gen.register_generator("G-EDF", edf.GedfGenerator)
-gen.register_generator("P-EDF", edf.PedfGenerator)
-gen.register_generator("C-EDF", edf.CedfGenerator)
-gen.register_generator("C-FL-split", edf.CflSplitGenerator)
+#gen.register_generator("G-EDF", edf.GedfGenerator)
+#gen.register_generator("P-EDF", edf.PedfGenerator)
+#gen.register_generator("C-EDF", edf.CedfGenerator)
+#gen.register_generator("C-FL-split", edf.CflSplitGenerator)
+gen.register_generator("C-FL-split", edf.CflSplitPgmGenerator)
diff --git a/gen/edf_generators.py b/gen/edf_generators.py
index ce99d05..58cbb0d 100644
--- a/gen/edf_generators.py
+++ b/gen/edf_generators.py
@@ -1,5 +1,13 @@
 import generator as gen
 import random
+import ecrts14.partition as partition
+import schedcat.sched.split_heuristic as split
+
+from ecrts14.ecrts14 import create_pgm_task_set
+from ecrts14.ecrts14 import get_overheads
+from config.config import FILES,PARAMS
+from schedcat.overheads.model import Overheads, CacheDelay, ConsumerOverheads, ProducerOverheads
+from ecrts14.tests import get_partitions
 
 TP_TBASE = """#for $t in $task_set
 {} $t.cost $t.period
@@ -8,6 +16,15 @@ TP_GLOB_TASK = TP_TBASE.format("")
 TP_PART_TASK = TP_TBASE.format("-p $t.cpu")
 TP_CLST_TASK = TP_TBASE.format("-p $t.cluster -z $t.cluster_sz")
 
+PARTITION_METHOD = {
+    'no_cache'              : partition.partition_no_cache,
+    'parallel'              : partition.partition_parallel,
+    'cache_aware'           : partition.partition_cache_aware,
+    'cache_aware_edges'     : partition.partition_cache_aware_edges,
+    'cache_aware_bfs'       : partition.partition_cache_aware_bfs,
+    'cache_aware_dfs'       : partition.partition_cache_aware_dfs,
+}
+
 class EdfGenerator(gen.Generator):
     '''Creates sporadic task sets with the most common Litmus options.'''
     def __init__(self, scheduler, templates, options, params):
@@ -39,12 +56,51 @@ class EdfGenerator(gen.Generator):
         self._customize(ts, exp_params)
 
         self._write_schedule(dict(exp_params.items() + [('task_set', ts)]))
+
         self._write_params(exp_params)
 
     def _customize(self, taskset, exp_params):
         '''Configure a generated taskset with extra parameters.'''
         pass
 
+class EdfPgmGenerator(gen.Generator):
+    '''Creates sporadic task sets with the most common Litmus options.'''
+    def __init__(self, scheduler, templates, options, params):
+        super(EdfPgmGenerator, self).__init__(scheduler, templates,
+                                           self.__make_options() + options,
+                                           params)
+
+    def __make_options(self):
+        '''Return generic EDF options.'''
+        return [gen.Generator._dist_option('utils', 'uni-medium',
+                                           gen.NAMED_UTILIZATIONS,
+                                           'Task utilization distributions.'),
+                gen.Generator._dist_option('periods', 'harmonic',
+                                           gen.NAMED_PERIODS,
+                                           'Task period distributions.')]
+
+    def _create_exp(self, dp, ts, graphs, subts):
+        '''Create a single experiment with @exp_params in @out_dir.'''
+
+        ts = self._customize(ts, graphs, subts, dp)
+
+        self._write_pgm_schedule(dict(dp.items() + [('task_set', ts)] + [('graphs', graphs)] + [('sub_task_set', subts)]))
+        self._write_params(dict(dp.items() + [('num_tasks', len(ts))]))
+
+    def _create_tasks(self, dp):
+        '''Create a task set.'''
+        ts, graphs, subts = create_pgm_task_set(dp)
+        # convert to ms
+        for t in ts:
+            t.cost = t.cost / 1000.0
+            t.period = t.period / 1000.0
+            t.deadline = t.deadline /1000.0
+
+        return ts, graphs, subts
+
+    def _customize(self, taskset, exp_params):
+        '''Configure a generated taskset with extra parameters.'''
+        pass
 
 class PartitionedGenerator(EdfGenerator):
     def __init__(self, scheduler, templates, options, params):
@@ -88,9 +144,6 @@ class CflSplitGenerator(EdfGenerator):
     TP_CLUSTER = "plugins/C-FL-split/cluster{$level}"
     CLUSTER_OPTION = gen.GenOption('level', ['L1', 'L2', 'L3', 'ALL'], 'L2',
                                    'Cache clustering level.',)
-#    CLUSTER_SZ_OPTION = gen.GenOption('cluster_size', ['1', '2', '6', '24'], '2',
-#                                   'Cluster size.',)
-
     def __init__(self, params={}):
         super(CflSplitGenerator, self).__init__("C-FL-split",
                                             [CflSplitGenerator.TP_CLUSTER, TP_CLST_TASK],
@@ -99,8 +152,6 @@ class CflSplitGenerator(EdfGenerator):
 
     def _customize(self, taskset, exp_params):
         cpus = int(exp_params['cpus'])
-#        cluster_sz = int(exp_params['cluster_size'])
-
         if exp_params['level'] == 'L1':
             cluster_sz = 1
         elif exp_params['level'] == 'L2':
@@ -127,3 +178,44 @@ class GedfGenerator(EdfGenerator):
     def __init__(self, params={}):
         super(GedfGenerator, self).__init__("GSN-EDF", [TP_GLOB_TASK],
                                             [], params)
+
+class CflSplitPgmGenerator(EdfPgmGenerator):
+    TP_CLUSTER = "plugins/C-FL-split/cluster{$level}"
+    CLUSTER_OPTION = gen.GenOption('level', ['L1', 'L2', 'L3', 'ALL'], 'L2',
+                                   'Cache clustering level.',)
+
+    def __init__(self, params={}):
+        super(CflSplitPgmGenerator, self).__init__("C-FL-split",
+                                            [CflSplitPgmGenerator.TP_CLUSTER],
+                                            [CflSplitPgmGenerator.CLUSTER_OPTION],
+                                            params)
+
+    def _customize(self, ts, graphs, subts, dp):
+        exp_params = dict(dp.items())
+        cpus = int(exp_params['cpus'])
+
+        if exp_params['level'] == 'L1':
+            cluster_sz = 1
+        elif exp_params['level'] == 'L2':
+            cluster_sz = 2
+        elif exp_params['level'] == 'L3':
+            cluster_sz = 6
+        elif exp_params['level'] == 'ALL':
+            cluster_sz = 24
+        else:
+            assert False
+
+        dp.nr_clusters = cpus / cluster_sz
+        assert dp.nr_clusters * cluster_sz == cpus
+
+        overheads = get_overheads(dp, dp.system)
+        # do the partition here
+        ts = partition.clear_partitioning(ts)
+        ts = PARTITION_METHOD[exp_params['partitions']](ts, graphs, subts, cluster_sz, dp.nr_clusters, dp.system, dp.heur_aggressiveness, overheads)
+
+        # compute split factor
+        working_ts = ts
+        partitions = get_partitions(working_ts, dp.nr_clusters, cluster_sz)
+        is_srt_sched = split.compute_splits_nolock(overheads, False, working_ts, partitions, bypass_split = not dp.job_splitting)
+
+        return working_ts
diff --git a/gen/generator.py b/gen/generator.py
index 0999e84..7456021 100644
--- a/gen/generator.py
+++ b/gen/generator.py
@@ -3,12 +3,18 @@ import os
 import pprint
 import schedcat.generator.tasks as tasks
 import shutil as sh
+import ecrts14.topology as topology
+import ecrts14.graph as graph
 
 from Cheetah.Template import Template
 from common import get_config_option,num_cpus,recordtype
 from config.config import FILES,PARAMS
 from gen.dp import DesignPointGenerator
+from ecrts14.generator import DesignPointGenerator as PgmDesignPointGenerator
 from parse.col_map import ColMapBuilder
+from numpy import arange
+from schedcat.util.storage import storage
+from ecrts14.machines import machines
 
 NAMED_PERIODS = {
     'harmonic'            : rv.uniform_choice([25, 50, 100, 200]),
@@ -75,13 +81,14 @@ class Generator(object):
         release_master = list(set([False, bool(rm_config)]))
 
 
-        return [GenOption('tasks', int, range(cpus, 5*cpus, cpus),
-                              'Number of tasks per experiment.'),
+        return [GenOption('partitions', str, ['no_cache', 'parallel', 'cache_aware', 'cache_aware_edges', 'cache_aware_bfs', 'cache_aware_dfs'],
+                          'Partition methods.'),
+                GenOption('tasks', int, [0],
+                          'Number of tasks'),
                 GenOption('cpus', int, [cpus],
                           'Number of processors on target system.'),
                 GenOption('release_master', [True,False], release_master,
-                          'Redirect release interrupts to a single CPU.'),
-                GenOption('duration', float, [30], 'Experiment duration.')]
+                          'Redirect release interrupts to a single CPU.')]
 
     @staticmethod
     def _dist_option(name, default, distribution, help):
@@ -122,14 +129,93 @@ class Generator(object):
     def _write_schedule(self, params):
         '''Write schedule file using current template for @params.'''
         sched_file = self.out_dir + "/" + FILES['sched_file']
+
         with open(sched_file, 'wa') as f:
             f.write(str(Template(self.template, searchList=[params])))
 
+    def _write_pgm_schedule(self, pgm_params):
+        '''Write schedule file using current template for @params.'''
+        # make pgmrt arguments using graphs and tasks.
+        sched_file = self.out_dir + "/" + FILES['sched_file']
+
+        graph_desc_arg = []
+        rates_arg = []
+        exec_arg = []
+        cluster_arg = []
+        clustersz_arg = []
+        wss_arg = []
+        split_arg = []
+        for g in pgm_params['graphs']:
+            cluster_arg_t = []
+            graph_desc_arg_t = []
+            exec_arg_t = []
+            rates_arg_t = []
+            wss_arg_t = []
+            split_arg_t = []
+
+            for n in g.nodes:
+                assert n.graph.id == g.id
+                cluster_arg_t.append('node_' + str(n.id) + ':' + str(n.task.partition))
+                exec_arg_t.append('node_' + str(n.id) + ':' + str(n.task.cost))
+                split_arg_t.append('node_' + str(n.id) + ':' + str(n.task.split))
+                if n.isSrc == True:
+                    # assume that x=1
+                    rates_arg_t.append('node_' + str(n.id) + ':1:' + str(n.task.period))
+                    # get cluster size
+                    clustersz_arg_t = str(pgm_params['cpus'] / pgm_params['nr_clusters'])
+                if len(g.nodes) == 1:
+                    graph_desc_arg_t.append('node_' + str(n.id))
+                for succ in n.succ:
+                    graph_desc_arg_t.append('node_' + str(n.id) + ':node_' + str(succ.id))
+                # wss parameter
+                for e in n.outEdges:
+                    wss_arg_t.append('node_' + str(n.id) + ':node_' + str(e.s.id) + ':' + str(e.wss))
+
+            # combine arguments to a comma-separated string
+            cluster_arg_t = ','.join(cluster_arg_t)
+            graph_desc_arg_t = ','.join(graph_desc_arg_t)
+            exec_arg_t = ','.join(exec_arg_t)
+            wss_arg_t = ','.join(wss_arg_t)
+            split_arg_t = ','.join(split_arg_t)
+            rates_arg_t = ','.join(rates_arg_t)
+
+            cluster_arg.append(cluster_arg_t)
+            exec_arg.append(exec_arg_t)
+            graph_desc_arg.append(graph_desc_arg_t)
+            wss_arg.append(wss_arg_t)
+            split_arg.append(split_arg_t)
+            rates_arg.append(rates_arg_t)
+            clustersz_arg.append(clustersz_arg_t)
+            #print('----------')
+        #print(pgm_params)
+
+        pgm_args = []
+        for i in range(len(pgm_params['graphs'])):
+            pgm_args_t = '';
+            pgm_args_t += '--wait --cluster ' + cluster_arg[i] + ' --clusterSize ' + clustersz_arg[i] + ' --name graph_' + str(pgm_params['graphs'][i].id)
+            pgm_args_t += ' --graph ' + graph_desc_arg[i] + ' --rates ' + rates_arg[i] + ' --execution ' + exec_arg[i]
+            pgm_args_t += ' --split ' + split_arg[i]
+            if len(wss_arg[i]) != 0:
+                pgm_args_t += ' --wss ' + wss_arg[i]
+
+#            pgm_args_t += ' --duration ' + str(pgm_params['duration'])
+            # last argument must always be duration. actual duration given by run_exps.py
+            pgm_args_t += ' --duration'
+
+            pgm_args.append(pgm_args_t)
+
+        with open(sched_file, 'wa') as f:
+            f.write(str(Template(self.template, searchList=[pgm_params])) + '\n')
+            for s in pgm_args:
+                f.write(s + '\n')
 
     def _write_params(self, params):
         '''Write out file with relevant parameters.'''
         # Don't include this in the parameters. It will be automatically added
         # in run_exps.py
+        if 'system' in params:
+            del params['system']
+
         if 'tasks' in params:
             tasks = params.pop('tasks')
         else:
@@ -240,6 +326,88 @@ class Generator(object):
 
     HELP_INDENT = 17
 
+    def create_pgm_exps(self, opts):
+        '''Create experiments for all possible combinations of params in
+        @out_dir. Overwrite existing files if @force is True.'''
+        builder = ColMapBuilder()
+
+        out_dir = opts.out_dir
+        force = opts.force
+        trials = opts.trials
+
+        # hard coded here
+        exp = storage()
+        exp.host = ['ludwig']
+        cpus = 24.0
+        exp.processors = [cpus]
+        exp.task_util = ['uni-medium']
+        exp.period = ['uni-long']
+        exp.sched = ['edf']
+        exp.sys_util = [ 20.0 ] #arange(1, cpus+0.1, 0.1)
+
+        exp.wcycle = [ 0 ]
+        exp.walk = ['seq']
+        exp.huge_pages = [False]
+        exp.uncached = [False]
+        exp.polluters = [False]
+        exp.ovh_type = ['max']
+        exp.release_master = [False]
+        exp.heur_aggressiveness = [0.75]
+        exp.job_splitting = [True]
+        exp.update(self.params)
+
+        # Track changing values so only relevant parameters are included
+        # in directory names
+        for dp in PgmDesignPointGenerator(exp):
+            for k, v in dp.iteritems():
+                builder.try_add(k, v)
+        col_map = builder.build()
+
+        for trial in xrange(trials):
+            dp.num_graphs = graph.uniform(opts.num_graphs, opts.num_graphs)
+            dp.depth_factor = [1.0/3.0, 2.0/3.0]
+            dp.node_placement = graph.uniform(opts.node_placement, opts.node_placement)
+            dp.fan_out = graph.geometric(1, opts.fan_out)
+            dp.fan_in_cap = opts.fan_in_cap
+            dp.edge_distance = graph.geometric(1, opts.edge_distance)
+            dp.nr_source = graph.uniform(opts.nr_source, opts.nr_source)
+            dp.nr_sink = graph.uniform(opts.nr_sink, opts.nr_sink)
+            dp.wss = tasks.multimodal([(tasks.uniform_int(1,2), 6), (tasks.uniform_int(2, 8), 3)])
+
+            # Generate a task set
+            ts, graphs, subts = self._create_tasks(dp)
+            dp.tasks = len(ts)
+
+            for dp in PgmDesignPointGenerator(exp):
+                # Create directory name from relevant parameters
+                dir_leaf  = "sched=%s_%s" % (self.scheduler, col_map.encode(dp))
+                dir_leaf  = dir_leaf.strip('_') # If there are none
+                dir_leaf += ("_trial=%s" % trial) if trials > 1 else ""
+
+                dir_path  = "%s/%s" % (out_dir, dir_leaf.strip('_'))
+
+                if os.path.exists(dir_path):
+                    if force:
+                        sh.rmtree(dir_path)
+                    else:
+                        print("Skipping existing experiment: '%s'" % dir_path)
+                        continue
+
+                os.mkdir(dir_path)
+
+                if trials > 1:
+                    dp[PARAMS['trial']] = trial
+                self.out_dir = dir_path
+
+                dp.system = topology.Topology(machines[dp.host])
+
+                # Write a sched.py and param.py for each partition method
+                self._create_exp(dp, ts, graphs, subts)
+
+                del(self.out_dir)
+                if PARAMS['trial'] in dp:
+                    del dp[PARAMS['trial']]
+
     def print_help(self):
         display_options = [o for o in self.options if not o.hidden]
         s = str(Template("""scheduler $scheduler:
diff --git a/gen_pgm_exps.py b/gen_pgm_exps.py
new file mode 100755
index 0000000..62723ec
--- /dev/null
+++ b/gen_pgm_exps.py
@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+from __future__ import print_function
+
+import gen.generator as gen
+import os
+import re
+import shutil as sh
+import sys
+
+from config.config import DEFAULTS
+from optparse import OptionParser
+
+import ecrts14.graph as graph
+import schedcat.generator.tasks as tasks
+
+def parse_args():
+    parser = OptionParser("usage: %prog [options] [files...] "
+                          "[generators...] [param=val[,val]...]")
+
+    parser.add_option('-o', '--out-dir', dest='out_dir',
+                      help='directory for data output',
+                      default=("%s/%s"% (os.getcwd(), DEFAULTS['out-gen'])))
+    parser.add_option('-f', '--force', action='store_true', default=True,
+                      dest='force', help='overwrite existing data')
+    parser.add_option('-n', '--num-trials', default=1, type='int', dest='trials',
+                      help='number of task systems for every config')
+    parser.add_option('-l', '--list-generators', dest='list_gens',
+                      help='list allowed generators', action='store_true',
+                      default=False)
+    parser.add_option('-d', '--describe-generators', metavar='generator[,..]',
+                      dest='described', default=None,
+                      help='describe parameters for generator(s)')
+    parser.add_option('-m', '--num-graphs', default=24, type='int', dest='num_graphs',
+                                          help='number of graphs for a taskset')
+    parser.add_option('-p', '--node-placement', default=1, type='int', dest='node_placement',
+                      help='node placement of the graph')
+    parser.add_option('-t', '--fan-out', default=3, type='int', dest='fan_out',
+                      help='fan out of a node')
+    parser.add_option('-i', '--fan-in-cap', default=3, type='int', dest='fan_in_cap',
+                      help='fan in cap')
+    parser.add_option('-g', '--edge-distance', default=3, type='int', dest='edge_distance',
+                      help='edge distance')
+    parser.add_option('-u', '--nr-source', default=1, type='int', dest='nr_source',
+                      help='number of source nodes')
+    parser.add_option('-v', '--nr_sink', default=1, type='int', dest='nr_sink',
+                      help='number of sink nodes')
+
+
+    return parser.parse_args()
+
+def load_file(fname):
+    with open(fname, 'r') as f:
+        data = f.read().strip()
+    try:
+        values = eval(data)
+        if 'generator' not in values:
+            raise ValueError()
+        generator = values['generator']
+        del values['generator']
+        return generator, values
+    except:
+           raise IOError("Invalid generation file: %s" % fname)
+
+def print_descriptions(described):
+    for generator in described.split(','):
+        if generator not in gen.get_generators():
+            sys.stderr.write("No generator '%s'\n" % generator)
+        else:
+            print("Generator '%s', " % generator)
+            gen.get_generators()[generator]().print_help()
+
+def main():
+    opts, args = parse_args()
+
+    # Print generator information on the command line
+    if opts.list_gens:
+        print(", ".join(gen.get_generators()))
+    if opts.described != None:
+        print_descriptions(opts.described)
+    if opts.list_gens or opts.described:
+        return 0
+
+    params = filter(lambda x : re.match("\w+=\w+", x), args)
+
+    # Ensure some generator is loaded
+    args = list(set(args) - set(params))
+    args = args or gen.get_generators().keys()
+
+    # Split into files to load and named generators
+    files = filter(os.path.exists, args)
+    gen_list = list(set(args) - set(files))
+
+    # Parse all specified parameters to be applied to every experiment
+    global_params = dict(map(lambda x : tuple(x.split("=")), params))
+    for k, v in global_params.iteritems():
+        global_params[k] = v.split(',')
+
+    exp_sets  = map(load_file, files)
+    exp_sets += map(lambda x: (x, {}), gen_list)
+
+    if opts.force and os.path.exists(opts.out_dir):
+        sh.rmtree(opts.out_dir)
+    if not os.path.exists(opts.out_dir):
+        os.mkdir(opts.out_dir)
+
+    for gen_name, gen_params in exp_sets:
+        if gen_name not in gen.get_generators():
+            raise ValueError("Invalid generator '%s'" % gen_name)
+
+        sys.stderr.write("Creating experiments with %s generator...\n" % gen_name)
+
+        params = dict(gen_params.items() + global_params.items())
+        clazz  = gen.get_generators()[gen_name]
+
+        generator = clazz(params=params)
+
+        generator.create_pgm_exps(opts)
+
+    sys.stderr.write("Experiments saved in %s.\n" % opts.out_dir)
+
+if __name__ == '__main__':
+    main()
diff --git a/run/experiment.py b/run/experiment.py
index da0e32e..522e490 100644
--- a/run/experiment.py
+++ b/run/experiment.py
@@ -23,7 +23,7 @@ class Experiment(object):
     INTERRUPTED_DIR = ".interrupted"
 
     def __init__(self, name, scheduler, working_dir, finished_dir,
-                 proc_entries, executables, tracer_types):
+                 proc_entries, executables, tracer_types, num_tasks):
         '''Run an experiment, optionally wrapped in tracing.'''
         self.name = name
         self.scheduler = scheduler
@@ -34,6 +34,7 @@ class Experiment(object):
         self.exec_out = None
         self.exec_err = None
         self.tracer_types = tracer_types
+        self.num_tasks = num_tasks
 
         self.regular_tracers = []
         self.exact_tracers = []
@@ -134,11 +135,11 @@ class Experiment(object):
         wait_start = time.time()
         num_ready  = lu.waiting_tasks()
 
-        while num_ready < len(self.executables):
+        while num_ready < self.num_tasks:
             # Quit if too much time passes without a task becoming ready
             if time.time() - wait_start > 180.0:
                 s = "waiting: %d, submitted: %d" %\
-                  (lu.waiting_tasks(), len(self.executables))
+                  (lu.waiting_tasks(), self.num_tasks)
                 raise Exception("Too much time spent waiting for tasks! %s" % s)
 
             time.sleep(1)
@@ -153,14 +154,13 @@ class Experiment(object):
                 num_ready  = now_ready
 
     def __run_tasks(self):
-        self.log("Starting %d tasks" % len(self.executables))
+        self.log("Starting %d real-time tasks, %d 'pgmrt' instances" % (self.num_tasks, len(self.executables)))
 
         for i,e in enumerate(self.executables):
             try:
                 e.execute()
             except:
                 raise Exception("Executable failed to start: %s" % e)
-
         self.__wait_for_ready()
 
         # Exact tracers (like overheads) must be started right after release or
@@ -170,14 +170,14 @@ class Experiment(object):
         time.sleep(1)
 
         try:
-            self.log("Releasing %d tasks" % len(self.executables))
+            self.log("Releasing %d tasks" % self.num_tasks)
             released = lu.release_tasks()
 
-            if released != len(self.executables):
+            if released != self.num_tasks:
                 # Some tasks failed to release, kill all tasks and fail
                 # Need to release non-released tasks before they can be killed
                 raise Exception("Released %s tasks, expected %s tasks" %
-                                (released, len(self.executables)))
+                                (released, self.num_tasks))
 
             self.log("Waiting for program to finish...")
             for e in self.executables:
@@ -212,6 +212,7 @@ class Experiment(object):
 
     def __setup(self):
         self.__make_dirs()
+        self.__clean_up_shm()
         self.__assign_executable_cwds()
         self.__setup_tracers()
 
@@ -244,6 +245,10 @@ class Experiment(object):
 
         os.system('sync')
 
+    def __clean_up_shm(self):
+        self.log("Removing temporary files in /dev/shm")
+        os.system('rm /dev/shm/* -r')
+
     def log(self, msg):
         print("[Exp %s]: %s" % (self.name, msg))
 
diff --git a/run_exps.py b/run_exps.py
index 21666a9..3fff667 100755
--- a/run_exps.py
+++ b/run_exps.py
@@ -65,7 +65,7 @@ def parse_args():
 
     parser.add_option('-s', '--scheduler', dest='scheduler',
                       help='scheduler for all experiments')
-    parser.add_option('-d', '--duration', dest='duration', type='int',
+    parser.add_option('-d', '--duration', dest='duration', type='int', default=30,
                       help='duration (seconds) of tasks')
     parser.add_option('-i', '--ignore-environment', dest='ignore',
                       action='store_true', default=False,
@@ -109,7 +109,7 @@ def convert_data(data):
               r"\s*{\s*(?P<CONTENT>.*?)\s*?}$)|"
         r"(?P<TASK>^"
             r"(?:(?P<PROG>[^\d\-\s][\w\.]*?) )?\s*"
-            r"(?P<ARGS>[\w\-_\d\. \=]+)\s*$)",
+            r"(?P<ARGS>[\w\-_\d\. \=\:\,]+)\s*$)",
         re.S|re.I|re.M)
 
     procs = []
@@ -140,10 +140,8 @@ def fix_paths(schedule, exp_dir, sched_file):
             elif re.match(r'.*\w+\.[a-zA-Z]\w*', arg):
                 sys.stderr.write("WARNING: non-existent file '%s' " % arg +
                                  "may be referenced:\n\t%s" % sched_file)
-
         schedule['task'][idx] = (task, args)
 
-
 def load_schedule(name, fname, duration):
     '''Turn schedule file @fname into ProcEntry's and Executable's which execute
     for @duration time.'''
@@ -153,7 +151,6 @@ def load_schedule(name, fname, duration):
         schedule = eval(data)
     except:
         schedule = convert_data(data)
-
     sched_dir = os.path.split(fname)[0]
 
     # Make paths relative to the file's directory
@@ -183,7 +180,6 @@ def load_schedule(name, fname, duration):
             real_args = ['-w'] + real_args
 
         executables += [Executable(real_task, real_args)]
-
     return proc_entries, executables
 
 
@@ -287,7 +283,7 @@ def run_experiment(data, start_message, ignore, jabber):
     procs, execs = load_schedule(data.name, data.sched_file, data.params.duration)
 
     exp = Experiment(data.name, data.params.scheduler, work_dir,
-                     data.out_dir, procs, execs, data.params.tracers)
+                     data.out_dir, procs, execs, data.params.tracers, data.params.file_params['num_tasks'])
 
     exp.log(start_message)
 
@@ -484,7 +480,6 @@ def run_exps(exps, opts):
             sys.stderr.write("Failed experiment %s\n" % exp.name)
             sys.stderr.write("%s\n" % e)
             exp.state = ExpState.Failed
-
         if exp.state is ExpState.Failed and opts.retry:
             exps_remaining += [(i, exp)]