Added parameter file options for tracers and pre/post experiment commands.

2 files changed, 71 insertions, 37 deletions

diff --git a/run/experiment.py b/run/experiment.py
index 03d6ab6..3dd4866 100644
--- a/run/experiment.py
+++ b/run/experiment.py
@@ -3,7 +3,6 @@ import time
 import run.litmus_util as lu
 import shutil as sh
 from operator import methodcaller
-from run.tracer import SchedTracer, LogTracer, PerfTracer, LinuxTracer, OverheadTracer
 
 class ExperimentException(Exception):
     '''Used to indicate when there are problems with an experiment.'''
@@ -32,7 +31,8 @@ class Experiment(object):
     '''Execute one task-set and save the results. Experiments have unique IDs.'''
     INTERRUPTED_DIR = ".interrupted"
 
-    def __init__(self, name, scheduler, working_dir, finished_dir, proc_entries, executables):
+    def __init__(self, name, scheduler, working_dir, finished_dir,
+                 proc_entries, executables, tracer_types):
         '''Run an experiment, optionally wrapped in tracing.'''
 
         self.name = name
@@ -46,27 +46,17 @@ class Experiment(object):
 
         self.__make_dirs()
         self.__assign_executable_cwds()
+        self.__setup_tracers(tracer_types)
 
-        self.tracers = []
-        if SchedTracer.enabled():
-            self.log("Enabling sched_trace")
-            self.tracers.append( SchedTracer(working_dir) )
-        if LinuxTracer.enabled():
-            self.log("Enabling trace-cmd")
-            self.tracers.append( LinuxTracer(working_dir) )
-        if LogTracer.enabled():
-            self.log("Enabling logging")
-            self.tracers.append( LogTracer(working_dir) )
-        if PerfTracer.enabled():
-            self.log("Tracking CPU performance counters")
-            self.tracers.append( PerfTracer(working_dir) )
-
-        # Overhead trace must be handled seperately, see __run_tasks
-        if OverheadTracer.enabled():
-            self.log("Enabling overhead tracing")
-            self.overhead_trace = OverheadTracer(working_dir)
-        else:
-            self.overhead_trace = None
+
+    def __setup_tracers(self, tracer_types):
+        tracers = [ t(self.working_dir) for t in tracer_types ]
+
+        self.regular_tracers  = [t for t in tracers if not t.is_exact()]
+        self.exact_tracers = [t for t in tracers if t.is_exact()]
+
+        for t in tracers:
+            self.log("Enabling %s" % t.get_name())
 
     def __make_dirs(self):
         interrupted = None
@@ -111,11 +101,10 @@ class Experiment(object):
                 raise Exception("Too much time has passed waiting for tasks!")
             time.sleep(1)
 
-        # Overhead tracer must be started right after release or overhead
+        # Exact tracers (like overheads) must be started right after release or
         # measurements will be full of irrelevant records
-        if self.overhead_trace:
-            self.log("Starting overhead trace")
-            self.overhead_trace.start_tracing()
+        self.log("Starting %d released tracers" % len(self.exact_tracers))
+        map(methodcaller('start_tracing'), self.exact_tracers)
 
         self.log("Releasing %d tasks" % len(self.executables))
         released = lu.release_tasks()
@@ -145,10 +134,9 @@ class Experiment(object):
             if not e.wait():
                 ret = False
 
-        # And it must be stopped here for the same reason
-        if self.overhead_trace:
-            self.log("Stopping overhead trace")
-            self.overhead_trace.stop_tracing()
+        # And these must be stopped here for the same reason
+        self.log("Stopping exact tracers")
+        map(methodcaller('stop_tracing'), self.exact_tracers)
 
         if not ret:
             raise ExperimentFailed(self.name)
@@ -186,8 +174,8 @@ class Experiment(object):
         self.log("Switching to %s" % self.scheduler)
         lu.switch_scheduler(self.scheduler)
 
-        self.log("Starting %d tracers" % len(self.tracers))
-        map(methodcaller('start_tracing'), self.tracers)
+        self.log("Starting %d regular tracers" % len(self.regular_tracers))
+        map(methodcaller('start_tracing'), self.regular_tracers)
 
         self.exec_out = open('%s/exec-out.txt' % self.working_dir, 'w')
         self.exec_err = open('%s/exec-err.txt' % self.working_dir, 'w')
@@ -200,6 +188,6 @@ class Experiment(object):
         self.exec_out and self.exec_out.close()
         self.exec_err and self.exec_err.close()
 
-        self.log("Stopping tracers")
-        map(methodcaller('stop_tracing'), self.tracers)
+        self.log("Stopping regular tracers")
+        map(methodcaller('stop_tracing'), self.regular_tracers)
 
diff --git a/run/tracer.py b/run/tracer.py
index 065797c..6e1d05c 100644
--- a/run/tracer.py
+++ b/run/tracer.py
@@ -6,10 +6,17 @@ from operator import methodcaller
 from run.executable.ftcat import FTcat,Executable
 
 class Tracer(object):
-    def __init__(self, name, output_dir):
+    def __init__(self, name, output_dir, exact=False):
         self.name = name
         self.output_dir = output_dir
         self.bins = []
+        self.exact=exact
+
+    def get_name(self):
+        return self.name
+
+    def is_exact(self):
+        return self.exact
 
     def start_tracing(self):
         map(methodcaller("execute"), self.bins)
@@ -23,7 +30,7 @@ class LinuxTracer(Tracer):
     LITMUS_EVENTS = "%s/events/litmus" % EVENT_ROOT
 
     def __init__(self, output_dir):
-        super(LinuxTracer, self).__init__("trace-cmd", output_dir)
+        super(LinuxTracer, self).__init__("Trace-cmd / Kernelshark", output_dir)
 
         extra_args = ["record", # "-e", "sched:sched_switch",
                       "-e", "litmus:*",
@@ -89,7 +96,7 @@ class OverheadTracer(Tracer):
     DEVICE_STR = '/dev/litmus/ft_trace0'
 
     def __init__(self, output_dir):
-        super(OverheadTracer, self).__init__("Overhead Trace", output_dir)
+        super(OverheadTracer, self).__init__("Overhead Trace", output_dir, True)
 
         stdout_f = open('{0}/{1}'.format(self.output_dir, conf.FILES['ft_data']), 'w')
         stderr_f = open('{0}/{1}.stderr.txt'.format(self.output_dir, conf.FILES['ft_data']), 'w')
@@ -109,3 +116,42 @@ class PerfTracer(Tracer):
     @staticmethod
     def enabled():
         return False
+
+
+tracers = {}
+
+def register_tracer(tracer, name):
+    tracers[name] = tracer
+
+def get_tracer_types(names):
+    error = True # Error if name is not present
+    errors = []
+
+    if not names:
+        # Just return all enabled tracers if none specified
+        names = tracers.keys()
+        error = False
+
+    ret = []
+
+    for name in names:
+        if name not in tracers:
+            raise ValueError("Invalid tracer '%s', valid names are: %s" %
+                             (name, tracers.keys()))
+
+        if tracers[name].enabled():
+            ret += [ tracers[name] ]
+        elif error:
+            errors += ["Tracer '%s' requested, but not enabled." % name]
+
+    if errors:
+        raise ValueError("Check your kernel compile configuration!\n" +
+                         "\n".join(errors))
+
+    return ret
+
+register_tracer(LinuxTracer, "kernelshark")
+register_tracer(LogTracer, "log")
+register_tracer(SchedTracer, "sched")
+register_tracer(OverheadTracer, "overhead")
+