MFCInputFile refactor & input file-defined tests (#410)

Author: henryleberre

CMakeLists.txt

@@ -263,22 +263,30 @@ macro(HANDLE_SOURCES target useCommon)
 
     string(TOUPPER ${target} ${target}_UPPER)
 
-    # Gather src/[<target>,common]/*.f90
-    file(GLOB ${target}_F90s CONFIGURE_DEPENDS "${${target}_DIR}/*.f90")
+    # Gather: 
+    # *          src/[<target>,(common)]/*.f90
+    # * (if any) <build>/modules/<target>/*.f90
+    file(GLOB ${target}_F90s CONFIGURE_DEPENDS "${${target}_DIR}/*.f90"
+                                               "${CMAKE_BINARY_DIR}/modules/${target}/*.f90")
     set(${target}_SRCs ${${target}_F90s})
     if (${useCommon})
         file(GLOB common_F90s CONFIGURE_DEPENDS "${common_DIR}/*.f90")
         list(APPEND ${target}_SRCs ${common_F90s})
     endif()
 
-    # src/[<target>,common]/*.fpp -> src/<target>/fypp/*.f90
-    file(GLOB ${target}_FPPs CONFIGURE_DEPENDS "${${target}_DIR}/*.fpp")
+    # Gather:
+    # *          src/[<target>,(common)]/*.fpp]
+    # * (if any) <build>/modules/<target>/*.fpp
+    file(GLOB ${target}_FPPs CONFIGURE_DEPENDS "${${target}_DIR}/*.fpp"
+                                               "${CMAKE_BINARY_DIR}/modules/${target}/*.fpp")
     if (${useCommon})
         file(GLOB common_FPPs CONFIGURE_DEPENDS "${common_DIR}/*.fpp")
         list(APPEND ${target}_FPPs ${common_FPPs})
     endif()
 
-    # Locate src/[<target>,common]/include/*.fpp
+    # Gather:
+    # *          src/[<target>,common]/include/*.fpp
+    # * (if any) <build>/include/<target>/*.fpp
     file(GLOB ${target}_incs CONFIGURE_DEPENDS "${${target}_DIR}/include/*.fpp"
                                                "${CMAKE_BINARY_DIR}/include/${target}/*.fpp")
 
@@ -287,6 +295,7 @@ macro(HANDLE_SOURCES target useCommon)
         list(APPEND ${target}_incs ${common_incs})
     endif()
 
+    # /path/to/*.fpp (used by <target>) -> <build>/fypp/<target>/*.f90
     file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/fypp/${target}")
     foreach(fpp ${${target}_FPPs})
         cmake_path(GET fpp FILENAME fpp_filename)

docs/documentation/testing.md

@@ -30,7 +30,7 @@ It is recommended that a range be specified when generating golden files for new
 **Note:** If you output new variables and want to update the golden files to include these without modifying the original data, use the `--add-new-variables` option instead.
 
 Adding a new test case can be done by modifying [cases.py](https://github.com/MFlowCode/MFC/tree/master/toolchain/mfc/test/cases.py).
-The function `generate_cases` is responsible for generating the list of test cases.
+The function `list_cases` is responsible for generating the list of test cases.
 Loops and conditionals are used to vary parameters, whose defaults can be found in the `BASE_CFG` case object within [case.py](https://github.com/MFlowCode/MFC/tree/master/toolchain/mfc/test/case.py).
 The function operates on two variables:
 
@@ -54,7 +54,7 @@ where:
 - `params` is the fully resolved case dictionary, as would appear in a Python case input file.
 - `ppn` is the number of processes per node to use when running the case.
 
-To illustrate, consider the following excerpt from `generate_cases`:
+To illustrate, consider the following excerpt from `list_cases`:
 
 ```python
 for weno_order in [3, 5]:
@@ -67,22 +67,22 @@ for weno_order in [3, 5]:
       })
 
       if not (mp_weno == 'T' and weno_order != 5):
-          cases.append(create_case(stack, '', {}))
+          cases.append(define_case_d(stack, '', {}))
 
       stack.pop()
 
   stack.pop()
 ```
 
-When pushing to the stack, or creating a new case with the `create_case` function, you must specify:
+When pushing to the stack, or creating a new case with the `define_case_d` function, you must specify:
 - `stack`: The current stack.
 - `trace`: A human-readable string describing what you are currently varying.
 - `variations`: A Python dictionary with case parameter variations.
 - (Optional) `ppn`: The number of processes per node to use (default is 1).
 
 If a trace is empty (that is, the empty string `""`), it will not appear in the final trace, but any case parameter variations associated with it will still be applied.
 
-Finally, the case is appended to the `cases` list, which will be returned by the `generate_cases` function.
+Finally, the case is appended to the `cases` list, which will be returned by the `list_cases` function.
 
 ### Testing Post Process
 

src/simulation/m_derived_variables.f90

@@ -202,7 +202,6 @@ subroutine s_derive_acceleration_component(i, q_prim_vf0, q_prim_vf1, &
 
                         do r = -fd_number, fd_number
                             if (n == 0) then ! 1D simulation
-                                print *, q_sf(j, k, l), q_prim_vf0(mom_idx%beg)%sf(j, k, l), fd_coeff_x(r, j), q_prim_vf0(mom_idx%beg)%sf(r + j, k, l)
                                 q_sf(j, k, l) = q_sf(j, k, l) &
                                                 + q_prim_vf0(mom_idx%beg)%sf(j, k, l)*fd_coeff_x(r, j)* &
                                                 q_prim_vf0(mom_idx%beg)%sf(r + j, k, l)

toolchain/mfc/args.py

@@ -3,7 +3,7 @@
 from .run.run      import get_baked_templates
 from .build        import TARGETS, DEFAULT_TARGETS, DEPENDENCY_TARGETS
 from .common       import MFCException, format_list_to_string
-from .test.cases   import generate_cases
+from .test.cases   import list_cases
 
 # pylint: disable=too-many-locals, too-many-branches, too-many-statements
 def parse(config):
@@ -77,7 +77,7 @@ def add_common_arguments(p, mask = None):
     add_common_arguments(clean, "jg")
 
     # === TEST ===
-    test_cases = generate_cases()
+    test_cases = list_cases()
 
     add_common_arguments(test, "t")
     test.add_argument("-l", "--list",         action="store_true", help="List all available tests.")
@@ -124,6 +124,7 @@ def add_common_arguments(p, mask = None):
     run.add_argument("-f", "--flags",              metavar="FLAGS", dest="--", nargs=argparse.REMAINDER, type=str, default=[], help="Arguments to forward to the MPI invocation.")
     run.add_argument("-c", "--computer",           metavar="COMPUTER",           type=str, default="default",  help=f"(Batch) Path to a custom submission file template or one of {format_list_to_string(list(get_baked_templates().keys()))}.")
     run.add_argument("-o", "--output-summary",     metavar="OUTPUT",             type=str, default=None,       help="Output file (YAML) for summary.")
+    run.add_argument("--clean",                    action="store_true",                    default=False,      help="Clean the case before running.")
 
     # === BENCH ===
     add_common_arguments(bench)

toolchain/mfc/build.py

@@ -31,20 +31,20 @@ def compute(self) -> typing.Set:
     def __hash__(self) -> int:
         return hash(self.name)
 
-    def get_slug(self) -> str:
+    def get_slug(self, case: input.MFCInputFile) -> str:
         if self.isDependency:
             return self.name
 
         m = hashlib.sha256()
         m.update(self.name.encode())
         m.update(CFG().make_slug().encode())
-        m.update(input.load({}).get_fpp(self, False).encode())
+        m.update(case.get_fpp(self, False).encode())
 
         return m.hexdigest()[:10]
 
     # Get path to directory that will store the build files
-    def get_staging_dirpath(self) -> str:
-        return os.sep.join([os.getcwd(), "build", "staging", self.get_slug() ])
+    def get_staging_dirpath(self, case: input.MFCInputFile) -> str:
+        return os.sep.join([os.getcwd(), "build", "staging", self.get_slug(case) ])
 
     # Get the directory that contains the target's CMakeLists.txt
     def get_cmake_dirpath(self) -> str:
@@ -56,41 +56,39 @@ def get_cmake_dirpath(self) -> str:
             os.sep.join(["toolchain", "dependencies"]) if self.isDependency else "",
         ])
 
-    def get_install_dirpath(self) -> str:
+    def get_install_dirpath(self, case: input.MFCInputFile) -> str:
         # The install directory is located:
         # Regular:    <root>/build/install/<slug>
         # Dependency: <root>/build/install/dependencies (shared)
         return os.sep.join([
             os.getcwd(),
             "build",
             "install",
-            'dependencies' if self.isDependency else self.get_slug(),
+            'dependencies' if self.isDependency else self.get_slug(case),
         ])
 
-    def get_install_binpath(self) -> str:
+    def get_install_binpath(self, case: input.MFCInputFile) -> str:
         # <root>/install/<slug>/bin/<target>
-        return os.sep.join([self.get_install_dirpath(), "bin", self.name])
+        return os.sep.join([self.get_install_dirpath(case), "bin", self.name])
 
-    def is_configured(self) -> bool:
+    def is_configured(self, case: input.MFCInputFile) -> bool:
         # We assume that if the CMakeCache.txt file exists, then the target is
         # configured. (this isn't perfect, but it's good enough for now)
         return os.path.isfile(
-            os.sep.join([self.get_staging_dirpath(), "CMakeCache.txt"])
+            os.sep.join([self.get_staging_dirpath(case), "CMakeCache.txt"])
         )
 
-    def get_configuration_txt(self) -> typing.Optional[dict]:
-        if not self.is_configured():
+    def get_configuration_txt(self, case: input.MFCInputFile) -> typing.Optional[dict]:
+        if not self.is_configured(case):
             return None
 
-        configpath = os.path.join(self.get_staging_dirpath(), "configuration.txt")
+        configpath = os.path.join(self.get_staging_dirpath(case), "configuration.txt")
         if not os.path.exists(configpath):
             return None
 
         with open(configpath) as f:
             return f.read()
 
-        return None
-
     def is_buildable(self) -> bool:
         if ARG("no_build"):
             return False
@@ -100,12 +98,12 @@ def is_buildable(self) -> bool:
 
         return True
 
-    def configure(self):
-        build_dirpath   = self.get_staging_dirpath()
+    def configure(self, case: input.MFCInputFile):
+        build_dirpath   = self.get_staging_dirpath(case)
         cmake_dirpath   = self.get_cmake_dirpath()
-        install_dirpath = self.get_install_dirpath()
+        install_dirpath = self.get_install_dirpath(case)
 
-        install_prefixes = ';'.join([install_dirpath, get_dependency_install_dirpath()])
+        install_prefixes = ';'.join([install_dirpath, get_dependency_install_dirpath(case)])
 
         mod_dirs = ';'.join(['build/install/dependencies/include/hipfort/amdgcn'])
 
@@ -152,17 +150,17 @@ def configure(self):
         delete_directory(build_dirpath)
         create_directory(build_dirpath)
 
-        input.load({}).generate_fpp(self)
+        case.generate_fpp(self)
 
         if system(command).returncode != 0:
             raise MFCException(f"Failed to configure the [bold magenta]{self.name}[/bold magenta] target.")
 
         cons.print(no_indent=True)
 
-    def build(self):
-        input.load({}).generate_fpp(self)
+    def build(self, case: input.MFCInputFile):
+        case.generate_fpp(self)
 
-        command = ["cmake", "--build",    self.get_staging_dirpath(),
+        command = ["cmake", "--build",    self.get_staging_dirpath(case),
                             "--target",   self.name,
                             "--parallel", ARG("jobs"),
                             "--config",   'Debug' if ARG('debug') else 'Release']
@@ -174,16 +172,16 @@ def build(self):
 
         cons.print(no_indent=True)
 
-    def install(self):
-        command = ["cmake", "--install", self.get_staging_dirpath()]
+    def install(self, case: input.MFCInputFile):
+        command = ["cmake", "--install", self.get_staging_dirpath(case)]
 
         if system(command).returncode != 0:
             raise MFCException(f"Failed to install the [bold magenta]{self.name}[/bold magenta] target.")
 
         cons.print(no_indent=True)
 
-    def clean(self):
-        build_dirpath = self.get_staging_dirpath()
+    def clean(self, case: input.MFCInputFile):
+        build_dirpath = self.get_staging_dirpath(case)
 
         if not os.path.isdir(build_dirpath):
             return
@@ -229,17 +227,17 @@ def get_targets(targets: typing.List[typing.Union[str, MFCTarget]]) -> typing.Li
     return [ get_target(t) for t in targets ]
 
 
-def get_dependency_install_dirpath() -> str:
+def get_dependency_install_dirpath(case: input.MFCInputFile) -> str:
     # Since dependencies share the same install directory, we can just return
     # the install directory of the first dependency we find.
     for target in TARGETS:
         if target.isDependency:
-            return target.get_install_dirpath()
+            return target.get_install_dirpath(case)
 
     raise MFCException("No dependency target found.")
 
 
-def __build_target(target: typing.Union[MFCTarget, str], history: typing.Set[str] = None):
+def __build_target(target: typing.Union[MFCTarget, str], case: input.MFCInputFile, history: typing.Set[str] = None):
     if history is None:
         history = set()
 
@@ -254,20 +252,20 @@ def __build_target(target: typing.Union[MFCTarget, str], history: typing.Set[str
         # If we have already built and installed this target,
         # do not do so again. This can be inferred by whether
         # the target requesting this dependency is already configured.
-        if dep.isDependency and target.is_configured():
+        if dep.isDependency and target.is_configured(case):
             continue
 
-        build([dep], history)
+        build([dep], case, history)
 
-    if not target.is_configured():
-        target.configure()
+    if not target.is_configured(case):
+        target.configure(case)
 
-    target.build()
-    target.install()
+    target.build(case)
+    target.install(case)
 
 
-def get_configured_targets() -> typing.List[MFCTarget]:
-    return [ target for target in TARGETS if target.is_configured() ]
+def get_configured_targets(case: input.MFCInputFile) -> typing.List[MFCTarget]:
+    return [ target for target in TARGETS if target.is_configured(case) ]
 
 
 def __generate_header(step_name: str, targets: typing.List):
@@ -281,27 +279,29 @@ def __generate_header(step_name: str, targets: typing.List):
     return f"[bold]{step_name} | {target_list} | {caseopt_info}[/bold]"
 
 
-def build(targets = None, history: typing.Set[str] = None):
+def build(targets = None, case: input.MFCInputFile = None, history: typing.Set[str] = None):
     if history is None:
         history = set()
     if targets is None:
         targets = ARG("targets")
 
     targets = get_targets(list(REQUIRED_TARGETS) + targets)
+    case    = case or input.load(ARG("input"), ARG("arguments"), {})
 
     if len(history) == 0:
         cons.print(__generate_header("Build", targets))
         cons.print(no_indent=True)
 
     for target in targets:
-        __build_target(target, history)
+        __build_target(target, case, history)
 
     if len(history) == 0:
         cons.print(no_indent=True)
 
 
-def clean(targets = None):
+def clean(targets = None, case: input.MFCInputFile = None):
     targets = get_targets(list(REQUIRED_TARGETS) + (targets or ARG("targets")))
+    case    = case or input.load(ARG("input"), ARG("arguments"), {})
 
     cons.print(__generate_header("Clean", targets))
     cons.print(no_indent=True)