Read locations of binary files from path instead of config.py.

8 files changed, 522 insertions, 0 deletions

diff --git a/run/__init__.py b/run/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/run/__init__.py
diff --git a/run/executable/__init__.py b/run/executable/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/run/executable/__init__.py
diff --git a/run/executable/executable.py b/run/executable/executable.py
new file mode 100644
index 0000000..628f711
--- /dev/null
+++ b/run/executable/executable.py
@@ -0,0 +1,77 @@
+import sys
+import subprocess
+import signal
+from ..litmus_util import is_executable
+
+class Executable(object):
+    '''Parent object that represents an executable for use in task-sets.'''
+
+    def __init__(self, exec_file, extra_args=None, stdout_file = None, stderr_file = None):
+        self.exec_file = exec_file
+        self.cwd = None
+        self.stdout_file = stdout_file
+        self.stderr_file = stderr_file
+        self.sp = None
+
+        if extra_args is None:
+            self.extra_args = None
+        else:
+            self.extra_args = list(extra_args) # make a duplicate
+
+        if not is_executable(self.exec_file):
+            raise Exception("Not executable ? : %s" % self.exec_file)
+
+    def __del__(self):
+        # Try and clean up
+        if self.stdout_file is not None:
+            self.stdout_file.close()
+        if self.stderr_file is not None:
+            self.stderr_file.close()
+
+        if self.sp is not None:
+            try:
+                self.sp.terminate()
+            except OSError as e:
+                if e.errno == 3:
+                    pass # no such process (already killed), okay
+                else:
+                    raise e
+
+    def __get_full_command(self):
+        full_command = [self.exec_file]
+        if self.extra_args is not None:
+            full_command += self.extra_args
+        return full_command
+
+    def __str__(self):
+        return " ".join(self.__get_full_command())
+
+    def execute(self):
+        '''Execute the binary.'''
+        full_command = self.__get_full_command()
+        self.sp = subprocess.Popen(full_command, stdout=self.stdout_file,
+                stderr=self.stderr_file, cwd=self.cwd)
+
+    def kill(self):
+        self.sp.kill()
+
+    def interrupt(self):
+        self.sp.send_signal(signal.SIGINT)
+
+    def terminate(self):
+        '''Send the terminate signal to the binary.'''
+        self.sp.terminate()
+
+    def wait(self):
+        '''Wait until the executable is finished, checking return code.
+
+        If the exit status is non-zero, raise an exception.
+
+        '''
+
+        self.sp.wait()
+        if self.sp.returncode != 0:
+            print >>sys.stderr, "Non-zero return: %s %s" % (self.exec_file, " ".join(self.extra_args))
+            return 0
+        else:
+            return 1
diff --git a/run/executable/ftcat.py b/run/executable/ftcat.py
new file mode 100644
index 0000000..5da8fa7
--- /dev/null
+++ b/run/executable/ftcat.py
@@ -0,0 +1,33 @@
+import os
+import stat
+
+from executable import Executable
+
+class FTcat(Executable):
+    '''Used to wrap the ftcat binary in the Experiment object.'''
+
+    def __init__(self, ft_cat_bin, stdout_file, stderr_file, dev, events, cpu=None):
+        '''Extends the Executable initializer method with ftcat attributes.'''
+
+        # hack to run FTCat at higher priority
+        chrt_bin = '/usr/bin/chrt'
+
+        super(FTcat, self).__init__(chrt_bin)
+        self.stdout_file = stdout_file
+        self.stderr_file = stderr_file
+
+        mode = os.stat(dev)[stat.ST_MODE]
+        if not mode & stat.S_IFCHR:
+            raise Exception("%s is not a character device" % dev)
+
+        if events is None:
+            raise Exception('No events!')
+
+        # hack to run FTCat at higher priority
+        self.extra_args = ['-f', '40']
+        if cpu is not None:
+            # and bind it to a CPU
+            self.extra_args.extend(['/usr/bin/taskset', '-c', str(cpu)])
+        events_str_arr = map(str, events)
+        self.extra_args.extend([ft_cat_bin, dev] + events_str_arr)
+
diff --git a/run/experiment.py b/run/experiment.py
new file mode 100644
index 0000000..4bd47c6
--- /dev/null
+++ b/run/experiment.py
@@ -0,0 +1,209 @@
+import os
+import time
+import litmus_util
+from operator import methodcaller
+from tracer import SchedTracer, LogTracer, PerfTracer, LinuxTracer, OverheadTracer
+
+class ExperimentException(Exception):
+    '''Used to indicate when there are problems with an experiment.'''
+    def __init__(self, name):
+        self.name = name
+
+
+class ExperimentDone(ExperimentException):
+    '''Raised when an experiment looks like it's been run already.'''
+    def __str__(self):
+        return "Experiment finished already: %d" % self.name
+
+
+class ExperimentInterrupted(ExperimentException):
+    '''Raised when an experiment appears to be interrupted (partial results).'''
+    def __str__(self):
+        return "Experiment was interrupted in progress: %d" % self.name
+
+
+class ExperimentFailed(ExperimentException):
+    def __str__(self):
+        return "Experiment failed during execution: %d" % self.name
+
+
+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):
+        '''Run an experiment, optionally wrapped in tracing.'''
+
+        self.name = name
+        self.scheduler = scheduler
+        self.working_dir  = working_dir
+        self.finished_dir = finished_dir
+        self.proc_entries = proc_entries
+        self.executables  = executables
+        self.exec_out = None
+        self.exec_err = None
+
+        self.__make_dirs()
+        self.__assign_executable_cwds()
+
+        self.tracers = []
+        if SchedTracer.enabled():
+            self.log("Enabling sched_trace")
+            self.tracers.append( SchedTracer(working_dir) )
+        if LinuxTracer.enabled():
+            self.log("Enabling trace-cmd / ftrace / kernelshark")
+            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 __make_dirs(self):
+        interrupted = None
+
+        if os.path.exists(self.finished_dir):
+            raise ExperimentDone(self.name)
+
+        if os.path.exists(self.working_dir):
+            self.log("Found interrupted experiment, saving in %s" %
+                     Experiment.INTERRUPTED_DIR)
+            interrupted = "%s/%s" % (os.path.split(self.working_dir)[0],
+                                     Experiment.INTERRUPTED_DIR)
+            os.rename(self.working_dir, interrupted)
+
+        os.mkdir(self.working_dir)
+
+        if interrupted:
+            os.rename(interrupted, "%s/%s" % (self.working_dir,
+                                              os.path.split(interrupted)[1]))
+