runall

#!/usr/bin/python
#
# run all tests
#

import os
import sys

os.system("echo HOSTNAME: `hostname`")

tests = [
    ["integerSort/parallelRadixSort",True,0],
    ["integerSort/serialRadixSort",False,0],

    ["comparisonSort/sampleSort",True,0],
    ["comparisonSort/quickSort",True,1],
    ["comparisonSort/mergeSort",True,1],
    ["comparisonSort/stableSampleSort",True,1],
    ["comparisonSort/serialSort",False,0],
    ["comparisonSort/ips4o",True,1],

    ["removeDuplicates/serial_hash", False,0],
    ["removeDuplicates/serial_sort", False,1],
    ["removeDuplicates/parlayhash", True,0],

    ["histogram/sequential",False,0],
    ["histogram/parallel",True,0],
    
    ["wordCounts/histogram",True,0],
    # ["wordCounts/histogramStar",True],
    ["wordCounts/serial",False,0],

    ["invertedIndex/sequential", False,0],
    ["invertedIndex/parallel", True,0],
    
    ["suffixArray/parallelKS",True,1],
    ["suffixArray/parallelRange",True,0],
    ["suffixArray/serialDivsufsort",False,0],

    ["longestRepeatedSubstring/doubling",True,0],

    ["classify/decisionTree", True,0],

    # ["minSpanningForest/parallelKruskal",True],
    ["minSpanningForest/parallelFilterKruskal",True,0],
    ["minSpanningForest/serialMST",False,0],

    ["spanningForest/incrementalST",True,1],
    ["spanningForest/ndST",True,0],
    ["spanningForest/serialST",False,0],

    ["breadthFirstSearch/simpleBFS",True,1],
    ["breadthFirstSearch/backForwardBFS",True,0],
    ["breadthFirstSearch/deterministicBFS",True,1],
    ["breadthFirstSearch/serialBFS",False,0],

    ["maximalMatching/serialMatching",False,0],
    ["maximalMatching/incrementalMatching",True,0],

    ["maximalIndependentSet/incrementalMIS",True,0],
    ["maximalIndependentSet/ndMIS",True,1],
    ["maximalIndependentSet/serialMIS",False,0],

    ["nearestNeighbors/octTree",True,0],

    ["rayCast/kdTree",True,0],

    ["convexHull/quickHull",True,0],
    ["convexHull/serialHull",False,0],

    ["delaunayTriangulation/incrementalDelaunay",True,0],

    ["delaunayRefine/incrementalRefine",True,0],
    
    ["rangeQuery2d/parallelPlaneSweep",True,0],
    ["rangeQuery2d/serial",False,0],

    ["nBody/parallelCK",True,0],
]

noTime = False
noCheck = False
scale = False
doSmall = False
forceCompile = False
parOnly = False
useNumactl = True
keep_tmp_files = False
extended = False
if (sys.argv.count("-only") > 0):
    filteredTests = [l for l in tests if sys.argv.count(l[0]) > 0]
    tests = filteredTests
    print("Running only: ", tests)
if (sys.argv.count("-from") > 0):
    idx = [i for i in range(len(tests)) if sys.argv.count(tests[i][0]) > 0]
    if len(idx) > 0 :
        tests = tests[idx[0]:len(tests)]
        print("Running from: ", tests[0])
if (sys.argv.count("-notime") > 0):
    print("Not Timing")
    noTime = True
if (sys.argv.count("-ext") > 0):
    print("Extended Benchmarks")
    extended = True
if (sys.argv.count("-nocheck") > 0):
    print("Not Checking")
    noCheck = True
if (sys.argv.count("-small") > 0):
    print("Small Inputs")
    doSmall = True
if (sys.argv.count("-par") > 0):
    print("Parallel Only")
    parOnly = True
if (sys.argv.count("-scale") > 0):
    print("Scale Tests")
    scale = True
if (sys.argv.count("-nonuma") > 0):
    print("No numactl")
    useNumactl = False
if (sys.argv.count("-keep") > 0):
    print("Keeping temp data files")
    keep_tmp_files = True
if (sys.argv.count("-force") > 0):
    print("Forcing Compile")
    forceCompile = True
if (sys.argv.count("-h") > 0 or sys.argv.count("-help")):
    print("arguments:")
    print(" -force   : forces compile")
    print(" -nonuma  : do not use numactl -i all")
    print(" -scale   : run on a range of number of cores")
    print(" -par     : only run parallel benchmarks")
    print(" -notime  : only compile")
    print(" -nocheck : do not check results")
    print(" -small   : run on small data sets")
    print(" -keep    : keep temporary data files")
    print(" -ext     : extended set of benchmars")
    print(" -only <bnchmrk> : only run given benchmark")
    print(" -from <bnchmrk> : only run from given benchmark")
    forceCompile = True
    exit()

def detectCPUs():
    """
     Detects the number of CPUs on a system. Cribbed from pp.
     """
    # Linux, Unix and MacOS:
    if hasattr(os, "sysconf"):
       if os.sysconf_names.has_key("SC_NPROCESSORS_ONLN"):
           # Linux & Unix:
           ncpus = os.sysconf("SC_NPROCESSORS_ONLN")
           if isinstance(ncpus, int) and ncpus > 0:
               return ncpus
       else: # OSX:
           return int(os.popen2("sysctl -n hw.ncpu")[1].read())
    # Windows:
    if os.environ.has_key("NUMBER_OF_PROCESSORS"):
           ncpus = int(os.environ["NUMBER_OF_PROCESSORS"]);
           if ncpus > 0:
               return ncpus
    return 1 # Default

maxcpus = detectCPUs()

def getProcessors() :
    if maxcpus <= 16:
        processors = [1]+range(2,maxcpus+1,2)
    elif maxcpus <= 32:
        processors = [1,2]+range(4,maxcpus+1,4)
    elif maxcpus <= 40:
        processors = [1,4,16,20,40]
    elif maxcpus <= 64:
        processors = [1,2,4]+range(8,maxcpus+1,8)
    elif maxcpus == 144:
        processors = [1,4,16,32,72,144]
    elif maxcpus == 256:
        processors = [1,4,16,32,64,128,256]
    else:
        processors = [1,2,4,8]+range(16,maxcpus+1,16)
    print(processors)
    return processors

def compiletest(sdir) :
    dir = "benchmarks/" + sdir
    if (forceCompile) :
        ss = "cd " + dir + " ; make -s cleanall ; make -s"
    else :
        ss = "cd " + dir + " ; make -s"
    os.system("echo")
    os.system("echo \"" + ss + "\"")
    os.system(ss)

def runtest(test,procs,check) :
    if (procs==1) : rounds = 1
    elif (procs < 16) : rounds = 3
    elif (procs < 64) : rounds = 3
    else : rounds = 5
    dir = "benchmarks/" + test[0]
    numactl = useNumactl and (procs > 1)
    options = "-r " + `rounds`
    if (doSmall) : testInputs = "./testInputs_small"
    else : testInputs = "./testInputs"
    if (procs > 0) :
        options =  options + " -p " + `procs`
    if not(check):
        options = options + " -x"
    if keep_tmp_files:
        options = options + " -k"        
    if numactl:
        sc = "cd " + dir + " ; numactl -i all " + testInputs + " " + options
    else:
        sc = "cd " + dir + " ; " + testInputs + " " + options
    os.system("echo \"" + sc + "\"")
    x = os.system(sc)
    if (x) :
        raise NameError("  " + sc)

try :
    if scale : processors = getProcessors()
    else : os.system("echo " + "\"running on " + `maxcpus` + " threads\"")
    for test in tests :
        isParallel = test[1]
        primary = (int(test[2]) == 0)
        if (isParallel or not(parOnly)) and (primary or extended) :
            compiletest(test[0])
            if not(noTime) :
                if (not(isParallel)) :
                    runtest(test, 1, not(noCheck))
                elif (not(scale)) :
                    runtest(test, maxcpus, not(noCheck))
                else :
                    n = len(processors)
                    for p in processors[0:n-1] :
                        runtest(test, p, False)
                        os.system("echo")
                    runtest(test, processors[n-1], not(noCheck))

except NameError,v :
  x, = v
  print "TEST TERMINATED ABNORMALLY:\n"+x