Add './mfc.sh packer' command

Author: henryleberre

toolchain/mfc.py

@@ -6,17 +6,17 @@
 from mfc.state   import ARG
 from mfc.run     import run
 from mfc.test    import test
+from mfc.packer  import packer
 from mfc.common  import MFC_LOGO, MFCException, quit, format_list_to_string, does_command_exist
 from mfc.printer import cons
 
-
 def __print_greeting():
     MFC_LOGO_LINES       = MFC_LOGO.splitlines()
     max_logo_line_length = max([ len(line) for line in MFC_LOGO_LINES ])
 
     host_line    = f"{getpass.getuser()}@{platform.node()} [{platform.system()}]"
     targets_line = f"[bold]--targets {format_list_to_string(ARG('targets'), 'magenta', 'None')}[/bold]"
-    help_line    = "$ ./mfc.sh \[build, run, test, clean, count] --help"
+    help_line    = "$ ./mfc.sh \[build, run, test, clean, count, packer] --help"
 
     MFC_SIDEBAR_LINES = [
         "",
@@ -48,8 +48,9 @@ def __checks():
 
 
 def __run():    
-    {"test":  test.test,   "run":   run.run,    "build": build.build,
-     "clean": build.clean, "bench": bench.bench, "count": count.count
+    {"test":   test.test,   "run":   run.run,    "build": build.build,
+     "clean":  build.clean, "bench": bench.bench, "count": count.count,
+     "packer": packer.packer
     }[ARG("command")]()
 
 

toolchain/mfc/args.py

@@ -1,9 +1,9 @@
-import re, argparse, dataclasses
+import re, os.path, argparse, dataclasses
 
 from .build     import get_mfc_target_names, get_target_names, get_dependencies_names
 from .common    import format_list_to_string
 from .test.test import CASES as TEST_CASES
-
+from .packer    import packer
 
 def parse(config):
     from .run.engines  import ENGINES
@@ -19,14 +19,25 @@ def parse(config):
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
 
-    parsers = parser.add_subparsers(dest="command")
+    parsers = parser.add_subparsers(dest="command")    
+    run     = parsers.add_parser(name="run",    help="Run a case with MFC.",            formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    test    = parsers.add_parser(name="test",   help="Run MFC's test suite.",           formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    build   = parsers.add_parser(name="build",  help="Build MFC and its dependencies.", formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    clean   = parsers.add_parser(name="clean",  help="Clean build artifacts.",          formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    bench   = parsers.add_parser(name="bench",  help="Benchmark MFC (for CI).",         formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    count   = parsers.add_parser(name="count",  help="Count LOC in MFC.",               formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    packer  = parsers.add_parser(name="packer", help="Packer utility (pack/unpack/compare)", formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+        
+    packers = packer.add_subparsers(dest="packer")
+    pack = packers.add_parser(name="pack", help="Pack a case into a single file.", formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    pack.add_argument("input", metavar="INPUT", type=str, default="", help="Input file of case to pack.")
+    pack.add_argument("-o", "--output", metavar="OUTPUT", type=str, default=None, help="Base name of output file.")
 
-    run   = parsers.add_parser(name="run",   help="Run a case with MFC.",            formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    test  = parsers.add_parser(name="test",  help="Run MFC's test suite.",           formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    build = parsers.add_parser(name="build", help="Build MFC and its dependencies.", formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    clean = parsers.add_parser(name="clean", help="Clean build artifacts.",          formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    bench = parsers.add_parser(name="bench", help="Benchmark MFC (for CI).",         formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    count = parsers.add_parser(name="count", help="Count LOC in MFC.",         formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    compare = packers.add_parser(name="compare", help="Compare two cases.", formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    compare.add_argument("input1", metavar="INPUT1", type=str, default=None, help="First pack file.")
+    compare.add_argument("input2", metavar="INPUT2", type=str, default=None, help="Second pack file.")
+    compare.add_argument("-rel", "--reltol", metavar="RELTOL", type=float, default=1e-12, help="Relative tolerance.")
+    compare.add_argument("-abs", "--abstol", metavar="ABSTOL", type=float, default=1e-12, help="Absolute tolerance.")
 
     def add_common_arguments(p, mask = None):
         if mask is None:
@@ -117,8 +128,8 @@ def append_defaults_to_data(name: str, parser):
                 if not key in args:
                     args[key] = val
 
-    for a, b in [("run",   run  ), ("test",  test ), ("build", build),
-                 ("clean", clean), ("bench", bench), ("count", count)]:
+    for a, b in [("run",    run  ), ("test",  test ), ("build", build),
+                 ("clean",  clean), ("bench", bench), ("count", count)]:
         append_defaults_to_data(a, b)
 
     if args["command"] is None:
@@ -128,4 +139,11 @@ def append_defaults_to_data(name: str, parser):
     # "Slugify" the name of the job
     args["name"] = re.sub(r'[\W_]+', '-', args["name"])
 
+    for e in ["input", "input1", "input2"]:
+        if e not in args:
+            continue
+        
+        if args[e] is not None:
+            args[e] = os.path.abspath(args[e])
+
     return args

toolchain/mfc/packer/__init__.py

@@ -0,0 +1,52 @@
+import dataclasses, math
+
+@dataclasses.dataclass(repr=False)
+class Error:
+    absolute: float
+    relative: float
+
+    def __repr__(self) -> str:
+        return f"abs: {self.absolute:.2E}, rel: {self.relative:.2E}"
+
+
+def compute_error(measured: float, expected: float) -> Error:
+    absolute = abs(measured - expected)
+
+    if expected != 0:
+        relative = absolute / abs(expected)
+    elif measured == expected:
+        relative = 0
+    else:
+        relative = float("NaN")
+
+    return Error(absolute, relative)
+
+
+class AverageError:
+    accumulated: Error
+    count:       int
+
+    def __init__(self) -> None:
+        self.accumulated = Error(0, 0)
+        self.count       = 0
+
+    def get(self) -> Error:
+        if self.count == 0:
+            return Error(0, 0)
+
+        return Error(self.accumulated.absolute / self.count,
+                     self.accumulated.relative / self.count)
+
+    def push(self, error: Error) -> None:
+        # Do not include nans in the result
+        # See: compute_error()
+        if math.isnan(error.relative):
+            return
+
+        self.accumulated.absolute += error.absolute
+        self.accumulated.relative += error.relative
+
+        self.count += 1
+
+    def __repr__(self) -> str:
+        return self.get().__repr__()

toolchain/mfc/packer/errors.py

@@ -0,0 +1,94 @@
+import dataclasses, typing, os, re, math
+
+from ..       import common
+from ..common import MFCException
+
+from pathlib import Path
+
+# This class maps to the data contained in one file in D/
+@dataclasses.dataclass(repr=False)
+class PackEntry:
+    filepath: str
+    doubles:  typing.List[float]
+
+    def __repr__(self) -> str:
+        return f"{self.filepath} {' '.join([ str(d) for d in self.doubles ])}"
+
+
+# This class maps to the data contained in the entirety of D/: it is tush a list
+# of PackEntry classes.
+class Pack:
+    entries: typing.Dict[str, PackEntry]
+
+    def __init__(self):
+        self.entries = {}
+
+    def __init__(self, entries: typing.List[PackEntry]):
+        self.entries = {}
+        for entry in entries:
+            self.set(entry)
+
+    def find(self, filepath: str) -> PackEntry:
+        return self.entries.get(filepath, None)
+
+    def set(self, entry: PackEntry):
+        self.entries[entry.filepath] = entry
+
+    def save(self, filepath: str):
+        if filepath.endswith(".py"):
+            filepath = os.path.dirname(filepath)
+        
+        if os.path.isdir(filepath):
+            filepath = os.path.join(filepath, "pack.txt")
+        
+        if not filepath.endswith(".txt"):
+            filepath += ".txt"
+        
+        common.file_write(filepath, '\n'.join([ str(e) for e in sorted(self.entries.values(), key=lambda x: x.filepath) ]))
+
+    def hash_NaNs(self) -> bool:
+        for entry in self.entries.values():
+            for double in entry.doubles:
+                if math.isnan(double):
+                    return True
+
+        return False
+
+
+def load(filepath: str) -> Pack:
+    if not os.path.isfile(filepath):
+        filepath = os.path.join(filepath, "pack.txt")
+    
+    entries: typing.List[PackEntry] = []
+
+    for line in common.file_read(filepath).splitlines():
+        if common.isspace(line):
+            continue
+
+        arr = line.split(' ')
+
+        entries.append(PackEntry(
+            filepath=arr[0],
+            doubles=[ float(d) for d in arr[1:] ]
+        ))
+
+    return Pack(entries)
+
+
+def compile(casepath: str) -> typing.Tuple[Pack, str]:
+    entries = []
+
+    case_dir = os.path.dirname(casepath) if os.path.isfile(casepath) else casepath
+    D_dir    = os.path.join(case_dir, "D")
+
+    for filepath in list(Path(D_dir).rglob("*.dat")):
+        short_filepath = str(filepath).replace(f'{case_dir}', '')[1:].replace("\\", "/")
+
+        try:
+            doubles = [ float(e) for e in re.sub(r"[\n\t\s]+", " ", common.file_read(filepath)).strip().split(' ') ]
+        except ValueError:
+            None, f"Failed to interpret the content of [magenta]{filepath}[/magenta] as a list of floating point numbers."
+
+        entries.append(PackEntry(short_filepath,doubles))
+
+    return Pack(entries), None

toolchain/mfc/packer/pack.py

@@ -0,0 +1,63 @@
+import typing, os.path
+
+from ..printer import cons
+from ..state import ARG, ARGS
+from . import pack as _pack
+from . import errors
+from . import tol as packtol
+from ..common import MFCException
+
+def load(packpath: str) -> _pack.Pack:
+    return _pack.load(packpath)
+
+def pack(casepath: str, packpath: str = None) -> typing.Tuple[_pack.Pack, str]:
+    if packpath is None:
+        packpath = casepath
+    
+    p, err = _pack.compile(casepath)
+    
+    if err is not None:
+        return None, err
+    
+    p.save(packpath)
+
+    return p, None
+
+def compare(lhs: str = None, rhs: str = None, tol: packtol.Tolerance = None) -> typing.Tuple[errors.Error, str]:
+    if isinstance(lhs, str):
+        lhs = load(lhs)
+    if isinstance(rhs, str):
+        rhs = load(rhs)
+
+    return packtol.compare(lhs, rhs, tol)
+
+def packer():
+    if ARG("packer") == "pack":
+        if not os.path.isdir(ARG("input")):
+            ARGS()["input"] = os.path.dirname(ARG("input"))
+        
+        out_dir = os.path.sep.join([ARG("input"), ARG("output")]) if ARG("output") is not None else None
+        p, err = pack(ARG("input"), out_dir)
+        if err is not None:
+            raise MFCException(err)
+    elif ARG("packer") == "compare":        
+        cons.print(f"Comparing [magenta]{os.path.relpath(ARG('input1'), os.getcwd())}[/magenta] to [magenta]{os.path.relpath(ARG('input1'), os.getcwd())}[/magenta]:")
+        
+        cons.indent()
+        cons.print()
+        
+        tol = packtol.Tolerance(ARG("abstol"), ARG("reltol"))
+        
+        err, msg = compare(ARG("input1"), ARG("input2"), tol)
+        if msg is not None:
+            cons.print(f"[bold red]ERROR[/bold red]: The two packs are not within tolerance ({tol}).")
+            cons.print(msg)
+        else:
+            cons.print(f"[bold green]OK[/bold green]: The two packs are within tolerance ({tol}).")
+            cons.print(f"Average error: {err}.")
+
+        cons.print()
+        cons.unindent()
+    
+    else:
+        raise MFCException(f"Unknown packer command: {ARG('packer')}")

toolchain/mfc/packer/packer.py

@@ -0,0 +1,70 @@
+import math, typing
+
+from ..common import MFCException
+
+from .pack   import Pack
+from .errors import compute_error, AverageError, Error
+
+class Tolerance(Error):
+    pass
+
+
+def is_close(error: Error, tolerance: Tolerance) -> bool:
+    if error.absolute <= tolerance.absolute:
+        return True
+
+    if math.isnan(error.relative):
+        return True
+
+    if error.relative <= tolerance.relative:
+        return True
+
+    return False
+
+
+def compare(candidate: Pack, golden: Pack, tol: Tolerance) -> typing.Tuple[Error, str]:
+    # Keep track of the average error
+    avg_err = AverageError()
+
+    # Compare entry-count
+    if len(candidate.entries) != len(golden.entries):
+        return None, "Line count does not match."
+
+    # For every entry in the golden's pack
+    for gFilepath, gEntry in golden.entries.items():
+        # Find the corresponding entry in the candidate's pack
+        cEntry = candidate.find(gFilepath)
+
+        if cEntry == None:
+            return None, f"No reference to {gFilepath} in the candidate's pack."
+
+        # Compare variable-count
+        if len(gEntry.doubles) != len(cEntry.doubles):
+            return None, f"Variable count didn't match for {gFilepath}."
+
+        # Check if each variable is within tolerance
+        for valIndex, (gVal, cVal) in enumerate(zip(gEntry.doubles, cEntry.doubles)):
+            # Keep track of the error and average errors
+            error = compute_error(cVal, gVal)
+            avg_err.push(error)
+
+            def raise_err(msg: str):
+                return None, f"""\
+Variable n°{valIndex+1} (1-indexed) in {gFilepath} {msg}:
+  - Candidate:   {cVal}
+  - Golden:      {gVal}
+  - Error:       {error}
+  - Tolerance:   {tol}
+"""
+
+            if math.isnan(gVal):
+                raise_err("is NaN in the golden file")
+
+            if math.isnan(cVal):
+                raise_err("is NaN in the pack file")
+
+            if not is_close(error, tol):
+                raise_err("is not within tolerance")
+
+    # Return the average relative error
+    return avg_err.get(), None