[gentoo-commits] proj/auto-numerical-bench:master commit in: app-benchmarks/autobench/files/python/, ...

[Andrea Arteaga]

commit:     5fb81447de9eac0011f18fbfa2713ad1291c9d9e
Author:     spiros <andyspiros <AT> gmail <DOT> com>
AuthorDate: Sun Jul  3 16:25:13 2011 +0000
Commit:     Andrea Arteaga <andyspiros <AT> gmail <DOT> com>
CommitDate: Sun Jul  3 16:25:13 2011 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=proj/auto-numerical-bench.git;a=commit;h=5fb81447

Added accuracy for BLAS. Many bugfix.

---
 .../autobench/files/python/accuracy/main_blas.cpp  |  217 ++++++++++++++++++++
 app-benchmarks/autobench/files/python/blas.py      |   69 +------
 .../autobench/files/python/blas_accuracy.py        |  216 +++++++++++++++++++
 .../files/python/{blas.py => blasbase.py}          |   23 +-
 app-benchmarks/autobench/files/python/btlbase.py   |   80 +++++---
 app-benchmarks/autobench/files/python/cblas.py     |   69 +------
 app-benchmarks/autobench/files/python/main.py      |    8 +-
 7 files changed, 506 insertions(+), 176 deletions(-)

diff --git a/app-benchmarks/autobench/files/python/accuracy/main_blas.cpp b/app-benchmarks/autobench/files/python/accuracy/main_blas.cpp
new file mode 100644
index 0000000..4a7a735
--- /dev/null
+++ b/app-benchmarks/autobench/files/python/accuracy/main_blas.cpp
@@ -0,0 +1,217 @@
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <vector>
+#include <cmath>
+#include <cstdlib>
+
+#define ADD_
+extern "C" {
+	void daxpy_(const int*, const double*, const double*, const int*, double*, const int*);
+	void dgemv_(const char*, const int*, const int*, const double*, const double*, const int*, const double*, const int*, const double*, double*, const int*);
+	void dtrsv_(const char*, const char*, const char*, const int*, const double*, const int*, double*, const int*);
+	void dgemm_(const char*, const char*, const int*, const int*, const int*, const double*, const double*, const int*, const double*, const int*, const double*, double*, const int*);
+	double dnrm2_(const int*, const double*, const int*);
+}
+
+using namespace std;
+
+template<typename T>
+void print_array(const int& N, const T* array) {
+	for (const T *p = array, *e = array+N; p != e; ++p)
+		cout << *p << " ";
+}
+
+template<typename T>
+void print_matrix(const int& rows, const int& cols, const T* matrix) {
+	for (int row = 0; row < rows; ++row) {
+		for (int col = 0; col < cols; ++col)
+			cout << *(matrix + rows*col + row) << " ";
+		cout << "\n";
+	}
+}
+
+template<typename T>
+vector<T> logspace(const T& min, const T& max, const unsigned& N)
+{
+	vector<T> result;
+	result.reserve(N);
+
+	const double emin = log(static_cast<double>(min)), emax = log(static_cast<double>(max));
+	double e, r = (emax-emin)/(N-1);
+	for (unsigned i = 0; i < N; ++i) {
+		e = emin + i*r;
+		result.push_back(static_cast<T>(exp(e)));
+	}
+
+	return result;
+}
+
+double axpy_test(const int& size)
+{
+	// Set up
+	const int ONE = 1;
+	const double alpha = 1./3.;
+	double *x = new double[size], *y = new double[size];
+	for (int i = 1; i <= size; ++i) {
+		x[i-1] = 10. / i;
+		y[i-1] = -10./(3. * i);
+	}
+
+	// Execute
+	daxpy_(&size, &alpha, x, &ONE, y, &ONE);
+
+	// Compute the error
+	double error = dnrm2_(&size, y, &ONE);
+
+	delete[] x; delete[] y;
+	return error;
+}
+
+double matrix_vector_test(const int& size)
+{
+	// Set up
+	const int ONE = 1;
+	char TRANS = 'N';
+	const double alpha = 1./size, beta = 1.;
+	double *A = new double[size*size], *x = new double[size], *y = new double[size];
+	for (int i = 1; i <= size; ++i) {
+		x[i-1] = i;
+		y[i-1] = -i;
+		for (int j = 1; j <= size; ++j) {
+			*(A+i-1+(j-1)*size) = static_cast<double>(i)/j;
+		}
+	}
+
+	// Execute
+	dgemv_(&TRANS, &size, &size, &alpha, A, &size, x, &ONE, &beta, y, &ONE);
+
+	// Compute the error
+	double error = dnrm2_(&size, y, &ONE);
+
+	delete[] A; delete[] x; delete[] y;
+	return error;
+}
+
+double trisolve_vector_test(const int& size)
+{
+	// Set up
+	const int ONE = 1;
+	char UPLO = 'U', TRANS = 'N', DIAG = 'U';
+	double *A = new double[size*size], *x = new double[size+1], *y = new double[size];
+	const double alpha = 1.;
+	x[size] = 0.;
+	for (int i = 1; i <= size; ++i) {
+		x[size-i] = x[size-i+1] + 1./i;
+		y[i-1] = -1.;
+		for (int j = i; j <= size; ++j) {
+			*(A+i-1+(j-1)*size) = 1. / (j-i+1);
+		}
+	}
+
+	// Execute
+	dtrsv_(&UPLO, &TRANS, &DIAG, &size, A, &size, x, &ONE);
+	daxpy_(&size, &alpha, x, &ONE, y, &ONE);
+	double error = dnrm2_(&size, y, &ONE);
+
+	delete[] A; delete[] x; delete[] y;
+	return error;
+}
+
+double matrix_matrix_test(const int& size)
+{
+	// rand48 initialization
+	srand48(5);
+
+	// sigma = SUM[k=1..size](k)
+	double sigma = 0;
+	for (int i = 1; i <= size; ++i)
+		sigma += i;
+
+	// Set up
+	const int ONE = 1;
+	char TRANS = 'N';
+	const double alpha = drand48(), beta = -2. * alpha * sigma;
+	const int size2 = size*size;
+	double *A = new double[size2], *B = new double[size2], *C = new double[size2];
+
+	for (int i = 1; i <= size; ++i)
+		for (int j = 1; j <= size; ++j) {
+			*(A+i-1+size*(j-1)) = static_cast<double>(j)/i;
+			*(B+i-1+size*(j-1)) = j;
+			*(C+i-1+size*(j-1)) = static_cast<double>(j)/(2.*i);
+		}
+
+	// Execute
+	dgemm_(&TRANS, &TRANS, &size, &size, &size, &alpha, A, &size, B, &size, &beta, C, &size);
+	double error = dnrm2_(&size2, C, &ONE);
+
+	delete[] A; delete[] B; delete[] C;
+	return error;
+}
+
+template<typename T>
+void test(T t, const int& min, const int& max, const unsigned& N, const string& name)
+{
+    ostringstream fname;
+	ofstream fout;
+	double result;
+	int N_;
+	
+	fname << "accuracy_" << name << "_blas.dat";
+	fout.open(fname.str().c_str());
+	cout << name << " test -- " << fname.str() << endl;
+	vector<int> axpy_sizes = logspace(min, max, N);
+	N_ = 0;
+	for (vector<int>::const_reverse_iterator i = axpy_sizes.rbegin(), e = axpy_sizes.rend(); i!=e; ++i) {
+		result = t(*i);
+		fout << *i << " " << result << endl;
+		cout << " size: " << *i << "   " << result << "   (" << ++N_ << "/100)" << endl;
+	}
+	fout.close();
+	cout << "\n";
+}
+
+int main()
+{
+    bool
+    axpy=false, axpby=false, rot=false,
+    matrix_vector=false, atv=false, symv=false, syr2=false, ger=false, trisolve_vector=false,
+    matrix_matrix=false, aat=false, trisolve_matrix=false, trmm=false  
+    ;
+  
+  
+    for (int i = 1; i < argv; ++i) {
+        std::string arg = argc[i];
+        if (arg == "axpy") axpy = true;
+        else if (arg == "axpby") axpby = true;
+        else if (arg == "rot") rot = true;
+        else if (arg == "matrix_vector") matrix_vector = true;
+        else if (arg == "atv") atv = true;
+        else if (arg == "symv") symv = true;
+        else if (arg == "syr2") syr2 = true;
+        else if (arg == "ger") ger = true;
+        else if (arg == "trisolve_vector") trisolve_vector = true;
+        else if (arg == "matrix_matrix") matrix_matrix = true;
+        else if (arg == "aat") aat = true;
+        else if (arg == "trisolve_matrix") trisolve_matrix = true;
+        else if (arg == "trmm") trmm = true;
+    
+    
+	/* AXPY test */
+	if (axpy)
+    test(axpy_test, 1, 1000000, 100, "axpy");
+    	
+    if (matrix_vector)
+    test(matrix_vector_test, 1, 3000, 100, "matrix_vector");
+	
+	if (trisolve_vector)
+    test(trisolve_vector_test, 1, 3000, 100, "trisolve_vector");
+    
+    if (matrix_matrix)
+    test(matrix_matrix_test, 1, 2000, 100, "matrix_matrix");
+
+    return 0;
+
+}

diff --git a/app-benchmarks/autobench/files/python/blas.py b/app-benchmarks/autobench/files/python/blas.py
index 52bb221..f6193ef 100644
--- a/app-benchmarks/autobench/files/python/blas.py
+++ b/app-benchmarks/autobench/files/python/blas.py
@@ -1,69 +1,6 @@
-import os, btlbase
-import subprocess as sp
-import shlex
+import blasbase
 
-class Module(btlbase.BTLBase):
+class Module(blasbase.BLASBase):
     def _initialize(self):
         self.libname = "blas"
-        self.avail1 = ['axpy', 'axpby', 'rot']
-        self.avail2 = ['matrix_vector','atv','symv','syr2','ger',
-          'trisolve_vector']
-        self.avail3 = ['matrix_matrix', 'aat', 'trisolve_matrix', 'trmm']
-        self.avail = self.avail1 + self.avail2 + self.avail3
-    
-    def _parse_args(self, args):     
-        # Parse arguments
-        tests = []
-        for i in args:
-            if i == '1':
-                tests += avail1
-                continue
-            if i == '2':
-                tests += avail2
-                continue
-            if i == '3':
-                tests += avail3
-                continue
-            if i in self.avail:
-                tests.append(i)
-                continue
-            raise Exception("Argument not recognized: " + i)
-        
-        # Sort tests
-        self.tests = [i for i in self.avail if i in tests]
-        
-        # If no test is specified, then choose four standard tests
-        if len(self.tests) == 0:
-            self.tests = ['axpy', 'matrix_vector', \
-              'trisolve_vector', 'matrix_matrix']
-    
-    @staticmethod
-    def _btl_source():
-        return "/libs/BLAS/main.cpp"
-    
-    @staticmethod
-    def _btl_includes():
-        return ["/libs/BLAS"]
-    
-    def _btl_defines(self):
-        return ["CBLASNAME=" + self.libname, "BLAS_INTERFACE"]
-           
-    def _get_flags(self, root, impl, libdir):
-        # Retrieve pkgconfig settings and map the directories to the new root
-        path = "%s/etc/env.d/alternatives/%s/%s/%s/pkgconfig" % \
-          (root, self.libname, impl, libdir)
-        pkgconf = sp.Popen('pkg-config --libs --cflags blas', shell=True, \
-          stdout=sp.PIPE, env={'PKG_CONFIG_PATH':path}).communicate()[0]
-        pkgconf = pkgconf.replace('-L/', '-L'+root+'/')
-        pkgconf = pkgconf.replace('-I/', '-I'+root+'/')
-        return shlex.split(pkgconf)
-        
-        
-    def get_impls(self, root):
-        output = sp.Popen(
-          ['eselect', '--no-color', '--brief', self.libname, 'list'],
-          env={'ROOT' : root}, stdout=sp.PIPE
-        ).communicate()[0]
-        return output.strip().split('\n')
-
-del btlbase
+        blasbase.BLASBase._initialize(self)
\ No newline at end of file

diff --git a/app-benchmarks/autobench/files/python/blas_accuracy.py b/app-benchmarks/autobench/files/python/blas_accuracy.py
new file mode 100644
index 0000000..9e13ed2
--- /dev/null
+++ b/app-benchmarks/autobench/files/python/blas_accuracy.py
@@ -0,0 +1,216 @@
+from pprint import pprint
+from os.path import join as pjoin
+import subprocess as sp
+import shlex, os
+from htmlreport import HTMLreport
+
+try:
+    import matplotlib.pyplot as plt
+    import numpy as np
+    with_images = True
+except ImportError:
+    sys.stderr.write('Error: matplotlib and numpy are needed' + \
+      'in order to generate the reports!\n')
+    sys.stderr.write('Continue anyway.\n\n')    
+    with_images = False
+
+run_cmd = lambda c : sp.Popen(c, stdout=sp.PIPE).communicate()[0]
+
+class Module:
+    def __init__(self, Print, libdir, args):
+        self.Print = Print
+        self.libdir = libdir
+        self.summary = False
+        self.summary_only = False
+        
+        self._initialize()
+        
+        passargs = []
+        for i in args:
+            if i == '-S':
+                self.summary_only = True
+                continue
+            elif i == '-s':
+                self.summary = True
+                continue
+            else:
+                passargs += [i]
+        
+        self._parse_args(passargs)
+    
+    def _initialize(self):
+        self.libname = 'blas'
+        self.avail=['axpy', 'matrix_vector', 'trisolve_vector', 'matrix_matrix']
+    
+    def _parse_args(self, args):     
+        # Parse arguments
+        tests = []
+        for i in args:
+            if i in self.avail:
+                tests.append(i)
+                continue
+            raise Exception("Argument not recognized: " + i)
+        
+        # Sort tests
+        self.tests = [i for i in self.avail if i in tests]
+        
+        # If no test is specified, then do everything
+        if len(self.tests) == 0:
+            self.tests = self.avail
+           
+    def _get_flags(self, root, impl, libdir):
+        # Retrieve pkgconfig settings and map the directories to the new root
+        path = pjoin(root, "etc/env.d/alternatives", \
+          self.libname, impl, libdir, "pkgconfig")
+        cmd = ['pkg-config', '--libs', '--cflags', self.libname]
+        env = {'PKG_CONFIG_PATH':path}
+        pkgconf = sp.Popen(cmd, stdout=sp.PIPE, env=env).communicate()[0]
+        pkgconf = pkgconf.replace('-L/', '-L'+root+'/')
+        pkgconf = pkgconf.replace('-I/', '-I'+root+'/')
+        return shlex.split(pkgconf)
+        
+    def get_impls(self, root):
+        output = sp.Popen(
+          ['eselect', '--no-color', '--brief', 'blas', 'list'],
+          env={'ROOT' : root}, stdout=sp.PIPE
+        ).communicate()[0]
+        return output.strip().split('\n')
+    
+    def run_test(self, root, impl, testdir, env, logdir):
+        Print = self.Print
+        libdir = self.libdir
+        name = self.libname
+        files = [pjoin(testdir, 'accuracy_%s_%s.dat' % (op, name)) \
+          for op in self.tests]
+        
+        results = {}
+        for op in self.tests:
+            results[op] = pjoin(testdir, 'accuracy_%s_%s.dat' % (op, name))
+            
+        # Prepare the environment
+        if env.has_key('LIBRARY_PATH'):
+            env['LIBRARY_PATH'] = pjoin(root,libdir) + ":" + env['LIBRARY_PATH']
+        else:
+            env['LIBRARY_PATH'] = pjoin(root, libdir)
+            
+        if env.has_key('INCLUDE_PATH'):
+            env['INCLUDE_PATH'] = \
+              pjoin(root, "/usr/include") + ":" + env['INCLUDE_PATH']
+        else:
+            env['INCLUDE_PATH'] = pjoin(root, "/usr/include")
+            
+        if env.has_key('LD_LIBRARY_PATH'):
+            env['LD_LIBRARY_PATH'] = \
+              pjoin(root, libdir) + ":" + env['LD_LIBRARY_PATH']
+        else:
+            env['LD_LIBRARY_PATH'] = pjoin(root, libdir)
+        
+        # Backup the environment
+        oldenv = {}
+        for k in env.keys():
+            oldenv[k] = \
+              (os.environ.has_key(k) and (os.environ[k],) or (None,))[0]
+        
+        # Set the environment
+        for k,v in env.items():
+            os.environ[k] = v
+        
+        # Compile test suite
+        exe = pjoin(testdir, 'test')
+        source = "accuracy/main_blas.cpp"
+        flags = self._get_flags(root, impl, libdir)
+        cxxflags = run_cmd(['portageq', 'envvar', 'CXXFLAGS']).strip()
+        cxx = 'g++'
+        cmd = [cxx, '-o', exe, source] + flags + shlex.split(cxxflags)
+        logfile = pjoin(logdir, 'compile.log')
+        p = sp.Popen(cmd, stdout=file(logfile, 'w'), stderr=sp.STDOUT)
+        p.wait()
+        if p.returncode != 0:
+            Print("Compilation failed")
+            Print("See log: " + logfile)
+            return
+        Print("Compilation successful")
+        
+        # Run test
+        logfile = file(pjoin(logdir, name+"_run.log"), 'w')
+        cmd = [pjoin(testdir,"test")] + self.tests
+        proc = sp.Popen(cmd, bufsize=1, stdout=sp.PIPE, stderr=sp.PIPE,
+          cwd=testdir)
+        Print.down()
+        while True:
+            line = proc.stdout.readline()
+            if not line:
+                break
+            logfile.write(line)
+            if len(line.strip()) == 0:
+                continue
+            if line[0] != ' ':
+                Print.up()
+                Print(line.strip().split()[-1])
+                Print.down()
+            else:
+                Print(line.strip())
+        Print.up()          
+        logfile.close()      
+        proc.wait()
+        if proc.returncode != 0:
+            Print('Test failed')
+        else:
+            Print('Test successful')
+        
+        return results
+        
+    
+    def save_results(self, results, figdir):
+        if not with_images:
+            self.Print("Report generation skipped - missing libraries")
+            return
+    
+        # Re-order the result dictionary
+        newresults = {}
+        for test in self.tests:
+            newresults[test] = {}
+            for nameimpl in results:
+                nameimplstr = pjoin(*nameimpl)
+                resdat = results[nameimpl][test]
+                newresults[test][nameimplstr] = resdat
+        
+        # Begin the HTML report
+        htmlfname = pjoin(figdir, 'index.html')
+        html = HTMLreport(htmlfname)
+        
+        # Generate summary - a single image with all plots
+        if self.summary or self.summary_only:
+            # Save summary figure
+            sprows = (len(self.tests)+1)/2
+            plt.figure(figsize=(16,6*sprows), dpi=300)
+            for i, test in enumerate(self.tests, 1):
+                plt.subplot(sprows, 2, i)
+                plt.title(test)
+                for impl in newresults[test]:
+                    x,y = np.loadtxt(newresults[test][impl], unpack=True)
+                    plt.loglog(x,y, label=impl, hold=True)
+                plt.legend(loc='best')
+                plt.grid(True)
+            fname = pjoin(figdir, 'summary.png')
+            plt.savefig(fname, format='png')
+            html.addFig("Summary", image=os.path.basename(fname), width='95%')
+            self.Print('Summary figure saved: ' + fname)
+                
+        # Generate plots
+        if not self.summary_only:
+            for test in self.tests:
+                plt.figure(figsize=(12,9), dpi=300)
+                for impl in newresults[test]:
+                    x,y = np.loadtxt(newresults[test][impl], unpack=True)
+                    plt.loglog(x,y, label=impl, hold=True)
+                plt.legend(loc='best')
+                plt.grid(True)
+                fname = pjoin(figdir, test+".png")
+                plt.savefig(fname, format='png')
+                html.addFig(test, image=os.path.basename(fname))
+                self.Print('Figure ' + fname + ' saved')
+        
+        html.close()
+            
+            

diff --git a/app-benchmarks/autobench/files/python/blas.py b/app-benchmarks/autobench/files/python/blasbase.py
similarity index 77%
copy from app-benchmarks/autobench/files/python/blas.py
copy to app-benchmarks/autobench/files/python/blasbase.py
index 52bb221..2ca9070 100644
--- a/app-benchmarks/autobench/files/python/blas.py
+++ b/app-benchmarks/autobench/files/python/blasbase.py
@@ -1,10 +1,10 @@
 import os, btlbase
 import subprocess as sp
 import shlex
+from os.path import join as pjoin
 
-class Module(btlbase.BTLBase):
+class BLASBase(btlbase.BTLBase):
     def _initialize(self):
-        self.libname = "blas"
         self.avail1 = ['axpy', 'axpby', 'rot']
         self.avail2 = ['matrix_vector','atv','symv','syr2','ger',
           'trisolve_vector']
@@ -16,13 +16,13 @@ class Module(btlbase.BTLBase):
         tests = []
         for i in args:
             if i == '1':
-                tests += avail1
+                tests += self.avail1
                 continue
             if i == '2':
-                tests += avail2
+                tests += self.avail2
                 continue
             if i == '3':
-                tests += avail3
+                tests += self.avail3
                 continue
             if i in self.avail:
                 tests.append(i)
@@ -39,21 +39,22 @@ class Module(btlbase.BTLBase):
     
     @staticmethod
     def _btl_source():
-        return "/libs/BLAS/main.cpp"
+        return "libs/BLAS/main.cpp"
     
     @staticmethod
     def _btl_includes():
-        return ["/libs/BLAS"]
+        return ["libs/BLAS"]
     
     def _btl_defines(self):
         return ["CBLASNAME=" + self.libname, "BLAS_INTERFACE"]
            
     def _get_flags(self, root, impl, libdir):
         # Retrieve pkgconfig settings and map the directories to the new root
-        path = "%s/etc/env.d/alternatives/%s/%s/%s/pkgconfig" % \
-          (root, self.libname, impl, libdir)
-        pkgconf = sp.Popen('pkg-config --libs --cflags blas', shell=True, \
-          stdout=sp.PIPE, env={'PKG_CONFIG_PATH':path}).communicate()[0]
+        path = pjoin(root, "etc/env.d/alternatives", \
+          self.libname,impl,libdir, "pkgconfig")
+        cmd = ['pkg-config', '--libs', '--cflags', self.libname]
+        env = {'PKG_CONFIG_PATH':path}
+        pkgconf = sp.Popen(cmd, stdout=sp.PIPE, env=env).communicate()[0]
         pkgconf = pkgconf.replace('-L/', '-L'+root+'/')
         pkgconf = pkgconf.replace('-I/', '-I'+root+'/')
         return shlex.split(pkgconf)

diff --git a/app-benchmarks/autobench/files/python/btlbase.py b/app-benchmarks/autobench/files/python/btlbase.py
index d71650e..1c6f8aa 100644
--- a/app-benchmarks/autobench/files/python/btlbase.py
+++ b/app-benchmarks/autobench/files/python/btlbase.py
@@ -46,40 +46,53 @@ def btlcompile(exe, source, btldir, includes, defines, libs, libdirs, other, \
     exist. If None, no log is generated.
     """
     
+    # Compile flags
     incs = (
       "%s/actions" % btldir,
       "%s/generic_bench" % btldir,
       "%s/generic_bench/utils" % btldir,
       "%s/libs/STL" % btldir
     ) + tuple(includes)
-    incs = ' '.join(['-I'+i for i in incs])
+    incs = ['-I'+i for i in incs]
     
-    defs = ' '.join(['-D'+d for d in ["NDEBUG"] + defines])
+    defs = ['-D'+d for d in ["NDEBUG"] + defines]
     
-    libs = ' '.join(['-l'+l for l in ["rt"] + libs])
+    libs = ['-l'+l for l in ["rt"] + libs]
     
-    libdirs = ' '.join(['-L'+L for L in libdirs])
+    libdirs = ['-L'+L for L in libdirs]
     
-    cxxflags = run_cmd(['portageq', 'envvar', 'CXXFLAGS']).strip()
+    cxxflags = shlex.split(run_cmd(['portageq', 'envvar', 'CXXFLAGS']).strip())
     
-    otherflags = ' '.join(other)
+    otherfl = other
     
-    # TODO: use CXX instead of g++
-    cl = "g++ -o %s %s %s %s %s %s %s %s" \
-        % (exe, source, incs, defs, libs, libdirs, cxxflags, otherflags)
-        
+    # Retrieve compiler
+    cxx = 'g++'
+    cxx_portage = run_cmd(['portageq', 'envvar', 'CXX']).strip()
+    if cxx_portage != '':
+        cxx = cxx_portage
+    if os.environ.has_key('CXX'):
+        cxx = os.environ['CXX']
+    
+    # Compile command
+    cl = [cxx, '-o', exe, source]+incs+defs+libs+libdirs+cxxflags+other
+    
+    # Open logfile or redirect to PIPE 
     if logfile is None:
         fout = sp.PIPE
     else:
         fout = file(logfile, 'w')
-        fout.write(cl + "\n" + 80*'-' + "\n")
+        fout.write(str(cl) + "\n" + 80*'-' + "\n")
         fout.flush()
-    cl = shlex.split(cl)
+    
+    # Execute command
     cp = sp.Popen(cl, stdout=fout, stderr=sp.STDOUT)
-    cp.communicate()
+    cp.wait()
+    
+    # Close the log file (if any)
     if logfile is not None:
         fout.close()
-    return (cp.returncode, ' '.join(cl))
+    
+    return cp.returncode
 
 
 class BTLBase:
@@ -134,19 +147,21 @@ class BTLBase:
             
         # Prepare the environment
         if env.has_key('LIBRARY_PATH'):
-            env['LIBRARY_PATH'] = root+libdir + ":" + env['LIBRARY_PATH']
+            env['LIBRARY_PATH'] = pjoin(root,libdir) + ":" + env['LIBRARY_PATH']
         else:
-            env['LIBRARY_PATH'] = root+libdir
+            env['LIBRARY_PATH'] = pjoin(root, libdir)
             
         if env.has_key('INCLUDE_PATH'):
-            env['INCLUDE_PATH'] = root+"/usr/include" +":"+ env['INCLUDE_PATH']
+            env['INCLUDE_PATH'] = \
+              pjoin(root, "/usr/include") + ":" + env['INCLUDE_PATH']
         else:
-            env['INCLUDE_PATH'] = root+"/usr/include"
+            env['INCLUDE_PATH'] = pjoin(root, "/usr/include")
             
         if env.has_key('LD_LIBRARY_PATH'):
-            env['LD_LIBRARY_PATH'] = root+libdir + ":" + env['LD_LIBRARY_PATH']
+            env['LD_LIBRARY_PATH'] = \
+              pjoin(root, libdir) + ":" + env['LD_LIBRARY_PATH']
         else:
-            env['LD_LIBRARY_PATH'] = root+libdir
+            env['LD_LIBRARY_PATH'] = pjoin(root, libdir)
         
         # Backup the environment
         oldenv = {}
@@ -158,15 +173,14 @@ class BTLBase:
         for k,v in env.items():
             os.environ[k] = v
         
-        # Compile
-        # TODO: use CXX instead of g++
+        # Compile test suite
         btldir = 'btl/'
         logfile = os.path.join(logdir, name+"_comp.log")
-        returncode, compilecl = btlcompile(
-          exe = testdir + "/test",
-          source = btldir + self._btl_source(),
+        returncode = btlcompile(
+          exe = pjoin(testdir, "test"),
+          source = pjoin(btldir, self._btl_source()),
           btldir = btldir,
-          includes = [btldir+d for d in self._btl_includes()],
+          includes = [pjoin(btldir, d) for d in self._btl_includes()],
           defines = self._btl_defines(),
           libs = [],
           libdirs = [root+libdir],
@@ -180,29 +194,31 @@ class BTLBase:
         Print("Compilation successful")
         
         # Run test
-        logfile = file(os.path.join(logdir, name+"_run.log"), 'w')
-        args = [os.path.join(testdir,"test")] + self.tests
+        logfile = file(pjoin(logdir, name+"_run.log"), 'w')
+        args = [pjoin(testdir,"test")] + self.tests
         proc = sp.Popen(args, bufsize=1, stdout=sp.PIPE, stderr=sp.PIPE, 
           cwd = testdir)
         results = {}
         while True:
+            # Each operation test begins with a line on stderr
             errline = proc.stderr.readline()
-            logfile.write(errline)
             if not errline:
                 break
+            logfile.write(errline)
             resfile = errline.split()[-1]
             testname = resfile[6:-5-len(name)]
             results[testname] = pjoin(testdir, resfile)
             Print(resfile)
+            
+            # 100 different sizes for each operation test
             Print.down()
             for i in xrange(100):
                 outline = proc.stdout.readline()
                 logfile.write(outline)
                 Print(outline.rstrip())
             Print.up()
-        Print.up()
-        proc.wait()
         logfile.close()
+        proc.wait()
         if proc.returncode != 0:
             Print('Test failed')
         else:
@@ -226,7 +242,7 @@ class BTLBase:
         for test in self.tests:
             newresults[test] = {}
             for nameimpl in results:
-                nameimplstr = "%s/%s" % nameimpl
+                nameimplstr = pjoin(*nameimpl)
                 resdat = results[nameimpl][test]
                 newresults[test][nameimplstr] = resdat
         

diff --git a/app-benchmarks/autobench/files/python/cblas.py b/app-benchmarks/autobench/files/python/cblas.py
index c3d0342..c78867c 100644
--- a/app-benchmarks/autobench/files/python/cblas.py
+++ b/app-benchmarks/autobench/files/python/cblas.py
@@ -1,69 +1,6 @@
-import os, btlbase
-import subprocess as sp
-import shlex
+import blasbase
 
-class Module(btlbase.BTLBase):
+class Module(blasbase.BLASBase):
     def _initialize(self):
         self.libname = "cblas"
-        self.avail1 = ['axpy', 'axpby', 'rot']
-        self.avail2 = ['matrix_vector','atv','symv','syr2','ger',
-          'trisolve_vector']
-        self.avail3 = ['matrix_matrix', 'aat', 'trisolve_matrix', 'trmm']
-        self.avail = self.avail1 + self.avail2 + self.avail3
-    
-    def _parse_args(self, args):     
-        # Parse arguments
-        tests = []
-        for i in args:
-            if i == '1':
-                tests += avail1
-                continue
-            if i == '2':
-                tests += avail2
-                continue
-            if i == '3':
-                tests += avail3
-                continue
-            if i in self.avail:
-                tests.append(i)
-                continue
-            raise Exception("Argument not recognized: " + i)
-        
-        # Sort tests
-        self.tests = [i for i in self.avail if i in tests]
-        
-        # If no test is specified, then choose four standard tests
-        if len(self.tests) == 0:
-            self.tests = ['axpy', 'matrix_vector', \
-              'trisolve_vector', 'matrix_matrix']
-    
-    @staticmethod
-    def _btl_source():
-        return "/libs/BLAS/main.cpp"
-    
-    @staticmethod
-    def _btl_includes():
-        return ["/libs/BLAS"]
-    
-    def _btl_defines(self):
-        return ["CBLASNAME=" + self.libname, "CBLAS_INTERFACE"]
-           
-    def _get_flags(self, root, impl, libdir):
-        # Retrieve pkgconfig settings and map the directories to the new root
-        path = "%s/etc/env.d/alternatives/%s/%s/%s/pkgconfig" % \
-          (root, self.libname, impl, libdir)
-        pkgconf = sp.Popen('pkg-config --libs --cflags cblas', shell=True, \
-          stdout=sp.PIPE, env={'PKG_CONFIG_PATH':path}).communicate()[0]
-        pkgconf = pkgconf.replace('-L/', '-L'+root+'/')
-        pkgconf = pkgconf.replace('-I/', '-I'+root+'/')
-        return shlex.split(pkgconf)
-        
-        
-    def get_impls(self, root):
-        output = sp.Popen(
-          ['eselect', '--no-color', '--brief', self.libname, 'list'],
-          env={'ROOT' : root}, stdout=sp.PIPE
-        ).communicate()[0]
-        return output.strip().split('\n')
-
-del btlbase
+        blasbase.BLASBase._initialize(self)
\ No newline at end of file

diff --git a/app-benchmarks/autobench/files/python/main.py b/app-benchmarks/autobench/files/python/main.py
index 991d735..3a02791 100644
--- a/app-benchmarks/autobench/files/python/main.py
+++ b/app-benchmarks/autobench/files/python/main.py
@@ -7,6 +7,7 @@ import subprocess as sp
 import time
  
 # Retrieve relevant files/directories
+# TODO: use external config module to share these variables (or use environ?)
 curdir = os.path.abspath('.')
 scriptdir = os.path.dirname(os.path.realpath(__file__))
 rootsdir = "/var/tmp/benchmarks/roots/"
@@ -236,6 +237,12 @@ for tn,(name,test) in enumerate(tests.items(),1):
     
 
 # Reports will be saved in figdir
+
+# Results are reordered:
+# results
+# |-(name1, impl1) -> resultobject11
+# |-(name1, impl2) -> resultobject12
+# |-(name2, impl1) -> resultobject21
 os.path.exists(figdir) or os.makedirs(figdir)        
 results = {}
 for (name,test) in tests.items():
@@ -244,4 +251,3 @@ for (name,test) in tests.items():
             results[(name, impl)] = test['results'][impl]
 
 mod.save_results(results, figdir)
-