def asynchronous_zfp():
sweep_parameters = [
p.ParamRunner('simulation', 'nprocs', [64]),
p.ParamCmdLineArg('simulation', 'settings', 1,
["settings-files.json"]),
p.ParamADIOS2XML('simulation', 'sim output engine', 'SimulationOutput',
'engine', [{
'BP4': {}
}]),
p.ParamRunner('pdf_calc', 'nprocs', [8]),
p.ParamCmdLineArg('pdf_calc', 'infile', 1, ['gs.bp']),
p.ParamCmdLineArg('pdf_calc', 'outfile', 2, ['pdf.bp']),
p.ParamCmdLineArg('pdf_calc', 'bins', 3, [100]),
p.ParamCmdLineArg('pdf_calc', 'write_orig_data', 4, ['YES']),
p.ParamADIOS2XML('pdf_calc', 'zfp compression', 'PDFAnalysisOutput',
'var_operation', [{
"U": {
"zfp": {
'accuracy': 0.001
}
}
}, {
"U": {
"zfp": {
'accuracy': 0.0001
}
}
}]),
]
sweep = p.Sweep(parameters=sweep_parameters,
rc_dependency={'pdf_calc': 'simulation'},
node_layout={'summit': node_layouts.separate_nodes()})
return sweep
class GrayScott(Campaign):
name = "gray_scott"
codes = [
("simulation", dict(exe="gray-scott", adios_xml_file='adios2.xml')),
("pdf_calc", dict(exe="pdf_calc", adios_xml_file='adios2.xml')),
]
supported_machines = ['local', 'titan', 'theta', 'summit']
kill_on_partial_failure = True
run_dir_setup_script = None
run_post_process_script = "cleanup.sh"
umask = '027'
scheduler_options = {
'theta': {
'project': 'CSC249ADCD01',
'queue': 'default'
},
'summit': {
'project': 'csc299'
}
}
app_config_scripts = {
'local': 'setup.sh',
'theta': 'env_setup.sh',
'summit': 'env-setup.sh'
}
# Create the sweeps
sw_posthoc = sweeps.posthoc_analysis()
sw_insitu_sep_nodes = sweeps.insitu_analysis(node_layouts.separate_nodes())
sw_insitu_shared_nodes = sweeps.insitu_analysis(node_layouts.share_nodes())
sw_insitu_shared_sockets = sweeps.insitu_analysis(
node_layouts.share_nodes_sockets())
sw_compression = sweeps.asynchronous_zfp()
# Create a SweepGroup and add the above Sweeps. Set batch job properties such as the no. of nodes,
sweepGroup1 = p.SweepGroup(
"sg-1",
walltime=1200,
per_run_timeout=200,
parameter_groups=[
sw_posthoc, sw_insitu_sep_nodes, sw_insitu_shared_nodes,
sw_insitu_shared_sockets, sw_compression
],
launch_mode='default',
# tau_profiling=True,
# tau_tracing=False,
#nodes=16,
component_inputs={
'simulation': ['settings-files.json', 'settings-staging.json'],
},
run_repetitions=2,
)
# Activate the SweepGroup
sweeps = {'summit': [sweepGroup1]}
def posthoc_analysis(sim_nprocs, analysis_nprocs):
sweep_parameters = [
p.ParamRunner('simulation', 'nprocs', [sim_nprocs]),
p.ParamCmdLineOption('simulation', 'sim input', '-in',
["in.lj.nordf"]),
p.ParamADIOS2XML('simulation', 'sim output engine', 'custom', 'engine',
[{
'BP4': {}
}]),
p.ParamRunner('rdf_calc', 'nprocs', [analysis_nprocs]),
p.ParamCmdLineOption('rdf_calc', 'input', '-in', ["in.lj.rdf.rerun"]),
]
sweep = p.Sweep(parameters=sweep_parameters,
rc_dependency={'rdf_calc': 'simulation'},
node_layout={'summit': node_layouts.separate_nodes()})
return sweep
def posthoc_analysis():
sweep_parameters = [
p.ParamRunner('simulation', 'nprocs', [4]),
p.ParamCmdLineArg('simulation', 'settings', 1,
["settings-files.json"]),
p.ParamADIOS2XML('simulation', 'sim output engine', 'SimulationOutput',
'engine', [{
'BP4': {}
}]),
p.ParamRunner('pdf_calc', 'nprocs', [4]),
p.ParamCmdLineArg('pdf_calc', 'infile', 1, ['gs.bp']),
p.ParamCmdLineArg('pdf_calc', 'outfile', 2, ['pdf.bp']),
]
sweep = p.Sweep(parameters=sweep_parameters,
rc_dependency={'pdf_calc': 'simulation'},
node_layout={'summit': node_layouts.separate_nodes()})
return sweep
class LAMMPS(Campaign):
name = "lammps"
codes = [
("simulation", dict(exe="lmp", adios_xml_file='adios2_config.xml')),
("rdf_calc", dict(exe="lmp", adios_xml_file='adios2_config.xml')),
("sim_inline_rdf_calc",
dict(exe="lmp", adios_xml_file='adios2_config.xml')),
]
supported_machines = ['local', 'titan', 'theta', 'summit']
kill_on_partial_failure = True
run_dir_setup_script = None
run_post_process_script = None
umask = '027'
scheduler_options = {
'theta': {
'project': 'CSC249ADCD01',
'queue': 'default'
},
'summit': {
'project': 'csc303'
}
}
app_config_scripts = {
'local': 'setup.sh',
'theta': 'env_setup.sh',
'summit': 'env-setup.sh'
}
sim_nodes = [1, 2]
analysis_nodes = [1]
sweeps = []
sg_count = 1
for s in sim_nodes:
for a in analysis_nodes:
if a > s:
continue
sw_inline = sweeps.inline_analysis(42 * (s + a))
sw_posthoc = sweeps.posthoc_analysis(42 * s, 42 * a)
sw_insitu_sst_sep_nodes = sweeps.insitu_analysis(
42 * s, 42 * a, node_layouts.separate_nodes(), 'SST')
sw_insitu_sst_shared_nodes_21to21 = sweeps.insitu_analysis(
21 * (s + a), 21 * (s + a), node_layouts.share_nodes_21to21(),
'SST')
sw_insitu_sst_shared_nodes_28to14 = sweeps.insitu_analysis(
28 * (s + a), 14 * (s + a), node_layouts.share_nodes_28to14(),
'SST')
sw_insitu_sst_shared_nodes_35to7 = sweeps.insitu_analysis(
35 * (s + a), 7 * (s + a), node_layouts.share_nodes_35to7(),
'SST')
sw_insitu_sst_shared_nodes_40to2 = sweeps.insitu_analysis(
40 * (s + a), 2 * (s + a), node_layouts.share_nodes_40to2(),
'SST')
sw_insitu_bp4_sep_nodes = sweeps.insitu_analysis(
42 * s, 42 * a, node_layouts.separate_nodes(), 'BP4')
sw_insitu_bp4_shared_nodes_21to21 = sweeps.insitu_analysis(
21 * (s + a), 21 * (s + a), node_layouts.share_nodes_21to21(),
'BP4')
sw_insitu_bp4_shared_nodes_28to14 = sweeps.insitu_analysis(
28 * (s + a), 14 * (s + a), node_layouts.share_nodes_28to14(),
'BP4')
sw_insitu_bp4_shared_nodes_35to7 = sweeps.insitu_analysis(
35 * (s + a), 7 * (s + a), node_layouts.share_nodes_35to7(),
'BP4')
sw_insitu_bp4_shared_nodes_40to2 = sweeps.insitu_analysis(
40 * (s + a), 2 * (s + a), node_layouts.share_nodes_40to2(),
'BP4')
# Create a SweepGroup and add the above Sweeps. Set batch job properties such as the no. of nodes,
sweepGroup = p.SweepGroup(
"sg-" + str(sg_count),
walltime=1200,
per_run_timeout=200,
parameter_groups=[
sw_inline, sw_posthoc, sw_insitu_sst_sep_nodes,
sw_insitu_sst_shared_nodes_21to21,
sw_insitu_sst_shared_nodes_28to14,
sw_insitu_sst_shared_nodes_35to7,
sw_insitu_sst_shared_nodes_40to2, sw_insitu_bp4_sep_nodes,
sw_insitu_bp4_shared_nodes_21to21,
sw_insitu_bp4_shared_nodes_28to14,
sw_insitu_bp4_shared_nodes_35to7,
sw_insitu_bp4_shared_nodes_40to2
],
launch_mode='default',
#nodes=16,
component_inputs={
'simulation': ['in.lj.nordf'],
'rdf_calc': ['in.lj.rdf.rerun'],
'sim_inline_rdf_calc': ['in.lj.rdf.nodump']
},
run_repetitions=2,
)
sg_count += 1
# Activate the SweepGroup
sweeps.append(sweepGroup)