diff --git a/configuration/archer2.py b/configuration/archer2.py index 783c205..1536368 100644 --- a/configuration/archer2.py +++ b/configuration/archer2.py @@ -25,7 +25,7 @@ def command(self, job): "descr": "Login nodes", "scheduler": "local", "launcher": "local", - "environs": ["Default", "PrgEnv-gnu", "PrgEnv-cray", "PrgEnv-aocc"], + "environs": ["Default", "PrgEnv-gnu", "PrgEnv-cray", "PrgEnv-aocc", "PrgEnv-gnu-hf", "PrgEnv-cray-hf", "PrgEnv-aocc-hf"], }, { "name": "compute", @@ -38,7 +38,7 @@ def command(self, job): "--partition=standard", "--qos=standard", ], - "environs": ["PrgEnv-gnu", "PrgEnv-cray", "PrgEnv-aocc"], + "environs": ["PrgEnv-gnu", "PrgEnv-cray", "PrgEnv-aocc", "PrgEnv-gnu-hf", "PrgEnv-cray-hf", "PrgEnv-aocc-hf"], "max_jobs": 64, "processor": { "num_cpus": 128, @@ -100,6 +100,15 @@ def command(self, job): "ftn": "ftn", "target_systems": ["archer2"], }, + { + "name": "PrgEnv-gnu-hf", + "modules": ["PrgEnv-gnu"], + "cc": "cc", + "cxx": "CC", + "ftn": "ftn", + "env_vars": [["SLURM_CPU_FREQ_REQ", 2250000]], + "target_systems": ["archer2"], + }, { "name": "PrgEnv-cray", "modules": ["PrgEnv-cray"], @@ -108,6 +117,15 @@ def command(self, job): "ftn": "ftn", "target_systems": ["archer2"], }, + { + "name": "PrgEnv-cray-hf", + "modules": ["PrgEnv-cray"], + "cc": "cc", + "cxx": "CC", + "ftn": "ftn", + "env_vars": [["SLURM_CPU_FREQ_REQ", 2250000]], + "target_systems": ["archer2"], + }, { "name": "PrgEnv-aocc", "modules": ["PrgEnv-aocc"], @@ -116,6 +134,15 @@ def command(self, job): "ftn": "ftn", "target_systems": ["archer2"], }, + { + "name": "PrgEnv-aocc-hf", + "modules": ["PrgEnv-aocc"], + "cc": "cc", + "cxx": "CC", + "ftn": "ftn", + "env_vars": [["SLURM_CPU_FREQ_REQ", 2250000]], + "target_systems": ["archer2"], + }, { "name": "rocm-PrgEnv-gnu", "modules": [ diff --git a/tests/apps/apps_base.py b/tests/apps/apps_base.py new file mode 100644 index 0000000..109152c --- /dev/null +++ b/tests/apps/apps_base.py @@ -0,0 +1,133 @@ +"""ReFrame base module for applications tests""" + +import reframe as rfm +import reframe.utility.sanity as sn +import abc + + + +@rfm.simple_test +class AppsFetchBase(rfm.RunonlyRegressionTest): + """Reframe base class for accessing application code""" + descr = 'Fetch app code' + version = variable(str, value='7.3') + executable = 'wget' + executable_opts = [ + f'app-{version}' + ] + local = True + valid_systems = [''] + valid_prog_environs = [''] + + @sanity_function + def validate_download(self): + return sn.assert_eq(self.job.exitcode, 0) + + +@rfm.simple_test +class AppsCompileBase(rfm.CompileOnlyRegressionTest, metaclass=abc.ABCMeta): + """Reframe base class for application compilation tests""" + descr = 'Build app' + build_system = '' + valid_systems = [''] + valid_prog_environs = [''] + + @abc.abstractmethod + @run_after('init') + def add_dependencies(self): + self.depends_on('', udeps.fully) + + @sanity_function + def validate_compilation_no_errors(self): + """Sanity check that software compiled correctly""" + return sn.assert_eq(self.job.exitcode, 0) + + @abc.abstractmethod + @sanity_function + def validate_compilation_executable_produced(self): + """Sanity check that software compiled correctly""" + pass + + +@rfm.simple_test +class AppsRunBase(rfm.RunOnlyRegressionTest, metaclass=abc.ABCMeta): + """ReFrame base class for applications execution tests""" + + # Test classifications + tags = {""} # { "applications", "performance", "largescale", "hugescale"} + + # Test environments + valid_prog_environs = [""] + + #Test executables + executable = "" + + # + extra_resources = {""} # {"qos": {"qos": "standard"}} + strict_check = True + + # Depency + appbinary = fixture(AppsCompileBase, scope="environment") + + # Outputs + keep_files = [""] + + # Info + maintainers =[""] + + + # Sanity checks + + @sanity_function + def validate_run_finished_no_error(self) -> bool: + """Sanity check that simulation finished successfully""" + return sn.assert_eq(self.job.exitcode, 0) + + @abc.abstractmethod + @sanity_function + def validate_run_finished(self) -> bool: + """Sanity check that simulation finished successfully""" + pass + + @abc.abstractmethod + @sanity_function + def assert_correctness(self) -> bool: + """Sanity check that simulation finished correctly""" + pass + + # Application performance check + + @abc.abstractmethod + @performance_function("app", perf_key="performance") + def extract_performance(self): + """Extract performance value to compare with reference value""" + #return sn.extractsingle("","") + pass + + + # Job performance tests + + @performance_function("J", perf_key="job_energy") + def extract_job_energy(self): + """Extract value of energy used in job from slurm""" + jobid = self.job.jobid + + slurm = rfm.utility.osext.run_command( + "sacct -j " + str(jobid) + " --format=JobID,ConsumedEnergy --noconvert | tr '\n' ' ' ", + check=True, + shell=True, + ) + + energy_slurm = sn.extractall_s( + r"JobID\s+ConsumedEnergy\s+------------ --------------\s+[0-9]+\s+[0-9]+\s+[0-9]+.bat\+\s+[0-9]+\s+[0-9]+.ext\+\s+[0-9]+\s+[0-9]+.0\s+(?P[0-9]+)", + str(slurm.stdout), + "energy", + ) + return int(str(energy_slurm[0])) + + @performance_function("sec", perf_key="job_time") + def extract_job_time(self): + """Extract value of the duration of the job from slurm""" + return self.completion_time + + diff --git a/tests/apps/cp2k/cp2k_check.py b/tests/apps/cp2k/cp2k_check.py index 9c5568d..4a8cafd 100644 --- a/tests/apps/cp2k/cp2k_check.py +++ b/tests/apps/cp2k/cp2k_check.py @@ -18,6 +18,10 @@ class CP2KBaseCheck(rfm.RunOnlyRegressionTest): # Output files to be retained keep_files = ["cp2k.out"] + # Set time limit + + time_limit = "20m" + maintainers = ["j.richings@epcc.ed.ac.uk"] use_multithreading = False tags = {"applications", "performance"} @@ -68,13 +72,13 @@ class CP2KARCHER2(CP2KBaseCheck): # Select system to use valid_systems = ["archer2:compute"] # Set Programming Environment - valid_prog_environs = ["PrgEnv-gnu"] + valid_prog_environs = ["PrgEnv-gnu", "PrgEnv-gnu-hf"] # Description of test descr = "CP2K " # Command line options for executable executable_opts = ("-i input_bulk_HFX_3.inp -o cp2k.out ").split() # different cpu frequencies - freq = parameter(["2250000", "2000000"]) + freq = ["2250000", "2000000"] # slurm parameters num_tasks = 384 num_tasks_per_node = 16 @@ -89,20 +93,20 @@ class CP2KARCHER2(CP2KBaseCheck): @run_after("init") def setup_params(self): """sets up extra parameters""" - self.descr += self.freq + #self.descr += self.freq if self.current_system.name in ["archer2"]: self.env_vars = { "OMP_NUM_THREADS": str(self.num_cpus_per_task), - "OMP_PLACES": "cores", - "SLURM_CPU_FREQ_REQ": self.freq, - } + "OMP_PLACES": "cores"} +# "SLURM_CPU_FREQ_REQ": self.freq, +# } @run_before("performance") def set_reference(self): """Changes reference values""" if self.current_system.name in ["archer2"]: # https://reframe-hpc.readthedocs.io/en/stable/utility_functions_reference.html#reframe.utility.ScopedDict - self.reference["archer2:compute:performance"] = self.reference_performance[self.freq] + self.reference["archer2:compute:performance"] = self.reference_performance["2250000" if self.current_environ.name[-3:] =='-hf' else "2000000"] @rfm.simple_test diff --git a/tests/apps/xcompact3d/xcompact3d_app.py b/tests/apps/xcompact3d/xcompact3d_app.py new file mode 100644 index 0000000..8c89d24 --- /dev/null +++ b/tests/apps/xcompact3d/xcompact3d_app.py @@ -0,0 +1,84 @@ +#!/usr/bin/env python3 + +"""Reframe test for XCompact3D""" + +# Based on original work from: +# Copyright 2016-2022 Swiss National Supercomputing Centre (CSCS/ETH Zurich) +# ReFrame Project Developers. See the top-level LICENSE file for details. +# SPDX-License-Identifier: BSD-3-Clause + +import reframe as rfm +import reframe.utility.sanity as sn + + + +class XCompact3dFetchStable(AppsFetchBase): + """Test to fetch xcompact3d from github""" + executable = 'git clone' + executable_opts = [ + f'https://github.com/xcompact3d/Incompact3d.git' + ] + + local = True + + valid_systems = ['*'] + valid_prog_environs = [''] + + +class Xcompact3dBuildStable(AppsCompileBase): + """Reframe base class for application compilation tests""" + descr = 'Build app' + build_system = '' + valid_systems = [''] + valid_prog_environs = [''] + + + + + + + + +@rfm.simple_test +class XCompact3DTest(rfm.RegressionTest): + """XCompact 3D Test""" + + valid_systems = ["archer2:compute"] + valid_prog_environs = ["PrgEnv-gnu"] + + tags = {"performance", "applications"} + + num_nodes = 64 + num_tasks_per_node = 128 + num_cpus_per_task = 1 + num_tasks = num_nodes * num_tasks_per_node * num_cpus_per_task + + env_vars = {"OMP_NUM_THREADS": str(num_cpus_per_task)} + + time_limit = "1h" + build_system = "CMake" + prebuild_cmds = [ + "git clone https://github.com/xcompact3d/Incompact3d.git", + "cd Incompact3d", + ] + builddir = "Incompact3d" + executable = "Incompact3d/bin/xcompact3d" + executable_opts = ["input-64.i3d"] + modules = ["cmake/3.29.4"] + + reference = {"archer2:compute": {"steptime": (6.3, -0.2, 0.2, "seconds")}} + + @sanity_function + def assert_finished(self): + """Sanity check that simulation finished successfully""" + return sn.assert_found("Good job", self.stdout) + + @performance_function("seconds", perf_key="performance") + def extract_perf(self): + """Extract performance value to compare with reference value""" + return sn.extractsingle( + r"Averaged time per step \(s\):\s+(?P\S+)", + self.stdout, + "steptime", + float, + )