def run(wf):
with NCDisplay() as display:
result = run_parallel_opt(wf,
2,
registry,
"cache.json",
display=display)
return result
def test_broker_logging():
A = log_add(1, 1)
B = sub(3, A)
multiples = [mul(log_add(i, B), A) for i in range(6)]
C = accumulate(noodles.gather(*multiples))
with NCDisplay(title="Running the test") as display:
assert run_parallel_with_display(C, 4, display) == 42
def call_xenon(job,
n_processes=1,
cache="cache.json",
user_name="x2sun",
adapter="slurm",
queue_name=None,
host_name="cartesius.surfsara.nl",
workdir=None,
timeout=60000,
**kwargs):
"""
See :
https://github.com/NLeSC/Xenon-examples/raw/master/doc/tutorial/xenon-tutorial.pdf
"""
dict_properties = {
"slurm": {
"xenon.adaptors.slurm.ignore.version": "true"
},
"pbs": {
"xenon.adaptors.pbs.ignore.version": "true"
},
}
with XenonKeeper(log_level="DEBUG") as Xe:
certificate = Xe.credentials.newCertificateCredential(
"ssh", os.environ["HOME"] + "/.ssh/id_rsa", user_name, "", None)
xenon_config = XenonConfig(
jobs_scheme=adapter,
location=host_name,
credential=certificate,
jobs_properties=dict_properties[adapter],
)
print(xenon_config.__dict__)
if workdir is None:
workdir = "/home/" + user_name
job_config = RemoteJobConfig(
registry=registry,
init=plams.init,
finish=plams.finish,
queue=queue_name,
time_out=timeout,
working_dir=workdir,
)
with NCDisplay() as display:
result = run_xenon_prov(job,
Xe,
cache,
n_processes,
xenon_config,
job_config,
display=display)
return result
def call_default(job, n_processes=1):
"""
Run locally using several threads.
"""
with NCDisplay() as display:
return run_parallel_opt(job,
n_threads=n_processes,
registry=registry,
jobdb_file='cache.json',
display=display)
def call_xenon(job,
n_processes=1,
cache='cache.json',
user_name='x2sun',
adapter='slurm',
queue_name=None,
host_name='cartesius.surfsara.nl',
workdir=None,
timeout=60000,
**kwargs):
"""
See :
https://github.com/NLeSC/Xenon-examples/raw/master/doc/tutorial/xenon-tutorial.pdf
"""
dict_properties = {
'slurm': {
'xenon.adaptors.slurm.ignore.version': 'true'
},
'pbs': {
'xenon.adaptors.pbs.ignore.version': 'true'
}
}
with XenonKeeper(log_level='DEBUG') as Xe:
certificate = Xe.credentials.newCertificateCredential(
'ssh', os.environ["HOME"] + '/.ssh/id_rsa', user_name, '', None)
xenon_config = XenonConfig(jobs_scheme=adapter,
location=host_name,
credential=certificate,
jobs_properties=dict_properties[adapter])
print(xenon_config.__dict__)
if workdir is None:
workdir = '/home/' + user_name
job_config = RemoteJobConfig(registry=registry,
init=plams.init,
finish=plams.finish,
queue=queue_name,
time_out=timeout,
working_dir=workdir)
with NCDisplay() as display:
result = run_xenon_prov(job,
Xe,
cache,
n_processes,
xenon_config,
job_config,
display=display)
return result
def call_default(job, n_processes=1, cache='cache.json'):
"""
Run locally using several threads.
Caching can be turned off by specifying cache=None
"""
with NCDisplay() as display:
if cache is None:
return run_parallel_with_display(
job, n_threads=n_processes,
display=display)
else:
return run_parallel_opt(
job, n_threads=n_processes,
registry=registry, jobdb_file=cache,
display=display)
def runNoodles(jsonFile, logFolder, numThreads):
global logFolderAbsPath
logFolderAbsPath = os.path.abspath(logFolder)
os.makedirs(logFolderAbsPath)
input = json.load(open(jsonFile, 'r'))
if input[0].get('task') is None:
jobs = [
make_job(td['command'], td['id'], td['exclude']) for td in input
]
else:
jobs = [
make_job(td['command'], td['task'], td['exclude']) for td in input
]
wf = noodles.gather(*jobs)
with NCDisplay(error_filter) as display:
run(wf, display=display, n_threads=numThreads)
def test_find_first():
global counter
wfs = [counted_sqr(x) for x in range(10)]
w = find_first(is_sixteen, wfs)
result = run_single(w)
assert result == 16
assert counter == 5
wfs = [counted_sqr(x) for x in range(10)]
w = find_first(is_sixteen, wfs)
result = run_process(w, n_processes=1, registry=base)
assert result == 16
wfs = [display_sqr(x) for x in range(10)]
w = find_first(is_sixteen, wfs)
with NCDisplay() as display:
result = run_logging(w, n_threads=2, display=display)
assert result == 16
def test_xenon_42():
A = log_add(1, 1)
B = sub(3, A)
multiples = [mul(log_add(i, B), A) for i in range(6)]
C = accumulate(noodles.gather(*multiples))
xenon_config = XenonConfig(jobs_scheme='local')
job_config = RemoteJobConfig(registry=serial.base, time_out=1000)
with XenonKeeper() as Xe, NCDisplay() as display:
result = run_xenon(C,
Xe,
"cache.json",
2,
xenon_config,
job_config,
display=display)
assert (result == 42)
def run(self, parameter_space, kernel_options, tuning_options):
""" Tune all instances in parameter_space using a multiple threads
:param parameter_space: The parameter space as an iterable.
:type parameter_space: iterable
:param kernel_options: A dictionary with all options for the kernel.
:type kernel_options: kernel_tuner.interface.Options
:param tuning_options: A dictionary with all options regarding the tuning
process.
:type tuning_options: kernel_tuner.interface.Options
:returns: A list of dictionaries for executed kernel configurations and their
execution times. And a dictionary that contains a information
about the hardware/software environment on which the tuning took place.
:rtype: list(dict()), dict()
"""
workflow = self._parameter_sweep(parameter_space, kernel_options,
self.device_options, tuning_options)
if tuning_options.verbose:
with NCDisplay(_error_filter) as display:
answer = run_parallel_with_display(workflow, self.max_threads,
display)
else:
answer = run_parallel(workflow, self.max_threads)
if answer is None:
print("Tuning did not return any results, did an error occur?")
return None
# Filter out None times
result = []
for chunk in answer:
result += [d for d in chunk if d['time']]
return result, {}
def run(
wf: object,
runner: str = 'parallel',
n_processes: int = 1,
cache: str = 'cache.db',
) -> Any:
"""Run a workflow `wf` using `runner` and `n_processes` number of threads/process."""
runner = runner.lower()
if isinstance(wf, Results):
wf = gather_dict(**wf.state)
if runner == 'display':
with NCDisplay() as display:
return run_logging(wf, n_processes, display)
elif runner == 'serial':
return run_single(wf)
else:
return run_provenance(wf,
n_threads=n_processes,
db_file=cache,
registry=registry,
echo_log=False,
always_cache=False)
s = read_input(args.material_file)
print(pprint_settings(cstool_model, s))
print()
print("Phonon loss: {:~P}".format(s.phonon.energy_loss))
print("Total molar weight: {:~P}".format(s.M_tot))
print("Number density: {:~P}".format(s.rho_n))
print("Brillouin zone energy: {:~P}".format(s.phonon.E_BZ))
print("Barrier energy: {:~P}".format(s.band_structure.barrier))
print()
print("# Computing Mott cross-sections using ELSEPA.")
e_mcs = np.logspace(1, 5, 145) * units.eV
f_mcs = s_mott_cs(s, e_mcs, split=12, mabs=False)
with NCDisplay() as display:
mcs = run_parallel_opt(f_mcs,
n_threads=4,
registry=registry,
jobdb_file='cache.json',
display=display)
print("# Merging elastic scattering processes.")
def elastic_cs_fn(a, E):
return log_interpolate(
lambda E: phonon_cs_fn(s)(a, E).to('cm^2').magnitude,
lambda E: mcs.unsafe(a,
E.to('eV').magnitude.flat), lambda x: x,
100 * units.eV, 200 * units.eV)(E) * units('cm^2/rad')