def test_parser(datadir):
from akrr.parsers.namd_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
results = process_appker_output(
appstdout=str(datadir / 'appstdout'),
stdout=str(datadir / 'stdout'),
stderr=str(datadir / 'stderr'),
geninfo=str(datadir / 'gen.info'),
resource_appker_vars={'resource': {'name': 'HPC-Cluster'}}
)
print(results)
# check resulting xml
xml_out = ElementTree.fromstring(results)
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
assert xml_out.find('./exitStatus/completed').text == "true"
assert len(params.find(".//parameter[ID='App:ExeBinSignature']").find('value').text) > 5
assert params.find(".//parameter[ID='App:NCores']").find('value').text == "128"
assert params.find(".//parameter[ID='App:NNodes']").find('value').text == "4"
assert len(params.find(".//parameter[ID='RunEnv:Nodes']").find('value').text) > 5
assert params.find(".//parameter[ID='resource']").find('value').text == "HPC-Cluster"
assert params.find(".//parameter[ID='App:Version']").find('value').text == "2.13b1"
assert params.find(".//parameter[ID='Input:Coordinate File']").find('value').text == "apoa1.pdb"
assert params.find(".//parameter[ID='Input:Number of Angles']").find('value').text == "74136"
assert params.find(".//parameter[ID='Input:Number of Atoms']").find('value').text == "92224"
assert params.find(".//parameter[ID='Input:Number of Bonds']").find('value').text == "70660"
assert params.find(".//parameter[ID='Input:Number of Dihedrals']").find('value').text == "74130"
assert params.find(".//parameter[ID='Input:Number of Steps']").find('value').text == "1200"
assert params.find(".//parameter[ID='Input:Structure File']").find('value').text == "apoa1.psf"
assert params.find(".//parameter[ID='Input:Timestep']").find('value').text == "2e-15"
assert floats_are_close(
float(stats.find(".//statistic[ID='Memory']").find('value').text), 586.160156)
assert floats_are_close(
float(stats.find(".//statistic[ID='Molecular Dynamics Simulation Performance']").find('value').text),
1.8502551501852105e-08)
assert floats_are_close(
float(stats.find(".//statistic[ID='Wall Clock Time']").find('value').text), 36.651707)
assert stats.find(".//statistic[ID='App kernel executable exists']").find('value').text == '1'
assert stats.find(".//statistic[ID='App kernel input exists']").find('value').text == '1'
assert stats.find(".//statistic[ID='Network scratch directory accessible']").find('value').text == '1'
assert stats.find(".//statistic[ID='Network scratch directory exists']").find('value').text == '1'
assert stats.find(".//statistic[ID='Task working directory accessible']").find('value').text == '1'
assert stats.find(".//statistic[ID='Task working directory exists']").find('value').text == '1'
assert stats.find(".//statistic[ID='local scratch directory accessible']").find('value').text == '1'
assert stats.find(".//statistic[ID='local scratch directory exists']").find('value').text == '1'
def test_parser(datadir):
from akrr.parsers.lammps_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
from .xml_comparison import parstat_val, parstat_val_f, parstat_val_i
results = process_appker_output(
appstdout=str(datadir / 'appstdout'),
stdout=str(datadir / 'stdout'),
stderr=str(datadir / 'stderr'),
geninfo=str(datadir / 'gen.info'),
resource_appker_vars={'resource': {'name': 'HPC-Cluster'}}
)
# check resulting xml
xml_out = ElementTree.fromstring(results.replace("'", ""))
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
assert xml_out.find('./exitStatus/completed').text == "true"
# Compare parameters to reference
assert len(parstat_val(params, "App:ExeBinSignature")) > 5
assert len(parstat_val(params, "RunEnv:Nodes")) > 5
assert parstat_val(params, "resource") == "HPC-Cluster"
assert parstat_val(params, "App:Version") == "1 May 2010"
assert parstat_val_i(params, "Input:Number of Atoms") == 32000
assert parstat_val_i(params, "Input:Number of Steps") == 4000
assert floats_are_close(parstat_val_f(params, "Input:Timestep"), 2e-15)
# Compare stats to reference
assert parstat_val_i(stats, "App kernel executable exists") == 1
assert parstat_val_i(stats, "App kernel input exists") == 1
assert parstat_val_i(stats, "Task working directory accessible") == 1
assert parstat_val_i(stats, "Task working directory exists") == 1
assert parstat_val_i(stats, "local scratch directory accessible") == 1
assert parstat_val_i(stats, "local scratch directory exists") == 1
assert parstat_val_i(stats, "Network scratch directory accessible") == 1
assert parstat_val_i(stats, "Network scratch directory exists") == 1
assert floats_are_close(parstat_val_f(stats, "Molecular Dynamics Simulation Performance"), 7.1538502141911645e-09)
assert floats_are_close(parstat_val_f(stats, "Per-Process Memory"), 11.8058)
assert floats_are_close(parstat_val_f(stats, "Time Spent in Bond Potential Calculation"), 3.04537)
assert floats_are_close(parstat_val_f(stats, "Time Spent in Communication"), 3.19531)
assert floats_are_close(parstat_val_f(stats, "Time Spent in Long-Range Coulomb Potential (K-Space) Calculation"),
22.1585)
assert floats_are_close(parstat_val_f(stats, "Time Spent in Neighbor List Regeneration"), 9.04183)
assert floats_are_close(parstat_val_f(stats, "Time Spent in Pairwise Potential Calculation"), 54.2335)
assert floats_are_close(parstat_val_f(stats, "Wall Clock Time"), 96.6193)
def test_get_float_or_int(a, result):
from akrr.util import floats_are_close, get_float_or_int
b = get_float_or_int(a)
assert type(b) == type(result)
if isinstance(result, int):
assert b == result
elif isinstance(result, float):
assert floats_are_close(b, result)
else:
assert 0
def test_parser(datadir):
from akrr.parsers.gromacs_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
from .xml_comparison import parstat_val, parstat_val_f, parstat_val_i
results = process_appker_output(
appstdout=str(datadir / 'appstdout'),
stdout=str(datadir / 'stdout'),
stderr=str(datadir / 'stderr'),
geninfo=str(datadir / 'gen.info'),
resource_appker_vars={'resource': {
'name': 'HPC-Cluster'
}})
# check resulting xml
xml_out = ElementTree.fromstring(results.replace("'", ""))
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
assert xml_out.find('./exitStatus/completed').text == "true"
# Compare parameters to reference
assert len(parstat_val(params, "App:ExeBinSignature")) > 5
assert len(parstat_val(params, "RunEnv:Nodes")) > 5
assert parstat_val(params, "resource") == "HPC-Cluster"
assert floats_are_close(parstat_val_f(params, "App:Version"), 2020.4)
# Compare stats to reference
assert parstat_val_i(stats, "App kernel executable exists") == 1
assert parstat_val_i(stats, "App kernel input exists") == 1
assert parstat_val_i(stats, "Task working directory accessible") == 1
assert parstat_val_i(stats, "Task working directory exists") == 1
assert parstat_val_i(stats, "local scratch directory accessible") == 1
assert parstat_val_i(stats, "local scratch directory exists") == 1
assert parstat_val_i(stats, "Network scratch directory accessible") == 1
assert parstat_val_i(stats, "Network scratch directory exists") == 1
assert floats_are_close(parstat_val_f(stats, "Core Clock Time"), 6977.538)
assert floats_are_close(parstat_val_f(stats, "Simulation Speed"), 3.963)
assert floats_are_close(parstat_val_f(stats, "Wall Clock Time"), 436.098)
def test_parser(datadir):
from akrr.parsers.quantum_espresso_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
from .xml_comparison import parstat_val, parstat_val_f, parstat_val_i
results = process_appker_output(
appstdout=str(datadir / 'appstdout'),
stdout=str(datadir / 'stdout'),
stderr=str(datadir / 'stderr'),
geninfo=str(datadir / 'gen.info'),
resource_appker_vars={'resource': {
'name': 'HPC-Cluster'
}})
# check resulting xml
xml_out = ElementTree.fromstring(results.replace("'", ""))
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
assert xml_out.find('./exitStatus/completed').text == "true"
# Compare parameters to reference
assert len(parstat_val(params, "App:ExeBinSignature")) > 5
assert len(parstat_val(params, "RunEnv:Nodes")) > 5
assert parstat_val(params, "resource") == "HPC-Cluster"
assert parstat_val(params, "App:Version") == "v.4.2.1"
assert parstat_val_i(params, "Input:Number of Atomic Types") == 2
assert parstat_val_i(params, "Input:Number of Atoms per Cell") == 63
assert floats_are_close(parstat_val_f(params, "Input:Number of Electrons"),
564.00)
# Compare stats to reference
assert parstat_val_i(stats, "App kernel executable exists") == 1
assert parstat_val_i(stats, "App kernel input exists") == 1
assert parstat_val_i(stats, "Task working directory accessible") == 1
assert parstat_val_i(stats, "Task working directory exists") == 1
assert parstat_val_i(stats, "local scratch directory accessible") == 1
assert parstat_val_i(stats, "local scratch directory exists") == 1
assert parstat_val_i(stats, "Network scratch directory accessible") == 1
assert parstat_val_i(stats, "Network scratch directory exists") == 1
assert floats_are_close(
parstat_val_f(stats, "Per-Process Dynamical Memory"), 77.6)
assert floats_are_close(
parstat_val_f(stats, "Time Spent in Electron Energy Calculation"),
149.84)
assert floats_are_close(
parstat_val_f(stats, "Time Spent in Force Calculation"), 2.24)
assert floats_are_close(
parstat_val_f(stats, "Time Spent in Program Initialization"), 2.79)
assert floats_are_close(parstat_val_f(stats, "User Time"), 155.69)
assert floats_are_close(parstat_val_f(stats, "Wall Clock Time"), 157.34)
def test_parser(datadir):
from akrr.parsers.amber_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
from .xml_comparison import parstat_val, parstat_val_f, parstat_val_i
results = process_appker_output(
appstdout=str(datadir / 'appstdout'),
stdout=str(datadir / 'stdout'),
stderr=str(datadir / 'stderr'),
geninfo=str(datadir / 'gen.info'),
resource_appker_vars={'resource': {'name': 'HPC-Cluster'}}
)
# check resulting xml
xml_out = ElementTree.fromstring(results.replace("'", ""))
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
assert xml_out.find('./exitStatus/completed').text == "true"
# Compare parameters to reference
assert len(parstat_val(params, "App:ExeBinSignature")) > 5
assert len(parstat_val(params, "RunEnv:Nodes")) > 5
assert parstat_val(params, "resource") == "HPC-Cluster"
assert parstat_val(params, "App:Version") == "PMEMD 11"
assert parstat_val(params, "Input:Coordinate File") == "inpcrd"
assert parstat_val_i(params, "Input:Number of Angles") == 4561
assert parstat_val_i(params, "Input:Number of Atoms") == 23558
assert parstat_val_i(params, "Input:Number of Bonds") == 23592
assert parstat_val_i(params, "Input:Number of Dihedrals") == 8166
assert parstat_val_i(params, "Input:Number of Steps") == 10000
assert parstat_val(params, "Input:Structure File") == "prmtop"
assert floats_are_close(parstat_val_f(params, "Input:Timestep"), 2e-15)
# Compare stats to reference
assert parstat_val_i(stats, "App kernel executable exists") == 1
assert parstat_val_i(stats, "App kernel input exists") == 1
assert parstat_val_i(stats, "Task working directory accessible") == 1
assert parstat_val_i(stats, "Task working directory exists") == 1
assert parstat_val_i(stats, "local scratch directory accessible") == 1
assert parstat_val_i(stats, "local scratch directory exists") == 1
assert parstat_val_i(stats, "Network scratch directory accessible") == 1
assert parstat_val_i(stats, "Network scratch directory exists") == 1
assert floats_are_close(parstat_val_f(stats, "Molecular Dynamics Simulation Performance"), 2.2153846153846156e-08)
assert parstat_val_i(stats, "Network scratch directory accessible") == 1
assert parstat_val_i(stats, "Network scratch directory exists") == 1
assert parstat_val_i(stats, "Task working directory accessible") == 1
assert parstat_val_i(stats, "Task working directory exists") == 1
assert floats_are_close(parstat_val_f(stats, "Time Spent in Direct Force Calculation"), 42.76)
assert floats_are_close(parstat_val_f(stats, "Time Spent in Non-Bond List Regeneration"), 6.81)
assert floats_are_close(parstat_val_f(stats, "Time Spent in Reciprocal Force Calculation"), 9.86)
assert floats_are_close(parstat_val_f(stats, "Wall Clock Time"), 78.0)
def test_parser_v32(datadir):
from akrr.parsers.ior_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
from .xml_comparison import parstat_val, parstat_val_f, parstat_val_i
results = process_appker_output(
appstdout=str(datadir / 'v32' / 'appstdout'),
stdout=str(datadir / 'v32' / 'stdout'),
stderr=str(datadir / 'v32' / 'stderr'),
geninfo=str(datadir / 'v32' / 'gen.info'),
resource_appker_vars={'resource': {
'name': 'HPC-Cluster'
}})
# check resulting xml
xml_out = ElementTree.fromstring(results)
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
assert xml_out.find('./exitStatus/completed').text == "true"
# Compare parameters to reference
assert len(parstat_val(params, "App:ExeBinSignature")) > 5
assert len(parstat_val(params, "RunEnv:Nodes")) > 5
assert parstat_val(params, "App:Version") == "3.2.0"
assert parstat_val(params, "HDF Version") == "1.8.21 (Parallel)"
assert parstat_val(
params, "HDF5 Collective N-to-1 Test File System"
) == "nfs ifs-x410.cbls.ccr.buffalo.edu:/ifs/projects /projects"
assert parstat_val(
params, "HDF5 Independent N-to-1 Test File System"
) == "nfs ifs-x410.cbls.ccr.buffalo.edu:/ifs/projects /projects"
assert parstat_val(
params, "HDF5 N-to-N Test File System"
) == "nfs ifs-x410.cbls.ccr.buffalo.edu:/ifs/projects /projects"
assert parstat_val(
params, "MPIIO Collective N-to-1 Test File System"
) == "nfs ifs-x410.cbls.ccr.buffalo.edu:/ifs/projects /projects"
assert parstat_val(
params, "MPIIO Independent N-to-1 Test File System"
) == "nfs ifs-x410.cbls.ccr.buffalo.edu:/ifs/projects /projects"
assert parstat_val(
params, "MPIIO N-to-N Test File System"
) == "nfs ifs-x410.cbls.ccr.buffalo.edu:/ifs/projects /projects"
assert parstat_val(params, "MPIIO Version") == "(3.1)"
assert parstat_val(
params, "POSIX N-to-1 Test File System"
) == "nfs ifs-x410.cbls.ccr.buffalo.edu:/ifs/projects /projects"
assert parstat_val(
params, "POSIX N-to-N Test File System"
) == "nfs ifs-x410.cbls.ccr.buffalo.edu:/ifs/projects /projects"
assert parstat_val(
params, "Parallel NetCDF Collective N-to-1 Test File System"
) == "nfs ifs-x410.cbls.ccr.buffalo.edu:/ifs/projects /projects"
assert parstat_val(
params, "Parallel NetCDF Independent N-to-1 Test File System"
) == "nfs ifs-x410.cbls.ccr.buffalo.edu:/ifs/projects /projects"
assert parstat_val(params,
"Parallel NetCDF Version") == "1.11.1 of 12 Apr 2019"
assert floats_are_close(parstat_val_f(params, "Per-Process Data Size"),
200.0)
assert floats_are_close(
parstat_val_f(params, "Per-Process I/O Block Size"), 200.0)
assert floats_are_close(parstat_val_f(params, "Transfer Size Per I/O"),
20.0)
# Compare stats to reference
assert floats_are_close(
parstat_val_f(stats, "HDF5 Collective N-to-1 File Close Time (Read)"),
0.000979)
assert floats_are_close(
parstat_val_f(stats,
"HDF5 Collective N-to-1 File Close Time (Write)"),
0.026462)
assert floats_are_close(
parstat_val_f(stats, "HDF5 Collective N-to-1 File Open Time (Read)"),
0.046134)
assert floats_are_close(
parstat_val_f(stats, "HDF5 Collective N-to-1 File Open Time (Write)"),
0.011664)
assert floats_are_close(
parstat_val_f(stats,
"HDF5 Collective N-to-1 Read Aggregate Throughput"),
129.41)
assert floats_are_close(
parstat_val_f(stats,
"HDF5 Collective N-to-1 Write Aggregate Throughput"),
30.94)
assert floats_are_close(
parstat_val_f(stats,
"HDF5 Independent N-to-1 File Close Time (Read)"), 1.97)
assert floats_are_close(
parstat_val_f(stats,
"HDF5 Independent N-to-1 File Close Time (Write)"),
4.76)
assert floats_are_close(
parstat_val_f(stats, "HDF5 Independent N-to-1 File Open Time (Read)"),
0.249513)
assert floats_are_close(
parstat_val_f(stats,
"HDF5 Independent N-to-1 File Open Time (Write)"),
0.056971)
assert floats_are_close(
parstat_val_f(stats,
"HDF5 Independent N-to-1 Read Aggregate Throughput"),
227.80)
assert floats_are_close(
parstat_val_f(stats,
"HDF5 Independent N-to-1 Write Aggregate Throughput"),
82.61)
assert floats_are_close(
parstat_val_f(stats, "HDF5 N-to-N File Close Time (Read)"), 1.94)
assert floats_are_close(
parstat_val_f(stats, "HDF5 N-to-N File Close Time (Write)"), 1.01)
assert floats_are_close(
parstat_val_f(stats, "HDF5 N-to-N File Open Time (Read)"), 0.120476)
assert floats_are_close(
parstat_val_f(stats, "HDF5 N-to-N File Open Time (Write)"), 0.129497)
assert floats_are_close(
parstat_val_f(stats, "HDF5 N-to-N Read Aggregate Throughput"), 260.06)
assert floats_are_close(
parstat_val_f(stats, "HDF5 N-to-N Write Aggregate Throughput"), 232.32)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Collective N-to-1 File Close Time (Read)"),
0.002445)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Collective N-to-1 File Close Time (Write)"),
3.17)
assert floats_are_close(
parstat_val_f(stats, "MPIIO Collective N-to-1 File Open Time (Read)"),
0.007683)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Collective N-to-1 File Open Time (Write)"),
0.021469)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Collective N-to-1 Read Aggregate Throughput"),
98.98)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Collective N-to-1 Write Aggregate Throughput"),
88.23)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Independent N-to-1 File Close Time (Read)"),
1.95)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Independent N-to-1 File Close Time (Write)"),
6.63)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Independent N-to-1 File Open Time (Read)"),
0.006738)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Independent N-to-1 File Open Time (Write)"),
0.145597)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Independent N-to-1 Read Aggregate Throughput"),
231.93)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Independent N-to-1 Write Aggregate Throughput"),
83.63)
assert floats_are_close(
parstat_val_f(stats, "MPIIO N-to-N File Close Time (Read)"), 1.88)
assert floats_are_close(
parstat_val_f(stats, "MPIIO N-to-N File Close Time (Write)"), 1.46)
assert floats_are_close(
parstat_val_f(stats, "MPIIO N-to-N File Open Time (Read)"), 0.009436)
assert floats_are_close(
parstat_val_f(stats, "MPIIO N-to-N File Open Time (Write)"), 0.290233)
assert floats_are_close(
parstat_val_f(stats, "MPIIO N-to-N Read Aggregate Throughput"), 260.99)
assert floats_are_close(
parstat_val_f(stats, "MPIIO N-to-N Write Aggregate Throughput"),
225.65)
assert parstat_val_i(stats, "Number of Tests Passed") == 10
assert parstat_val_i(stats, "Number of Tests Started") == 10
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-1 File Close Time (Read)"), 3.64)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-1 File Close Time (Write)"), 34.82)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-1 File Open Time (Read)"), 0.041881)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-1 File Open Time (Write)"), 0.554965)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-1 Read Aggregate Throughput"), 261.32)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-1 Write Aggregate Throughput"), 91.52)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-N File Close Time (Read)"), 2.17)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-N File Close Time (Write)"), 13.85)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-N File Open Time (Read)"), 0.178423)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-N File Open Time (Write)"), 0.115553)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-N Read Aggregate Throughput"), 268.57)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-N Write Aggregate Throughput"),
228.30)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Collective N-to-1 File Close Time (Read)"),
0.114754)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Collective N-to-1 File Close Time (Write)"),
0.000259)
assert floats_are_close(
parstat_val_f(
stats, "Parallel NetCDF Collective N-to-1 File Open Time (Read)"),
0.210366)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Collective N-to-1 File Open Time (Write)"),
0.008537)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Collective N-to-1 Read Aggregate Throughput"),
213.89)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Collective N-to-1 Write Aggregate Throughput"),
92.22)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Independent N-to-1 File Close Time (Read)"),
2.47)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Independent N-to-1 File Close Time (Write)"),
6.11)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Independent N-to-1 File Open Time (Read)"),
0.259060)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Independent N-to-1 File Open Time (Write)"),
0.007681)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Independent N-to-1 Read Aggregate Throughput"),
193.72)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Independent N-to-1 Write Aggregate Throughput"),
87.93)
assert floats_are_close(parstat_val_f(stats, "Wall Clock Time"), 561.0)
def test_floats_are_close(a, b, tol, result):
from akrr.util import floats_are_close
if tol is None:
assert floats_are_close(a, b) == result
else:
assert floats_are_close(a, b, tol) == result
def test_parser(datadir):
from akrr.parsers.imb_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
from .xml_comparison import parstat_val, parstat_val_f, parstat_val_i
results = process_appker_output(
appstdout=str(datadir / 'appstdout'),
stdout=str(datadir / 'stdout'),
stderr=str(datadir / 'stderr'),
geninfo=str(datadir / 'gen.info'),
resource_appker_vars={'resource': {
'name': 'HPC-Cluster'
}})
# check resulting xml
xml_out = ElementTree.fromstring(results.replace("'", ""))
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
assert xml_out.find('./exitStatus/completed').text == "true"
# Compare parameters to reference
assert len(parstat_val(params, "App:ExeBinSignature")) > 5
assert len(parstat_val(params, "RunEnv:Nodes")) > 5
assert floats_are_close(parstat_val_f(params, "App:MPI Version"), 3.1)
assert floats_are_close(parstat_val_f(params, "App:Max Message Size"), 4.0)
assert parstat_val(params, "resource") == "HPC-Cluster"
# Compare stats to reference
assert parstat_val_i(stats, "App kernel executable exists") == 1
assert parstat_val_i(stats, "App kernel input exists") == 1
assert parstat_val_i(stats, "Task working directory accessible") == 1
assert parstat_val_i(stats, "Task working directory exists") == 1
assert parstat_val_i(stats, "local scratch directory accessible") == 1
assert parstat_val_i(stats, "local scratch directory exists") == 1
assert parstat_val_i(stats, "Network scratch directory accessible") == 1
assert parstat_val_i(stats, "Network scratch directory exists") == 1
assert floats_are_close(parstat_val_f(stats, "Max Exchange Bandwidth"),
18536.14)
assert floats_are_close(
parstat_val_f(stats,
"Max MPI-2 Bidirectional Get Bandwidth (aggregate)"),
1619.75)
assert floats_are_close(
parstat_val_f(stats,
"Max MPI-2 Bidirectional Get Bandwidth (non-aggregate)"),
3465.83)
assert floats_are_close(
parstat_val_f(stats,
"Max MPI-2 Bidirectional Put Bandwidth (aggregate)"),
10857.36)
assert floats_are_close(
parstat_val_f(stats,
"Max MPI-2 Bidirectional Put Bandwidth (non-aggregate)"),
11046.2)
assert floats_are_close(
parstat_val_f(stats,
"Max MPI-2 Unidirectional Get Bandwidth (aggregate)"),
3664.45)
assert floats_are_close(
parstat_val_f(
stats, "Max MPI-2 Unidirectional Get Bandwidth (non-aggregate)"),
3809.56)
assert floats_are_close(
parstat_val_f(stats,
"Max MPI-2 Unidirectional Put Bandwidth (aggregate)"),
12090.85)
assert floats_are_close(
parstat_val_f(
stats, "Max MPI-2 Unidirectional Put Bandwidth (non-aggregate)"),
11589.06)
assert floats_are_close(parstat_val_f(stats, "Max PingPing Bandwidth"),
11277.77)
assert floats_are_close(parstat_val_f(stats, "Max PingPong Bandwidth"),
11833.44)
assert floats_are_close(parstat_val_f(stats, "Max SendRecv Bandwidth"),
18086.86)
assert floats_are_close(parstat_val_f(stats, "Min AllGather Latency"),
4.669999999999999e-06)
assert floats_are_close(parstat_val_f(stats, "Min AllGatherV Latency"),
4.8299999999999995e-06)
assert floats_are_close(parstat_val_f(stats, "Min AllReduce Latency"),
4.69e-06)
assert floats_are_close(parstat_val_f(stats, "Min AllToAll Latency"),
4.16e-06)
assert floats_are_close(parstat_val_f(stats, "Min AllToAllV Latency"),
4.24e-06)
assert floats_are_close(parstat_val_f(stats, "Min Barrier Latency"),
4.41e-06)
assert floats_are_close(parstat_val_f(stats, "Min Broadcast Latency"),
1.83e-06)
assert floats_are_close(parstat_val_f(stats, "Min Gather Latency"),
6.5e-07)
assert floats_are_close(parstat_val_f(stats, "Min GatherV Latency"),
4.2099999999999995e-06)
assert floats_are_close(
parstat_val_f(stats, "Min MPI-2 Accumulate Latency (aggregate)"),
3.8499999999999996e-06)
assert floats_are_close(
parstat_val_f(stats, "Min MPI-2 Accumulate Latency (non-aggregate)"),
1.3539999999999999e-05)
assert floats_are_close(
parstat_val_f(stats, "Min MPI-2 Window Creation Latency"),
5.4189999999999994e-05)
assert floats_are_close(parstat_val_f(stats, "Min Reduce Latency"),
3.92e-06)
assert floats_are_close(parstat_val_f(stats, "Min ReduceScatter Latency"),
2.35e-06)
assert floats_are_close(parstat_val_f(stats, "Min Scatter Latency"),
1.47e-06)
assert floats_are_close(parstat_val_f(stats, "Min ScatterV Latency"),
1.48e-06)
assert floats_are_close(parstat_val_f(stats, "Wall Clock Time"), 48.0)
def test_parser_v30(datadir):
from akrr.parsers.ior_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
from .xml_comparison import parstat_val, parstat_val_f, parstat_val_i
results = process_appker_output(
appstdout=str(datadir / 'v30' / 'appstdout'),
stdout=str(datadir / 'v30' / 'stdout'),
stderr=str(datadir / 'v30' / 'stderr'),
geninfo=str(datadir / 'v30' / 'gen.info'),
resource_appker_vars={'resource': {
'name': 'HPC-Cluster'
}})
# check resulting xml
xml_out = ElementTree.fromstring(results)
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
assert xml_out.find('./exitStatus/completed').text == "true"
# Compare parameters to reference
assert len(parstat_val(params, "App:ExeBinSignature")) > 5
assert len(parstat_val(params, "RunEnv:Nodes")) > 5
assert parstat_val(params, "App:Version") == "3.0.1"
assert parstat_val(params, "HDF Version") == "1.8.14 (Parallel)"
assert parstat_val(
params,
"HDF5 Collective N-to-1 Test File System") == "gpfs gpfs0 /gpfs"
assert parstat_val(
params,
"HDF5 Independent N-to-1 Test File System") == "gpfs gpfs0 /gpfs"
assert parstat_val(params,
"HDF5 N-to-N Test File System") == "gpfs gpfs0 /gpfs"
assert parstat_val(
params,
"MPIIO Collective N-to-1 Test File System") == "gpfs gpfs0 /gpfs"
assert parstat_val(
params,
"MPIIO Independent N-to-1 Test File System") == "gpfs gpfs0 /gpfs"
assert parstat_val(params,
"MPIIO N-to-N Test File System") == "gpfs gpfs0 /gpfs"
assert parstat_val(params, "MPIIO Version") == "(version=3, subversion=1)"
assert parstat_val(params,
"POSIX N-to-1 Test File System") == "gpfs gpfs0 /gpfs"
assert parstat_val(params,
"POSIX N-to-N Test File System") == "gpfs gpfs0 /gpfs"
assert parstat_val(params,
"Parallel NetCDF Collective N-to-1 Test File System"
) == "gpfs gpfs0 /gpfs"
assert parstat_val(params,
"Parallel NetCDF Independent N-to-1 Test File System"
) == "gpfs gpfs0 /gpfs"
assert parstat_val(
params,
"Parallel NetCDF Version") == "(version = 1.3.1 of 24 Sep 2012)"
assert floats_are_close(parstat_val_f(params, "Per-Process Data Size"),
200.0)
assert floats_are_close(
parstat_val_f(params, "Per-Process I/O Block Size"), 200.0)
assert floats_are_close(parstat_val_f(params, "Transfer Size Per I/O"),
20.0)
assert parstat_val(params, "resource") == "HPC-Cluster"
# Compare stats to reference
assert parstat_val_i(stats, "App kernel executable exists") == 1
assert parstat_val_i(stats, "App kernel input exists") == 1
assert parstat_val_i(stats, "Task working directory accessible") == 1
assert parstat_val_i(stats, "Task working directory exists") == 1
assert parstat_val_i(stats, "local scratch directory accessible") == 1
assert parstat_val_i(stats, "local scratch directory exists") == 1
assert parstat_val_i(stats, "Network scratch directory accessible") == 1
assert parstat_val_i(stats, "Network scratch directory exists") == 1
assert floats_are_close(
parstat_val_f(stats, "HDF5 Collective N-to-1 File Close Time (Read)"),
0.078640)
assert floats_are_close(
parstat_val_f(stats,
"HDF5 Collective N-to-1 File Close Time (Write)"), 2.12)
assert floats_are_close(
parstat_val_f(stats, "HDF5 Collective N-to-1 File Open Time (Read)"),
0.384665)
assert floats_are_close(
parstat_val_f(stats, "HDF5 Collective N-to-1 File Open Time (Write)"),
0.771071)
assert floats_are_close(
parstat_val_f(stats,
"HDF5 Collective N-to-1 Read Aggregate Throughput"),
411.51)
assert floats_are_close(
parstat_val_f(stats,
"HDF5 Collective N-to-1 Write Aggregate Throughput"),
189.38)
assert floats_are_close(
parstat_val_f(stats,
"HDF5 Independent N-to-1 File Close Time (Read)"), 7.54)
assert floats_are_close(
parstat_val_f(stats,
"HDF5 Independent N-to-1 File Close Time (Write)"),
17.24)
assert floats_are_close(
parstat_val_f(stats, "HDF5 Independent N-to-1 File Open Time (Read)"),
0.465735)
assert floats_are_close(
parstat_val_f(stats,
"HDF5 Independent N-to-1 File Open Time (Write)"),
0.797255)
assert floats_are_close(
parstat_val_f(stats,
"HDF5 Independent N-to-1 Read Aggregate Throughput"),
812.37)
assert floats_are_close(
parstat_val_f(stats,
"HDF5 Independent N-to-1 Write Aggregate Throughput"),
544.09)
assert floats_are_close(
parstat_val_f(stats, "HDF5 N-to-N File Close Time (Read)"), 17.68)
assert floats_are_close(
parstat_val_f(stats, "HDF5 N-to-N File Close Time (Write)"), 25.30)
assert floats_are_close(
parstat_val_f(stats, "HDF5 N-to-N File Open Time (Read)"), 10.95)
assert floats_are_close(
parstat_val_f(stats, "HDF5 N-to-N File Open Time (Write)"), 24.63)
assert floats_are_close(
parstat_val_f(stats, "HDF5 N-to-N Read Aggregate Throughput"), 929.46)
assert floats_are_close(
parstat_val_f(stats, "HDF5 N-to-N Write Aggregate Throughput"), 755.65)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Collective N-to-1 File Close Time (Read)"),
0.174882)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Collective N-to-1 File Close Time (Write)"),
3.86)
assert floats_are_close(
parstat_val_f(stats, "MPIIO Collective N-to-1 File Open Time (Read)"),
0.803321)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Collective N-to-1 File Open Time (Write)"),
0.773575)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Collective N-to-1 Read Aggregate Throughput"),
357.51)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Collective N-to-1 Write Aggregate Throughput"),
468.32)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Independent N-to-1 File Close Time (Read)"),
36.32)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Independent N-to-1 File Close Time (Write)"),
18.75)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Independent N-to-1 File Open Time (Read)"),
0.807227)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Independent N-to-1 File Open Time (Write)"),
0.819208)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Independent N-to-1 Read Aggregate Throughput"),
492.79)
assert floats_are_close(
parstat_val_f(stats,
"MPIIO Independent N-to-1 Write Aggregate Throughput"),
517.62)
assert floats_are_close(
parstat_val_f(stats, "MPIIO N-to-N File Close Time (Read)"), 11.36)
assert floats_are_close(
parstat_val_f(stats, "MPIIO N-to-N File Close Time (Write)"), 27.27)
assert floats_are_close(
parstat_val_f(stats, "MPIIO N-to-N File Open Time (Read)"), 0.091708)
assert floats_are_close(
parstat_val_f(stats, "MPIIO N-to-N File Open Time (Write)"), 26.62)
assert floats_are_close(
parstat_val_f(stats, "MPIIO N-to-N Read Aggregate Throughput"), 927.21)
assert floats_are_close(
parstat_val_f(stats, "MPIIO N-to-N Write Aggregate Throughput"),
701.60)
assert parstat_val_i(stats, "Number of Tests Passed") == 10
assert parstat_val_i(stats, "Number of Tests Started") == 10
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-1 File Close Time (Read)"), 22.47)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-1 File Close Time (Write)"), 13.50)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-1 File Open Time (Read)"), 0.082365)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-1 File Open Time (Write)"), 0.161028)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-1 Read Aggregate Throughput"), 742.56)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-1 Write Aggregate Throughput"),
613.20)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-N File Close Time (Read)"), 15.76)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-N File Close Time (Write)"), 38.33)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-N File Open Time (Read)"), 15.40)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-N File Open Time (Write)"), 38.60)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-N Read Aggregate Throughput"), 938.84)
assert floats_are_close(
parstat_val_f(stats, "POSIX N-to-N Write Aggregate Throughput"),
488.70)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Collective N-to-1 File Close Time (Read)"),
0.626368)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Collective N-to-1 File Close Time (Write)"),
0.032479)
assert floats_are_close(
parstat_val_f(
stats, "Parallel NetCDF Collective N-to-1 File Open Time (Read)"),
0.874303)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Collective N-to-1 File Open Time (Write)"),
0.826898)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Collective N-to-1 Read Aggregate Throughput"),
803.91)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Collective N-to-1 Write Aggregate Throughput"),
752.14)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Independent N-to-1 File Close Time (Read)"),
5.90)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Independent N-to-1 File Close Time (Write)"),
22.18)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Independent N-to-1 File Open Time (Read)"),
0.910970)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Independent N-to-1 File Open Time (Write)"),
0.793515)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Independent N-to-1 Read Aggregate Throughput"),
861.72)
assert floats_are_close(
parstat_val_f(
stats,
"Parallel NetCDF Independent N-to-1 Write Aggregate Throughput"),
317.39)
assert floats_are_close(parstat_val_f(stats, "Wall Clock Time"), 816.0)
def test_parser(datadir):
from akrr.parsers.enzo_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
results = process_appker_output(
appstdout=str(datadir / 'appstdout'),
stdout=str(datadir / 'stdout'),
stderr=str(datadir / 'stderr'),
geninfo=str(datadir / 'gen.info'),
resource_appker_vars={'resource': {'name': 'HPC-Cluster'}}
)
# check resulting xml
xml_out = ElementTree.fromstring(results)
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
assert xml_out.find('./exitStatus/completed').text == "true"
assert len(params.find(".//parameter[ID='RunEnv:Nodes']").find('value').text) > 5
assert params.find(".//parameter[ID='resource']").find('value').text == "HPC-Cluster"
assert floats_are_close(
float(stats.find(".//statistic[ID='All Data Group Write Time']").find('value').text), 10.915409)
assert floats_are_close(
float(stats.find(".//statistic[ID='All Grid Level 00 Calculation Time']").find('value').text), 42.9321762)
assert floats_are_close(
float(stats.find(".//statistic[ID='All Grid Level 01 Calculation Time']").find('value').text), 87.9636495)
assert floats_are_close(
float(stats.find(".//statistic[ID='All Grid Level 02 Calculation Time']").find('value').text), 34.781478992)
assert floats_are_close(
float(stats.find(".//statistic[ID='Boundary Conditions Setting Time']").find('value').text), 30.76190286)
assert floats_are_close(
float(stats.find(".//statistic[ID='Communication Transpose Time']").find('value').text), 1.244992267)
assert floats_are_close(
float(stats.find(".//statistic[ID='Final Simulation Time']").find('value').text), 26.413138)
assert floats_are_close(
float(stats.find(".//statistic[ID='Gravitational Potential Field Computing Time']").find('value').text),
2.461694230)
assert floats_are_close(
float(stats.find(".//statistic[ID='Grid Hierarchy Rebuilding Time']").find('value').text), 29.1920113)
assert floats_are_close(
float(stats.find(".//statistic[ID='Hydro Equations Solving Time']").find('value').text), 60.4315396)
assert floats_are_close(
float(stats.find(".//statistic[ID='Poisson Equation Solving Time']").find('value').text), 32.91500784812)
assert floats_are_close(
float(stats.find(".//statistic[ID='Radiative Transfer Calculation Time']").find('value').text), 104.8994714547)
assert floats_are_close(
float(stats.find(".//statistic[ID='Total Cycles']").find('value').text), 161)
assert floats_are_close(
float(stats.find(".//statistic[ID='Total Time Spent in Cycles']").find('value').text), 327.22692)
assert floats_are_close(
float(stats.find(".//statistic[ID='Wall Clock Time']").find('value').text), 328.044961)
assert stats.find(".//statistic[ID='App kernel executable exists']").find('value').text == '0'
assert stats.find(".//statistic[ID='App kernel input exists']").find('value').text == '1'
assert stats.find(".//statistic[ID='Network scratch directory accessible']").find('value').text == '1'
assert stats.find(".//statistic[ID='Network scratch directory exists']").find('value').text == '1'
assert stats.find(".//statistic[ID='Task working directory accessible']").find('value').text == '1'
assert stats.find(".//statistic[ID='Task working directory exists']").find('value').text == '1'
assert stats.find(".//statistic[ID='local scratch directory accessible']").find('value').text == '1'
assert stats.find(".//statistic[ID='local scratch directory exists']").find('value').text == '1'
def test_original_hpcg_parser(datadir):
from akrr.parsers.hpcg_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
results = process_appker_output(
appstdout=str(datadir / "original_hpcg" / 'appstdout'),
stdout=str(datadir / "original_hpcg" / 'stdout'),
stderr=str(datadir / "original_hpcg" / 'stderr'),
geninfo=str(datadir / "original_hpcg" / 'gen.info'),
resource_appker_vars={'resource': {'name': 'HPC-Cluster'}}
)
# check resulting xml
xml_out = ElementTree.fromstring(results.replace("'", ""))
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
assert xml_out.find('./exitStatus/completed').text == "true"
assert len(params.find(".//parameter[ID='App:ExeBinSignature']").find('value').text) > 5
assert len(params.find(".//parameter[ID='RunEnv:Nodes']").find('value').text) > 5
assert params.find(".//parameter[ID='resource']").find('value').text == "HPC-Cluster"
assert params.find(".//parameter[ID='App:Version']").find('value').text == "HPCG-Benchmark version 3.0"
assert params.find(".//parameter[ID='RunEnv:CPU Speed']").find('value').text == "2100.0"
assert params.find(".//parameter[ID='Input:Global Problem Dimensions Nx']").find('value').text == "208"
assert params.find(".//parameter[ID='Input:Global Problem Dimensions Ny']").find('value').text == "208"
assert params.find(".//parameter[ID='Input:Global Problem Dimensions Nz']").find('value').text == "104"
assert params.find(".//parameter[ID='Input:Local Domain Dimensions Nx']").find('value').text == "104"
assert params.find(".//parameter[ID='Input:Local Domain Dimensions Ny']").find('value').text == "104"
assert params.find(".//parameter[ID='Input:Local Domain Dimensions Nz']").find('value').text == "104"
assert params.find(".//parameter[ID='Input:Number of Coarse Grid Levels']").find('value').text == "3"
assert params.find(".//parameter[ID='Input:Distributed Processes']").find('value').text == "4"
assert params.find(".//parameter[ID='Input:Threads per processes']").find('value').text == "1"
assert floats_are_close(float(stats.find(
".//statistic[ID='Floating-Point Performance, Raw DDOT']").find('value').text), 0.637654)
assert floats_are_close(float(stats.find(
".//statistic[ID='Floating-Point Performance, Raw MG']").find('value').text), 0.778318)
assert floats_are_close(float(stats.find(
".//statistic[ID='Floating-Point Performance, Raw SpMV']").find('value').text), 0.91135)
assert floats_are_close(float(stats.find(
".//statistic[ID='Floating-Point Performance, Raw Total']").find('value').text), 0.80397)
assert floats_are_close(float(stats.find(
".//statistic[ID='Floating-Point Performance, Raw WAXPBY']").find('value').text), 5.65298)
assert floats_are_close(float(stats.find(
".//statistic[ID='Floating-Point Performance, Total']").find('value').text), 0.773896)
assert floats_are_close(float(stats.find(
".//statistic[ID='Memory Bandwidth, Read']").find('value').text), 4.95353)
assert floats_are_close(float(stats.find(
".//statistic[ID='Memory Bandwidth, Total']").find('value').text), 6.0983)
assert floats_are_close(float(stats.find(
".//statistic[ID='Memory Bandwidth, Write']").find('value').text), 1.14477)
assert floats_are_close(float(stats.find(
".//statistic[ID='Setup Time']").find('value').text), 40.2448)
assert floats_are_close(float(stats.find(
".//statistic[ID='Wall Clock Time']").find('value').text), 385.0)
assert stats.find(".//statistic[ID='App kernel executable exists']").find('value').text == '1'
assert stats.find(".//statistic[ID='App kernel input exists']").find('value').text == '1'
assert stats.find(".//statistic[ID='Network scratch directory accessible']").find('value').text == '1'
assert stats.find(".//statistic[ID='Network scratch directory exists']").find('value').text == '1'
assert stats.find(".//statistic[ID='Task working directory accessible']").find('value').text == '1'
assert stats.find(".//statistic[ID='Task working directory exists']").find('value').text == '1'
assert stats.find(".//statistic[ID='local scratch directory accessible']").find('value').text == '1'
assert stats.find(".//statistic[ID='local scratch directory exists']").find('value').text == '1'
def test_parser(datadir):
from akrr.parsers.gamess_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
results = process_appker_output(
appstdout=str(datadir / 'appstdout'),
stdout=str(datadir / 'stdout'),
stderr=str(datadir / 'stderr'),
geninfo=str(datadir / 'gen.info'),
resource_appker_vars={'resource': {
'name': 'HPC-Cluster'
}})
print(results)
# check resulting xml
xml_out = ElementTree.fromstring(results)
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
assert xml_out.find('./exitStatus/completed').text == "true"
assert len(
params.find(".//parameter[ID='App:ExeBinSignature']").find(
'value').text) > 5
assert len(
params.find(".//parameter[ID='RunEnv:Nodes']").find('value').text) > 5
assert params.find(".//parameter[ID='resource']").find(
'value').text == "HPC-Cluster"
assert params.find(".//parameter[ID='App:NCores']").find(
'value').text == "128"
assert params.find(".//parameter[ID='App:NNodes']").find(
'value').text == "4"
assert params.find(".//parameter[ID='App:Version']").find(
'value').text == "02 AUG 2018 (R2)"
assert floats_are_close(
float(
stats.find(
".//statistic[ID='Time Spent in MP2 Energy Calculation']").
find('value').text), 134.28)
assert floats_are_close(
float(
stats.find(
".//statistic[ID='Time Spent in Restricted Hartree-Fock Calculation']"
).find('value').text), 376.44)
assert floats_are_close(
float(stats.find(".//statistic[ID='User Time']").find('value').text),
539.367)
assert floats_are_close(
float(
stats.find(".//statistic[ID='Wall Clock Time']").find(
'value').text), 978.0)
assert stats.find(".//statistic[ID='App kernel executable exists']").find(
'value').text == '1'
assert stats.find(".//statistic[ID='App kernel input exists']").find(
'value').text == '1'
assert stats.find(".//statistic[ID='Network scratch directory accessible']"
).find('value').text == '1'
assert stats.find(".//statistic[ID='Network scratch directory exists']"
).find('value').text == '1'
assert stats.find(".//statistic[ID='Task working directory accessible']"
).find('value').text == '1'
assert stats.find(".//statistic[ID='Task working directory exists']").find(
'value').text == '1'
assert stats.find(".//statistic[ID='local scratch directory accessible']"
).find('value').text == '1'
assert stats.find(".//statistic[ID='local scratch directory exists']"
).find('value').text == '1'
def test_parser(datadir):
from akrr.parsers.wrf_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
from .xml_comparison import parstat_val, parstat_val_f, parstat_val_i, print_params_or_stats_for_comparisons
results = process_appker_output(
appstdout=str(datadir / 'appstdout'),
stdout=str(datadir / 'stdout'),
stderr=str(datadir / 'stderr'),
geninfo=str(datadir / 'gen.info'),
resource_appker_vars={'resource': {
'name': 'HPC-Cluster'
}})
# check resulting xml
xml_out = ElementTree.fromstring(results.replace("'", ""))
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
assert xml_out.find('./exitStatus/completed').text == "true"
# Compare parameters to reference
assert len(parstat_val(params, "App:ExeBinSignature")) > 5
assert len(parstat_val(params, "RunEnv:Nodes")) > 5
assert parstat_val(params, "resource") == "HPC-Cluster"
assert floats_are_close(parstat_val_f(params, "App:Version"), 3.3)
assert parstat_val(params, "Input:Grid Resolution") == "12 x 12"
assert floats_are_close(parstat_val_f(params, "Input:Simulation Length"),
3.0)
assert parstat_val(params,
"Input:Simulation Start Date") == "2001-10-24_00:00:00"
assert floats_are_close(parstat_val_f(params, "Input:Timestep"), 72.0)
assert parstat_val(params,
"WRF Dynamical Solver") == "Advanced Research WRF (ARW)"
# Compare stats to reference
assert parstat_val_i(stats, "App kernel executable exists") == 1
assert parstat_val_i(stats, "App kernel input exists") == 1
assert parstat_val_i(stats, "Task working directory accessible") == 1
assert parstat_val_i(stats, "Task working directory exists") == 1
assert parstat_val_i(stats, "local scratch directory accessible") == 1
assert parstat_val_i(stats, "local scratch directory exists") == 1
assert parstat_val_i(stats, "Network scratch directory accessible") == 1
assert parstat_val_i(stats, "Network scratch directory exists") == 1
assert floats_are_close(
parstat_val_f(stats, "Average Floating-Point Performance"),
45428.61484535666)
assert floats_are_close(parstat_val_f(stats, "Average Simulation Speed"),
108.68089675922646)
assert floats_are_close(
parstat_val_f(stats, "Mean Time To Simulate One Timestep"),
0.6624899328859059)
assert floats_are_close(parstat_val_f(stats, "Output Data Size"),
625.2359209060669)
assert floats_are_close(
parstat_val_f(stats, "Peak Floating-Point Performance"),
50479.70479704797)
assert floats_are_close(parstat_val_f(stats, "Peak Simulation Speed"),
120.7648440120765)
assert floats_are_close(parstat_val_f(stats, "Time Spent on I/O"), 40.9111)
assert floats_are_close(parstat_val_f(stats, "Wall Clock Time"), 144.0)
def test_parser(datadir):
from akrr.parsers.nwchem_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
results = process_appker_output(
appstdout=str(datadir / 'appstdout'),
stdout=str(datadir / 'stdout'),
stderr=str(datadir / 'stderr'),
geninfo=str(datadir / 'gen.info'),
resource_appker_vars={'resource': {
'name': 'HPC-Cluster'
}})
# check resulting xml
xml_out = ElementTree.fromstring(results.replace("'", ""))
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
assert xml_out.find('./exitStatus/completed').text == "true"
assert len(
params.find(".//parameter[ID='App:ExeBinSignature']").find(
'value').text) > 5
assert len(
params.find(".//parameter[ID='RunEnv:Nodes']").find('value').text) > 5
assert params.find(".//parameter[ID='resource']").find(
'value').text == "HPC-Cluster"
assert params.find(".//parameter[ID='App:Version']").find(
'value').text == "6.8"
assert params.find(".//parameter[ID='Input:File']").find(
'value').text == "aump2.nw"
assert floats_are_close(
float(
stats.find(".//statistic[ID='Global Arrays Accumulate Amount']").
find('value').text), 421.5240478515625)
assert floats_are_close(
float(
stats.find(".//statistic[ID='Global Arrays Accumulate Calls']").
find('value').text), 176000)
assert floats_are_close(
float(
stats.find(".//statistic[ID='Global Arrays Create Calls']").find(
'value').text), 580)
assert floats_are_close(
float(
stats.find(".//statistic[ID='Global Arrays Destroy Calls']").find(
'value').text), 580)
assert floats_are_close(
float(
stats.find(".//statistic[ID='Global Arrays Get Amount']").find(
'value').text), 963.2110595703125)
assert floats_are_close(
float(
stats.find(".//statistic[ID='Global Arrays Get Calls']").find(
'value').text), 24900)
assert floats_are_close(
float(
stats.find(".//statistic[ID='Global Arrays Put Amount']").find(
'value').text), 152.587890625)
assert floats_are_close(
float(
stats.find(".//statistic[ID='Global Arrays Put Calls']").find(
'value').text), 17800)
assert floats_are_close(
float(stats.find(".//statistic[ID='User Time']").find('value').text),
9.4)
assert floats_are_close(
float(
stats.find(".//statistic[ID='Wall Clock Time']").find(
'value').text), 20.1)
assert stats.find(".//statistic[ID='App kernel executable exists']").find(
'value').text == '1'
assert stats.find(".//statistic[ID='App kernel input exists']").find(
'value').text == '1'
assert stats.find(".//statistic[ID='Network scratch directory accessible']"
).find('value').text == '1'
assert stats.find(".//statistic[ID='Network scratch directory exists']"
).find('value').text == '1'
assert stats.find(".//statistic[ID='Task working directory accessible']"
).find('value').text == '1'
assert stats.find(".//statistic[ID='Task working directory exists']").find(
'value').text == '1'
assert stats.find(".//statistic[ID='local scratch directory accessible']"
).find('value').text == '1'
assert stats.find(".//statistic[ID='local scratch directory exists']"
).find('value').text == '1'
def test_parser(datadir):
from akrr.parsers.hpcc_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
results = process_appker_output(
appstdout=str(datadir / 'appstdout'),
stdout=str(datadir / 'stdout'),
stderr=str(datadir / 'stderr'),
geninfo=str(datadir / 'gen.info'),
resource_appker_vars={'resource': {'name': 'HPC-Cluster','nnodes': 4, 'ppn': 32},
'app': {"appkernel_on_resource": {'HPC-Cluster':
{'theoretical_gflops_per_core': 2100.0*2*2}}}}
)
# check resulting xml
xml_out = ElementTree.fromstring(results.replace("'", ""))
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
assert xml_out.find('./exitStatus/completed').text == "true"
assert len(params.find(".//parameter[ID='App:ExeBinSignature']").find('value').text) > 5
assert len(params.find(".//parameter[ID='RunEnv:Nodes']").find('value').text) > 5
assert params.find(".//parameter[ID='resource']").find('value').text == "HPC-Cluster"
assert params.find(".//parameter[ID='App:Version']").find('value').text == "1.4.2f"
assert params.find(".//parameter[ID='Input:DGEMM Problem Size']").find('value').text == "2040"
assert params.find(".//parameter[ID='Input:High Performance LINPACK Grid Cols']").find('value').text == "16"
assert params.find(".//parameter[ID='Input:High Performance LINPACK Grid Rows']").find('value').text == "8"
assert params.find(".//parameter[ID='Input:High Performance LINPACK Problem Size']").find('value').text == "40000"
assert params.find(".//parameter[ID='Input:MPI Ranks']").find('value').text == "128"
assert params.find(".//parameter[ID='Input:MPIRandom Problem Size']").find('value').text == "1024.0"
assert params.find(".//parameter[ID='Input:OpenMP Threads']").find('value').text == "0"
assert params.find(".//parameter[ID='Input:PTRANS Problem Size']").find('value').text == "20000"
assert params.find(".//parameter[ID='Input:STREAM Array Size']").find('value').text == "4166666"
assert params.find(".//parameter[ID='RunEnv:CPU Speed']").find('value').text == "2100.0"
assert floats_are_close(float(stats.find(
".//statistic[ID='Average Double-Precision General Matrix Multiplication (DGEMM) Floating-Point Performance']"
).find('value').text), 47635.3)
assert floats_are_close(
float(stats.find(".//statistic[ID='Average STREAM Add Memory Bandwidth']").find('value').text), 4785.75616)
assert floats_are_close(
float(stats.find(".//statistic[ID='Average STREAM Copy Memory Bandwidth']").find('value').text), 5505.35168)
assert floats_are_close(
float(stats.find(".//statistic[ID='Average STREAM Scale Memory Bandwidth']").find('value').text), 4325.90848)
assert floats_are_close(
float(stats.find(".//statistic[ID='Average STREAM Triad Memory Bandwidth']").find('value').text), 4888.7808)
assert floats_are_close(
float(stats.find(
".//statistic[ID='Fast Fourier Transform (FFTW) Floating-Point Performance']").find('value').text), 67847.4)
assert floats_are_close(
float(stats.find(".//statistic[ID='High Performance LINPACK Efficiency']").find('value').text), 0.329)
assert floats_are_close(
float(stats.find(".//statistic[ID='High Performance LINPACK Floating-Point Performance']").find('value').text),
3532370.0)
assert floats_are_close(
float(stats.find(".//statistic[ID='High Performance LINPACK Run Time']").find('value').text), 12.0794)
assert floats_are_close(
float(stats.find(".//statistic[ID='MPI Random Access']").find('value').text), 62.2572)
assert floats_are_close(
float(stats.find(".//statistic[ID='Parallel Matrix Transpose (PTRANS)']").find('value').text), 35308.1344)
assert floats_are_close(
float(stats.find(".//statistic[ID='Wall Clock Time']").find('value').text), 187.0)
assert stats.find(".//statistic[ID='App kernel executable exists']").find('value').text == '1'
assert stats.find(".//statistic[ID='App kernel input exists']").find('value').text == '1'
assert stats.find(".//statistic[ID='Network scratch directory accessible']").find('value').text == '1'
assert stats.find(".//statistic[ID='Network scratch directory exists']").find('value').text == '1'
assert stats.find(".//statistic[ID='Task working directory accessible']").find('value').text == '1'
assert stats.find(".//statistic[ID='Task working directory exists']").find('value').text == '1'
assert stats.find(".//statistic[ID='local scratch directory accessible']").find('value').text == '1'
assert stats.find(".//statistic[ID='local scratch directory exists']").find('value').text == '1'
def test_parser(datadir):
from akrr.parsers.mpi_tile_io_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
from .xml_comparison import parstat_val, parstat_val_f, parstat_val_i
results = process_appker_output(
appstdout=str(datadir / 'appstdout'),
stdout=str(datadir / 'stdout'),
stderr=str(datadir / 'stderr'),
geninfo=str(datadir / 'gen.info'),
resource_appker_vars={'resource': {
'name': 'HPC-Cluster'
}})
# check resulting xml
xml_out = ElementTree.fromstring(results.replace("'", ""))
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
assert xml_out.find('./exitStatus/completed').text == "true"
# Compare parameters to reference
assert len(parstat_val(params, "App:ExeBinSignature")) > 5
assert len(parstat_val(params, "RunEnv:Nodes")) > 5
assert parstat_val(params, "resource") == "HPC-Cluster"
assert parstat_val(params, "2D Collective Read Test File System"
) == "panfs (panfs://panfs.ccr.buffalo.edu:global)"
assert parstat_val(params, "2D Collective Write Test File System"
) == "panfs (panfs://panfs.ccr.buffalo.edu:global)"
assert parstat_val(params, "2D HDF5 Collective Read Test File System"
) == "panfs (panfs://panfs.ccr.buffalo.edu:global)"
assert parstat_val(params, "2D HDF5 Collective Write Test File System"
) == "panfs (panfs://panfs.ccr.buffalo.edu:global)"
assert parstat_val(params, "2D Independent Read Test File System"
) == "panfs (panfs://panfs.ccr.buffalo.edu:global)"
assert parstat_val(params, "2D Independent Write Test File System"
) == "panfs (panfs://panfs.ccr.buffalo.edu:global)"
assert parstat_val(params, "2D Per-Process Data Topology") == "5120x5120"
assert parstat_val(params, "2D Per-Process Ghost Zone") == "0x0"
assert floats_are_close(parstat_val_f(params, "2D Per-Process Memory"),
200.0)
assert parstat_val(params, "2D Process Topology") == "8x8"
assert parstat_val(params, "3D Collective Read Test File System"
) == "panfs (panfs://panfs.ccr.buffalo.edu:global)"
assert parstat_val(params, "3D Collective Write Test File System"
) == "panfs (panfs://panfs.ccr.buffalo.edu:global)"
assert parstat_val(params, "3D HDF5 Collective Read Test File System"
) == "panfs (panfs://panfs.ccr.buffalo.edu:global)"
assert parstat_val(params, "3D HDF5 Collective Write Test File System"
) == "panfs (panfs://panfs.ccr.buffalo.edu:global)"
assert parstat_val(params, "3D Independent Read Test File System"
) == "panfs (panfs://panfs.ccr.buffalo.edu:global)"
assert parstat_val(params, "3D Independent Write Test File System"
) == "panfs (panfs://panfs.ccr.buffalo.edu:global)"
assert parstat_val(params, "3D Per-Process Data Topology") == "256x320x320"
assert parstat_val(params, "3D Per-Process Ghost Zone") == "0x0x0"
assert floats_are_close(parstat_val_f(params, "3D Per-Process Memory"),
200.0)
assert parstat_val(params, "3D Process Topology") == "4x4x4"
assert parstat_val(params, "HDF Version") == "1.8.11 (Parallel)"
assert parstat_val(params, "MPI-IO Hints") == "panfs_concurrent_write=1;"
# Compare stats to reference
assert parstat_val_i(stats, "App kernel executable exists") == 1
assert parstat_val_i(stats, "App kernel input exists") == 1
assert parstat_val_i(stats, "Task working directory accessible") == 1
assert parstat_val_i(stats, "Task working directory exists") == 1
assert parstat_val_i(stats, "local scratch directory accessible") == 1
assert parstat_val_i(stats, "local scratch directory exists") == 1
assert parstat_val_i(stats, "Network scratch directory accessible") == 1
assert parstat_val_i(stats, "Network scratch directory exists") == 1
assert floats_are_close(
parstat_val_f(stats, "2D Array Collective Read Aggregate Throughput"),
620.45)
assert floats_are_close(
parstat_val_f(stats, "2D Array Collective Write Aggregate Throughput"),
287.00)
assert floats_are_close(
parstat_val_f(stats,
"2D Array HDF5 Collective Read Aggregate Throughput"),
653.72)
assert floats_are_close(
parstat_val_f(stats,
"2D Array HDF5 Collective Write Aggregate Throughput"),
330.36)
assert floats_are_close(
parstat_val_f(stats, "2D Array Independent Read Aggregate Throughput"),
541.87)
assert floats_are_close(
parstat_val_f(stats,
"2D Array Independent Write Aggregate Throughput"),
21.46)
assert floats_are_close(
parstat_val_f(stats, "3D Array Collective Read Aggregate Throughput"),
652.08)
assert floats_are_close(
parstat_val_f(stats, "3D Array Collective Write Aggregate Throughput"),
336.02)
assert floats_are_close(
parstat_val_f(stats,
"3D Array HDF5 Collective Read Aggregate Throughput"),
636.77)
assert floats_are_close(
parstat_val_f(stats,
"3D Array HDF5 Collective Write Aggregate Throughput"),
317.90)
assert floats_are_close(
parstat_val_f(stats, "3D Array Independent Read Aggregate Throughput"),
331.93)
assert floats_are_close(
parstat_val_f(stats,
"3D Array Independent Write Aggregate Throughput"),
27.17)
assert floats_are_close(
parstat_val_f(stats, "File Close Time (2D Data Collective Read)"),
0.000261)
assert floats_are_close(
parstat_val_f(stats, "File Close Time (2D Data Collective Write)"),
0.181099)
assert floats_are_close(
parstat_val_f(stats, "File Close Time (2D Data HDF5 Collective Read)"),
0.000697)
assert floats_are_close(
parstat_val_f(stats,
"File Close Time (2D Data HDF5 Collective Write)"),
0.772100)
assert floats_are_close(
parstat_val_f(stats, "File Close Time (2D Data Independent Read)"),
0.000081)
assert floats_are_close(
parstat_val_f(stats, "File Close Time (2D Data Independent Write)"),
0.032696)
assert floats_are_close(
parstat_val_f(stats, "File Close Time (3D Data Collective Read)"),
0.000405)
assert floats_are_close(
parstat_val_f(stats, "File Close Time (3D Data Collective Write)"),
0.191116)
assert floats_are_close(
parstat_val_f(stats, "File Close Time (3D Data HDF5 Collective Read)"),
0.000653)
assert floats_are_close(
parstat_val_f(stats,
"File Close Time (3D Data HDF5 Collective Write)"),
0.841222)
assert floats_are_close(
parstat_val_f(stats, "File Close Time (3D Data Independent Read)"),
0.000288)
assert floats_are_close(
parstat_val_f(stats, "File Close Time (3D Data Independent Write)"),
0.032183)
assert floats_are_close(
parstat_val_f(stats, "File Open Time (2D Data Collective Read)"),
0.086550)
assert floats_are_close(
parstat_val_f(stats, "File Open Time (2D Data Collective Write)"),
0.049139)
assert floats_are_close(
parstat_val_f(stats, "File Open Time (2D Data HDF5 Collective Read)"),
0.078241)
assert floats_are_close(
parstat_val_f(stats, "File Open Time (2D Data HDF5 Collective Write)"),
0.037127)
assert floats_are_close(
parstat_val_f(stats, "File Open Time (2D Data Independent Read)"),
0.030526)
assert floats_are_close(
parstat_val_f(stats, "File Open Time (2D Data Independent Write)"),
0.041617)
assert floats_are_close(
parstat_val_f(stats, "File Open Time (3D Data Collective Read)"),
0.071459)
assert floats_are_close(
parstat_val_f(stats, "File Open Time (3D Data Collective Write)"),
0.037431)
assert floats_are_close(
parstat_val_f(stats, "File Open Time (3D Data HDF5 Collective Read)"),
0.061011)
assert floats_are_close(
parstat_val_f(stats, "File Open Time (3D Data HDF5 Collective Write)"),
0.049155)
assert floats_are_close(
parstat_val_f(stats, "File Open Time (3D Data Independent Read)"),
0.054999)
assert floats_are_close(
parstat_val_f(stats, "File Open Time (3D Data Independent Write)"),
0.034026)
assert floats_are_close(parstat_val_f(stats, "Wall Clock Time"), 864.0)
def test_parser(datadir):
from akrr.parsers.graph500_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
subdir = '1node'
results = process_appker_output(
appstdout=str(datadir / subdir / 'appstdout'),
stdout=str(datadir / subdir / 'stdout'),
stderr=str(datadir / subdir / 'stderr'),
geninfo=str(datadir / subdir / 'gen.info'),
resource_appker_vars={'resource': {
'name': 'HPC-Cluster'
}})
# check resulting xml
xml_out = ElementTree.fromstring(results)
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
print(results)
assert xml_out.find('./exitStatus/completed').text == "true"
assert len(
params.find(".//parameter[ID='App:ExeBinSignature']").find(
'value').text) > 5
assert len(
params.find(".//parameter[ID='RunEnv:Nodes']").find('value').text) > 5
assert params.find(".//parameter[ID='resource']").find(
'value').text == "HPC-Cluster"
assert params.find(".//parameter[ID='App:Version']").find(
'value').text == "2.1.4 replicated csc"
assert params.find(".//parameter[ID='Edge Factor']").find(
'value').text == "16"
assert params.find(".//parameter[ID='Number of Edges']").find(
'value').text == "134217728"
assert params.find(".//parameter[ID='Number of Roots to Check']").find(
'value').text == "64"
assert params.find(".//parameter[ID='Number of Vertices']").find(
'value').text == "8388608"
assert params.find(".//parameter[ID='Scale']").find('value').text == "23"
assert floats_are_close(
float(
stats.find(".//statistic[ID='Harmonic Mean TEPS']").find(
'value').text), 6.60498e+09)
assert floats_are_close(
float(
stats.find(".//statistic[ID='Harmonic Standard Deviation TEPS']").
find('value').text), 1.88566e+08)
assert floats_are_close(
float(stats.find(".//statistic[ID='Median TEPS']").find('value').text),
7.22041e+09)
assert floats_are_close(
float(
stats.find(".//statistic[ID='Wall Clock Time']").find(
'value').text), 336.0)
assert stats.find(".//statistic[ID='App kernel executable exists']").find(
'value').text == '1'
assert stats.find(".//statistic[ID='App kernel input exists']").find(
'value').text == '1'
assert stats.find(".//statistic[ID='Network scratch directory accessible']"
).find('value').text == '1'
assert stats.find(".//statistic[ID='Network scratch directory exists']"
).find('value').text == '1'
assert stats.find(".//statistic[ID='Task working directory accessible']"
).find('value').text == '1'
assert stats.find(".//statistic[ID='Task working directory exists']").find(
'value').text == '1'
assert stats.find(".//statistic[ID='local scratch directory accessible']"
).find('value').text == '1'
assert stats.find(".//statistic[ID='local scratch directory exists']"
).find('value').text == '1'
def test_parser(datadir):
from akrr.parsers.mdtest_parser import process_appker_output
import xml.etree.ElementTree as ElementTree
from akrr.util import floats_are_close
from .xml_comparison import parstat_val, parstat_val_f, parstat_val_i
results = process_appker_output(
appstdout=str(datadir / 'v1' / 'appstdout'),
stdout=str(datadir / 'v1' / 'stdout'),
stderr=str(datadir / 'v1' / 'stderr'),
geninfo=str(datadir / 'v1' / 'gen.info'),
resource_appker_vars={'resource': {
'name': 'HPC-Cluster'
}})
# check resulting xml
xml_out = ElementTree.fromstring(results)
params = xml_out.find(".//parameters")
stats = xml_out.find(".//statistics")
assert xml_out.find('./exitStatus/completed').text == "true"
# Compare parameters to reference
assert len(parstat_val(params, "App:ExeBinSignature")) > 5
assert len(parstat_val(params, "RunEnv:Nodes")) > 5
assert parstat_val(params, "Arguments (single directory per process)"
) == "-v -I 32 -z 0 -b 0 -i 2 -u"
assert parstat_val(
params, "Arguments (single directory)") == "-v -I 32 -z 0 -b 0 -i 2"
assert parstat_val(params, "Arguments (single tree directory per process)"
) == "-v -I 4 -z 4 -b 2 -i 2 -u"
assert parstat_val(
params,
"Arguments (single tree directory)") == "-v -I 4 -z 4 -b 2 -i 2"
assert parstat_val_i(
params, "files/directories (single directory per process)") == 3072
assert parstat_val_i(params,
"files/directories (single directory)") == 3072
assert parstat_val_i(
params,
"files/directories (single tree directory per process)") == 11904
assert parstat_val_i(params,
"files/directories (single tree directory)") == 11904
assert parstat_val(params, "resource") == "HPC-Cluster"
assert parstat_val_i(params, "tasks (single directory per process)") == 96
assert parstat_val_i(params, "tasks (single directory)") == 96
assert parstat_val_i(params,
"tasks (single tree directory per process)") == 96
assert parstat_val_i(params, "tasks (single tree directory)") == 96
# Compare stats to reference
assert parstat_val_i(stats, "App kernel executable exists") == 1
assert parstat_val_i(stats, "App kernel input exists") == 1
assert parstat_val_i(stats, "Network scratch directory accessible") == 1
assert parstat_val_i(stats, "Network scratch directory exists") == 1
assert parstat_val_i(stats, "Task working directory accessible") == 1
assert parstat_val_i(stats, "Task working directory exists") == 1
assert parstat_val_i(stats, "local scratch directory accessible") == 1
assert parstat_val_i(stats, "local scratch directory exists") == 1
assert floats_are_close(
parstat_val_f(stats,
"Directory creation (single directory per process)"),
25485.108)
assert floats_are_close(
parstat_val_f(stats, "Directory creation (single directory)"), 100.331)
assert floats_are_close(
parstat_val_f(
stats, "Directory creation (single tree directory per process)"),
14795.304)
assert floats_are_close(
parstat_val_f(stats, "Directory creation (single tree directory)"),
1159.207)
assert floats_are_close(
parstat_val_f(stats,
"Directory removal (single directory per process)"),
106924.358)
assert floats_are_close(
parstat_val_f(stats, "Directory removal (single directory)"), 83.151)
assert floats_are_close(
parstat_val_f(stats,
"Directory removal (single tree directory per process)"),
98807.620)
assert floats_are_close(
parstat_val_f(stats, "Directory removal (single tree directory)"),
1013.108)
assert floats_are_close(
parstat_val_f(stats, "Directory stat (single directory per process)"),
1474174.388)
assert floats_are_close(
parstat_val_f(stats, "Directory stat (single directory)"), 157316.373)
assert floats_are_close(
parstat_val_f(stats,
"Directory stat (single tree directory per process)"),
1081034.251)
assert floats_are_close(
parstat_val_f(stats, "Directory stat (single tree directory)"),
123501.252)
assert floats_are_close(
parstat_val_f(stats, "File creation (single directory per process)"),
35892.066)
assert floats_are_close(
parstat_val_f(stats, "File creation (single directory)"), 113.827)
assert floats_are_close(
parstat_val_f(stats,
"File creation (single tree directory per process)"),
26951.173)
assert floats_are_close(
parstat_val_f(stats, "File creation (single tree directory)"),
1807.941)
assert floats_are_close(
parstat_val_f(stats, "File read (single directory per process)"),
294344.471)
assert floats_are_close(
parstat_val_f(stats, "File read (single directory)"), 277066.971)
assert floats_are_close(
parstat_val_f(stats, "File read (single tree directory per process)"),
286266.660)
assert floats_are_close(
parstat_val_f(stats, "File read (single tree directory)"), 289428.427)
assert floats_are_close(
parstat_val_f(stats, "File removal (single directory per process)"),
147540.803)
assert floats_are_close(
parstat_val_f(stats, "File removal (single directory)"), 123.151)
assert floats_are_close(
parstat_val_f(stats,
"File removal (single tree directory per process)"),
100810.329)
assert floats_are_close(
parstat_val_f(stats, "File removal (single tree directory)"), 2973.052)
assert floats_are_close(
parstat_val_f(stats, "File stat (single directory per process)"),
1548423.892)
assert floats_are_close(
parstat_val_f(stats, "File stat (single directory)"), 1483281.640)
assert floats_are_close(
parstat_val_f(stats, "File stat (single tree directory per process)"),
1161124.965)
assert floats_are_close(
parstat_val_f(stats, "File stat (single tree directory)"), 114689.532)
assert floats_are_close(
parstat_val_f(stats, "Tree creation (single directory per process)"),
2.446)
assert floats_are_close(
parstat_val_f(stats, "Tree creation (single directory)"), 3734.746)
assert floats_are_close(
parstat_val_f(stats,
"Tree creation (single tree directory per process)"),
48.073)
assert floats_are_close(
parstat_val_f(stats, "Tree creation (single tree directory)"),
4143.686)
assert floats_are_close(
parstat_val_f(stats, "Tree removal (single directory per process)"),
2.046)
assert floats_are_close(
parstat_val_f(stats, "Tree removal (single directory)"), 132.413)
assert floats_are_close(
parstat_val_f(stats,
"Tree removal (single tree directory per process)"),
58.162)
assert floats_are_close(
parstat_val_f(stats, "Tree removal (single tree directory)"), 188.171)
assert floats_are_close(parstat_val_f(stats, "Wall Clock Time"), 320.0)