def _solve(self, initialConfig, problemArchive):
try:
config = DOUGConfigParser(name='DOUG execution parameters')
config.addConfigContents(doug.execution.getDefaultConfigContents())
config.addConfig(initialConfig)
suffix = time.strftime('--run-%y%m%d-%H%M%S')
config.set('DEFAULT', 'doug-workdir', problemArchive.directoryName+suffix)
config.set('DEFAULT', 'doug-datadir', problemArchive.directoryName)
matrixFiles = problemArchive.getFiles('Matrix')
if matrixFiles:
matrixFile='%(doug-datadir)s/'+matrixFiles[0]
else:
matrixFile=''
config.set('doug-controls', 'assembled_mtx_file', matrixFile)
rhsFiles = problemArchive.getFiles('Vector/RHS')
if rhsFiles:
rhsFile='%(doug-datadir)s/'+rhsFiles[0]
else:
rhsFile=''
config.set('doug-controls', 'assembled_rhs_file', rhsFile)
# change configurations
configPanel = ConfigPanel(self.frame, config, title="DOUG configuration",
sectionNames=['DEFAULT', 'doug', 'doug-controls'])
if not configPanel.done:
return
# run
execution = doug.execution.DOUGExecution(config)
try:
archive = Archive(problemArchive.name+suffix,
directoryName=problemArchive.directoryName+suffix,
archiveType='solution')
archive.info.set('general','problem-name',problemArchive.name)
archive.info.addConfig(execution.config)
archive.info.set('doug-execution', 'date', time.strftime('%y-%m-%d %H:%M:%S'), addsection=True)
resultConfig=execution.run()
archive.info.addConfig(resultConfig)
if archive.info.has_option('doug-result', 'solutionfile'):
archive.setFileType(archive.info.get('doug-result', 'solutionfile'), 'Vector/Solution')
if archive.info.has_option('doug-result', 'errorfile'):
archive.setFileType(archive.info.get('doug-result', 'errorfile'), 'Text/Error')
if archive.info.has_option('doug-result', 'outputfile'):
archive.setFileType(archive.info.get('doug-result', 'outputfile'), 'Text/Output')
if archive.info.has_option('doug-result', 'fineaggrsfile'):
archive.setFileType(archive.info.get('doug-result', 'fineaggrsfile'), 'Aggregates/Fine')
if archive.info.has_option('doug-result', 'coarseaggrsfile'):
archive.setFileType(archive.info.get('doug-result', 'coarseaggrsfile'), 'Aggregates/Coarse')
if archive.info.has_option('doug-result', 'profilefile'):
archive.setFileType(archive.info.get('doug-result', 'profilefile'), 'Text/Profile')
finally:
self.app.addArchive(archive)
except(Exception), e:
LOG.error(e, exc_info=e)
class Archive(object):
DIRTY = 'DIRTY'
SAVED = 'SAVED'
ARCHIVED = 'ARCHIVED'
FILETYPES = ['', 'Grid', 'Matrix', 'Vector', 'Vector/RHS', 'Vector/Solution',
'Aggregates/Fine', 'Aggregates/Coarse', 'Text', 'Text/Output', 'Text/Error',
'Matrix/Connections']
def _setState(self, newstate): self._state=newstate
state = property(lambda self: self._state, fset=_setState)
def __init__(self, name=None, directoryName=None, archiveType='problem'):
self.name = name
self.filetypes = {} #: file name -> type
if directoryName==None:
directoryName = os.path.abspath(name)
if os.path.isdir(directoryName):
self._state = Archive.SAVED
self.directoryName = directoryName
self.load()
else:
os.mkdir(directoryName)
self._state = Archive.DIRTY
self.directoryName = directoryName
self.info = DOUGConfigParser()
self.info.add_section('general')
self.info.set('general', 'archive-type', archiveType)
self.info.add_section('files')
def save(self):
if self.state == Archive.DIRTY:
LOG.info("Saving '%s' to %s" % (self.name, self.directoryName))
config = copy.deepcopy(self.info)
config.set('general', 'name', self.name)
configFile = file(os.path.join(self.directoryName, '.info'), 'w')
files=map(lambda f: "%s:%s"%f, self.filetypes.items())
config.set('files', 'types', ", ".join(files))
config.write(configFile)
configFile.close()
def load(self):
LOG.info("Loading from %s" % self.directoryName)
config = DOUGConfigParser()
config.read([os.path.join(self.directoryName, '.info')])
self.info = config
if config.has_section('general'):
self.name = config.get('general', 'name')
else:
config.add_section('general')
if config.has_section('files'):
types = config.get('files', 'types', default="")
types = types.split(",")
types = filter(bool, types) # filter out empty strings
types = map(lambda s: map(str.strip, s.split(':')), types)
for filename, filetype in types:
self.setFileType(filename, filetype)
else:
config.add_section('files')
def close(self):
self.save()
def setFileType(self, filename, filetype):
if filetype==None:
if self.filetypes.has_key(filename):
del self.filetypes[filename]
else:
self.filetypes[filename] = filetype
if filetype=='Text/Profile':
self._readProfileFile(filename)
self.state = Archive.DIRTY
def _readProfileFile(self, filename):
f = open(os.path.join(self.directoryName, filename))
try:
for line in f:
line = line.strip()
proc, name, value = line.split(':')
name = name.replace(' ', '-')
self.info.set('doug-profile', name, value, addsection=True)
finally:
f.close()
def getFileType(self, filename):
return self.filetypes.get(filename, None)
def getFiles(self, filetype):
files = map(lambda g: g[0],
filter(lambda x: x[1]==filetype,
self.filetypes.items()))
return files
def __str__(self):
return "Archive(directory=%s)" % self.directoryName
def main(testResults):
# svn
if conf.getboolean('testscript', 'run-svn'):
svndoug = svnscripts.run(confFileNames, conf.defaults())
# autotools
if conf.getboolean('testscript', 'run-autotools'):
autotools.run(confFileNames, conf.defaults())
# construct tests
if conf.getboolean('testscript', 'run-tests'):
testSuite = unittest.TestSuite()
items = conf.items("tests")
for name, value in items:
if not name.startswith("test"): continue
tname = name[4:]
# read test data
ctrlfname, solutionfname, testconfs = tuple(value.strip().split(" ", 2))
ctrlfname = os.path.abspath(ctrlfname)
solutionfname = os.path.abspath(solutionfname)
datadir = os.path.dirname(ctrlfname)
LOG.debug("Constructing test '%s'" % (tname, ))
LOG.debug("Control file: %s" % ctrlfname)
LOG.debug("Correct solution file: %s" % (solutionfname,))
# read test configurations
testconfs = testconfs.split(",")
for testconf in testconfs:
testconfname = "testconf_%s" % testconf
testname = "%s_%s" % (tname, testconf)
solvers = map(int, conf.get(testconfname, "solver").split(","))
methods = map(int, conf.get(testconfname, "method").split(","))
levels = map(int, conf.get(testconfname, "levels").split(","))
fine_methods = map(int, conf.get(testconfname, "fine_methods").split(","))
nsubdomains = map(int, conf.get(testconfname, "num_subdomains").split(","))
processors = map(int, conf.get(testconfname, "processors").split(","))
executables = conf.get(testconfname, "executables").split(",")
overlaps = map(int, conf.get(testconfname, "overlaps").split(","))
smoothers = map(int, conf.get(testconfname, "smoothers").split(","))
testtuples = generateTuples(solvers, methods, levels, fine_methods, nsubdomains, processors, executables, overlaps, smoothers)
for solver,method,level,fine_method, nsubdomain,nproc,executable,overlap,smoother in testtuples:
dougControlFile = doug.execution.ControlFile(filename=ctrlfname, basedir=os.path.dirname(ctrlfname))
dougConfig = DOUGConfigParser(name='DOUG execution parameters')
# set/copy doug configuration from tests configuration
dougConfig.add_section('doug')
for name,value in conf.items('doug', raw=True):
dougConfig.set('doug', name, value)
dougConfig.add_section('doug-controls')
for name,value in conf._sections['doug-controls'].items():
dougConfig.set('doug-controls', name, value)
dougConfig.add_section('doug-tests')
dougConfig.set('doug-tests', 'csolution_file', solutionfname)
# set test configuration
dougConfig.set('doug-controls', 'solver', str(solver))
dougConfig.set('doug-controls', 'method', str(method))
dougConfig.set('doug-controls', 'levels', str(level))
dougConfig.set('doug-controls', 'fine_method', str(fine_method))
dougConfig.set('doug-controls', 'num_subdomains', str(nsubdomain))
dougConfig.set('doug', 'nproc', str(nproc))
dougConfig.set('doug', 'executable', executable)
dougConfig.set('doug-controls', 'overlap', str(overlap))
dougConfig.set('doug-controls', 'smoothers', str(smoother))
# create DOUG execution object
execution = doug.execution.DOUGExecution(dougConfig, dougControlFile)
test = dougtest.TestCase(execution, testname)
#resultConfig=execution.run()
#test = dougtest.MPITestCase(name+"_"+testconf, datadir, ctrlfname, solutionfname, conf, *testtuple)
testSuite.addTest(test)
# run tests
testRunner = dougtest.TestRunner(testResults)
testRunner.run(testSuite)
