da4ml 0.5.1.post1__cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

da4ml/__init__.py

@@ -0,0 +1,4 @@
+from . import cmvm, codegen, converter, trace, typing
+from ._version import *
+
+__all__ = ['cmvm', 'codegen', 'converter', 'trace', 'typing']

da4ml/_binary/__init__.py

@@ -0,0 +1,15 @@
+import numpy as np
+from numpy.typing import NDArray
+
+from .dais_bin import run_interp
+
+
+def dais_interp_run(bin_logic: NDArray[np.int32], data: NDArray, n_threads: int = 1):
+    inp_size = int(bin_logic[2])
+
+    assert data.size % inp_size == 0, f'Input size {data.size} is not divisible by {inp_size}'
+
+    inputs = np.ascontiguousarray(np.ravel(data), dtype=np.float64)
+    bin_logic = np.ascontiguousarray(np.ravel(bin_logic), dtype=np.int32)
+
+    return run_interp(bin_logic, inputs, n_threads)

da4ml/_binary/dais_bin.pyi

@@ -0,0 +1,5 @@
+import numpy
+from numpy.typing import NDArray
+
+
+def run_interp(bin_logic: NDArray[numpy.int32], data: NDArray[numpy.float64], n_threads: int = 1) -> NDArray[numpy.float64]: ...

da4ml/_cli/__init__.py

@@ -0,0 +1,30 @@
+import argparse
+
+from .. import _version
+from .convert import _add_convert_args, convert_main
+from .report import _add_report_args, report_main
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Welcome to the da4ml command line interface')
+    subparsers = parser.add_subparsers(dest='command')
+
+    convert_parser = subparsers.add_parser('convert', help='Convert a Keras model to RTL project')
+    report_parser = subparsers.add_parser('report', help='Generate report from an existing RTL projects')
+    _add_convert_args(convert_parser)
+    _add_report_args(report_parser)
+    parser.add_argument('--version', '-v', action='version', version=f'%(prog)s {_version.__version__}')
+    args = parser.parse_args()
+
+    match args.command:
+        case 'convert':
+            convert_main(args)
+        case 'report':
+            report_main(args)
+        case _:
+            parser.print_help()
+            exit(1)
+
+
+if __name__ == '__main__':
+    main()

da4ml/_cli/convert.py

@@ -0,0 +1,204 @@
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+
+
+def to_da4ml(
+    model_path: Path,
+    path: Path,
+    n_test_sample: int,
+    period: float,
+    unc: float,
+    flavor: str,
+    latency_cutoff: int,
+    part_name: str,
+    verbose: int = 1,
+    rtl_validation: bool = False,
+    hwconf: tuple[int, int, int] = (1, -1, -1),
+    hard_dc: int = 2,
+    openmp: bool = True,
+    n_threads: int = 4,
+    metadata=None,
+    inputs_kif: tuple[int, int, int] | None = None,
+):
+    from da4ml.cmvm.types import CombLogic
+    from da4ml.codegen import RTLModel
+    from da4ml.converter import trace_model
+    from da4ml.trace import HWConfig, comb_trace
+
+    if model_path.suffix in {'.h5', '.keras'}:
+        import hgq  # noqa: F401
+        import keras
+
+        model: keras.Model = keras.models.load_model(model_path, compile=False)  # type: ignore
+        if verbose > 1:
+            model.summary()
+        inp, out = trace_model(model, HWConfig(*hwconf), {'hard_dc': hard_dc}, verbose > 1, inputs_kif=inputs_kif)
+        comb = comb_trace(inp, out)
+
+    elif model_path.suffix == '.json':
+        comb = CombLogic.load(model_path)
+        model = None  # type: ignore
+
+    else:
+        raise ValueError(f'Unsupported model file format: {model_path}')
+
+    rtl_model = RTLModel(
+        comb,
+        'model',
+        path,
+        flavor=flavor,
+        latency_cutoff=latency_cutoff,
+        print_latency=True,
+        clock_uncertainty=unc / 100,
+        clock_period=period,
+        part_name=part_name,
+    )
+    rtl_model.write(metadata)
+    if verbose > 1:
+        print(rtl_model)
+        print('Model written')
+    if not n_test_sample:
+        return
+
+    if model is not None:
+        data_in = [np.random.rand(n_test_sample, *inp.shape[1:]).astype(np.float32) * 64 - 32 for inp in model.inputs]
+        if len(data_in) == 1:
+            data_in = data_in[0]
+        y_keras = model.predict(data_in, batch_size=16384, verbose=0)  # type: ignore
+
+        if isinstance(y_keras, list):
+            y_keras = np.concatenate([y.reshape(n_test_sample, -1) for y in y_keras], axis=1)
+        else:
+            y_keras = y_keras.reshape(n_test_sample, -1)
+        y_comb = comb.predict(data_in, n_threads=n_threads)
+
+        total = y_comb.size
+        mask = y_comb != y_keras
+        ndiff = np.sum(mask)
+        if ndiff:
+            n_nonzero = np.sum(y_keras != 0)
+            abs_diff = np.abs(y_comb - y_keras)[mask]
+            rel_diff = abs_diff / (np.abs(y_keras[np.where(mask)]) + 1e-6)
+
+            max_diff, max_rel_diff = np.max(abs_diff), np.max(rel_diff)
+            mean_diff, mean_rel_diff = np.mean(abs_diff), np.mean(rel_diff)
+            print(
+                f'[WARNING] {ndiff}/{total} ({n_nonzero}) mismatches ({max_diff=}, {max_rel_diff=}, {mean_diff=}, {mean_rel_diff=})'
+            )
+        else:
+            max_diff = max_rel_diff = mean_diff = mean_rel_diff = 0.0
+            if verbose:
+                print(f'[INFO] DAIS simulation passed: [0/{total}] mismatches.')
+        with open(path / 'mismatches.json', 'w') as f:
+            json.dump(
+                {
+                    'n_total': int(total),
+                    'n_mismatch': int(ndiff),
+                    'max_diff': float(max_diff),
+                    'max_rel_diff': float(max_rel_diff),
+                    'mean_diff': float(mean_diff),
+                    'mean_rel_diff': float(mean_rel_diff),
+                },
+                f,
+            )
+    else:
+        if not rtl_validation:
+            return
+        data_in = np.random.rand(n_test_sample, comb.shape[0]).astype(np.float32) * 64 - 32
+        y_comb = comb.predict(data_in, n_threads=n_threads)
+        total = y_comb.size
+
+    if not rtl_validation:
+        return
+
+    if verbose > 1:
+        print('Verilating...')
+    for _ in range(3):
+        try:
+            rtl_model._compile(nproc=n_threads, openmp=openmp)
+            break
+        except RuntimeError:
+            pass
+    y_da4ml = rtl_model.predict(data_in)
+    if not np.all(y_comb == y_da4ml):
+        raise RuntimeError(f'[CRITICAL ERROR] RTL validation failed: {np.sum(y_comb != y_da4ml)}/{total} mismatches!')
+    if verbose:
+        print(f'[INFO]  RTL validation passed: [0/{total}] mismatches.')
+
+
+def convert_main(args):
+    args.outdir.mkdir(parents=True, exist_ok=True)
+    hw_conf = tuple(args.hw_config)
+    if args.metadata is not None:
+        with open(args.metadata) as f:
+            metadata = json.load(f)
+    else:
+        metadata = None
+
+    to_da4ml(
+        args.model,
+        args.outdir,
+        args.n_test_sample,
+        args.clock_period,
+        args.clock_uncertainty,
+        latency_cutoff=args.latency_cutoff,
+        part_name=args.part_name,
+        flavor=args.flavor,
+        verbose=args.verbose,
+        rtl_validation=args.validate_rtl,
+        hwconf=hw_conf,
+        hard_dc=args.delay_constraint,
+        openmp=not args.no_openmp,
+        n_threads=args.n_threads,
+        metadata=metadata,
+        inputs_kif=args.inputs_kif,
+    )
+
+
+def _add_convert_args(parser: argparse.ArgumentParser):
+    parser.add_argument('model', type=Path, help='Path to the Keras model file (.h5 or .keras)')
+    parser.add_argument('outdir', type=Path, help='Output directory')
+    parser.add_argument('--n-test-sample', '-n', type=int, default=131072, help='Number of test samples for validation')
+    parser.add_argument('--clock-period', '-c', type=float, default=5.0, help='Clock period in ns')
+    parser.add_argument('--clock-uncertainty', '-unc', type=float, default=10.0, help='Clock uncertainty in percent')
+    parser.add_argument('--flavor', type=str, default='verilog', help='Flavor for DA4ML (verilog/vhdl)')
+    parser.add_argument('--latency-cutoff', '-lc', type=float, default=5, help='Latency cutoff for pipelining')
+    parser.add_argument('--part-name', '-p', type=str, default='xcvu13p-flga2577-2-e', help='FPGA part name')
+    parser.add_argument('--verbose', '-v', default=1, type=int, help='Set verbosity level (0: silent, 1: info, 2: debug)')
+    parser.add_argument('--validate-rtl', '-vr', action='store_true', help='Validate RTL by Verilator (and GHDL)')
+    parser.add_argument('--n-threads', '-j', type=int, default=4, help='Number of threads for compilation and DAIS simulation')
+    parser.add_argument('--metadata', '-meta', type=str, default=None, help='Path to metadata JSON file to be included')
+    parser.add_argument(
+        '--hw-config',
+        '-hc',
+        type=int,
+        nargs=3,
+        metavar=('ACCUM_SIZE', 'ADDER_SIZE', 'CUTOFF'),
+        default=[1, -1, -1],
+        help='Size of accumulator and adder, and cutoff threshold during tracing. No need to modify unless you know what you are doing.',
+    )
+    parser.add_argument('--delay-constraint', '-dc', type=int, default=2, help='Delay constraint for each CMVM block')
+    parser.add_argument(
+        '--no-openmp',
+        '--no-omp',
+        action='store_true',
+        help='Disable OpenMP in RTL simulation; no effect if --validate-rtl is not set',
+    )
+    parser.add_argument(
+        '--inputs-kif',
+        '-ikif',
+        type=int,
+        nargs=3,
+        default=None,
+        help='Input precision in KIF format (keep_neg, int bits, frac bits), if known.',
+    )
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Convert Keras model to da4ml RTL model with random input test vectors')
+    _add_convert_args(parser)
+    args = parser.parse_args()
+    convert_main(args)

da4ml/_cli/report.py

@@ -0,0 +1,295 @@
+import argparse
+import json
+import os
+import re
+from math import ceil, log10
+from pathlib import Path
+from typing import Any
+
+
+def parse_timing_summary(timing_summary: str):
+    loc0 = timing_summary.find('Design Timing Summary')
+    lines = timing_summary[loc0:].split('\n')[3:10]
+    lines = [line for line in lines if line.strip() != '']
+
+    assert set(lines[1]) == {' ', '-'}
+    keys = [k.strip() for k in lines[0].split('  ') if k]
+    vals = [int(v) if '.' not in v else float(v) for v in lines[2].split('  ') if v]
+    assert len(keys) == len(vals)
+    d = dict(zip(keys, vals))
+    return d
+
+
+track = [
+    'DSPs',
+    'LUT as Logic',
+    'LUT as Memory',
+    'CLB Registers',
+    'CARRY8',
+    'Register as Latch',
+    'Register as Flip Flop',
+    'RAMB18',
+    'URAM',
+    'RAMB36/FIFO*',
+]
+
+mms = []
+for name in track:
+    m = re.compile(
+        rf'\|\s*{name}\s*\|\s*(?P<Used>\d+)\s*\|\s*(?P<Fixed>\d+)\s*\|\s*(?P<Prohibited>\d+)\s*\|\s*(?P<Available>\d+)\s*\|'
+    )
+    mms.append(m)
+
+
+def parse_utilization(utilization: str):
+    """
+    Parse the utilization report and return a DataFrame with the results.
+    """
+
+    dd = {}
+    for name, m in zip(track, mms):
+        found = m.findall(utilization)
+        # assert found, f"{name} not found in utilization report"
+        used, fixed, prohibited, available = map(int, found[0])
+        dd[name] = used
+        dd[f'{name}_fixed'] = fixed
+        dd[f'{name}_prohibited'] = prohibited
+        dd[f'{name}_available'] = available
+
+    dd['FF'] = dd['Register as Flip Flop'] + dd['Register as Latch']
+    dd['LUT'] = dd['LUT as Logic'] + dd['LUT as Memory']
+    dd['LUT_available'] = max(dd['LUT as Logic_available'], dd['LUT as Memory_available'])
+    dd['FF_available'] = max(dd['Register as Flip Flop_available'], dd['Register as Latch_available'])
+    dd['DSP'] = dd['DSPs']
+
+    return dd
+
+
+def _load_project(path: str | Path) -> dict[str, Any]:
+    path = Path(path)
+    build_tcl_path = path / 'build_vivado_prj.tcl'
+    assert build_tcl_path.exists(), f'build_vivado_prj.tcl not found in {path}'
+    top_name = build_tcl_path.read_text().split('"', 2)[1]
+
+    with open(path / f'src/{top_name}.xdc') as f:
+        target_clock_period = float(f.readline().strip().split()[2])
+    with open(path / 'metadata.json') as f:
+        metadata = json.load(f)
+
+    if metadata['flavor'] == 'vhdl':
+        with open(path / f'src/{top_name}.vhd') as f:  # type: ignore
+            latency = f.read().count('register') // 2
+    else:
+        with open(path / f'src/{top_name}.v') as f:  # type: ignore
+            latency = f.read().count('reg') - 1
+
+    d = {**metadata, 'clock_period': target_clock_period, 'latency': latency}
+
+    if (path / f'output_{top_name}/reports/{top_name}_post_route_util.rpt').exists():
+        with open(path / f'output_{top_name}/reports/{top_name}_post_route_util.rpt') as f:
+            util_rpt = f.read()
+            util = parse_utilization(util_rpt)
+
+        with open(path / f'output_{top_name}/reports/{top_name}_post_route_timing.rpt') as f:
+            timing_rpt = f.read()
+            timing = parse_timing_summary(timing_rpt)
+        d.update(timing)
+        d.update(util)
+
+        d['actual_period'] = d['clock_period'] - d['WNS(ns)']
+        d['Fmax(MHz)'] = 1000.0 / d['actual_period']
+        d['latency(ns)'] = d['latency'] * d['actual_period']
+
+    return d
+
+
+def load_project(path: str | Path) -> dict[str, Any] | None:
+    try:
+        return _load_project(path)
+    except Exception as e:
+        print(e)
+        return None
+
+
+def extra_info_from_fname(fname: str):
+    d = {}
+    for part in fname.split('-'):
+        if '=' not in part:
+            continue
+        k, v = part.split('=', 1)
+        try:
+            v = int(v)
+            d[k] = v
+            continue
+        except ValueError:
+            pass
+        try:
+            v = float(v)
+            d[k] = v
+            continue
+        except ValueError:
+            pass
+        d[k] = v
+    return d
+
+
+def pretty_print(arr: list[list]):
+    n_cols = len(arr[0])
+    terminal_width = os.get_terminal_size().columns
+    default_width = [
+        max(min(6, len(str(arr[i][j]))) if isinstance(arr[i][j], float) else len(str(arr[i][j])) for i in range(len(arr)))
+        for j in range(n_cols)
+    ]
+    if sum(default_width) + 2 * n_cols + 1 <= terminal_width:
+        col_width = default_width
+    else:
+        th = max(8, (terminal_width - 2 * n_cols - 1) // n_cols)
+        col_width = [min(w, th) for w in default_width]
+
+    header = [
+        '| ' + ' | '.join(f'{str(arr[0][i]).ljust(col_width[i])[: col_width[i]]}' for i in range(n_cols)) + ' |',
+        '|-' + '-|-'.join('-' * col_width[i] for i in range(n_cols)) + '-|',
+    ]
+    content = []
+    for row in arr[1:]:
+        _row = []
+        for i, v in enumerate(row):
+            w = col_width[i]
+            if type(v) is float:
+                n_int = ceil(log10(abs(v) + 1)) if v != 0 else 1 + (v < 0)
+                v = round(v, 10 - n_int)
+                if type(v) is int:
+                    fmt = f'{{:>{w}d}}'
+                    _v = fmt.format(v)
+                else:
+                    _v = str(v)
+                    if len(_v) > w:
+                        fmt = f'{{:.{max(w - n_int - 1, 0)}f}}'
+                        _v = fmt.format(v).ljust(w)
+                    else:
+                        _v = _v.ljust(w)
+            else:
+                _v = str(v).ljust(w)[:w]
+            _row.append(_v)
+        content.append('| ' + ' | '.join(_row) + ' |')
+    print('\n'.join(header + content))
+
+
+def stdout_print(arr: list[list], full: bool, columns: list[str] | None):
+    whitelist = [
+        'epoch',
+        'flavor',
+        'actual_period',
+        'clock_period',
+        'ebops',
+        'cost',
+        'latency',
+        'DSP',
+        'LUT',
+        'FF',
+        'comb_metric',
+        'Fmax(MHz)',
+        'latency(ns)',
+    ]
+    if columns is None:
+        columns = whitelist
+
+    if not full:
+        idx_row = arr[0]
+        keep_cols = [idx_row.index(col) for col in columns if col in idx_row]
+        arr = [[row[i] for i in keep_cols] for row in arr]
+
+    if len(arr) == 2:  # One sample
+        k_width = max(len(str(h)) for h in arr[0])
+        for k, v in zip(arr[0], arr[1]):
+            print(f'{str(k).ljust(k_width)} : {v}')
+    else:
+        pretty_print(arr)
+
+
+def report_main(args):
+    _vals = [load_project(Path(p)) for p in args.paths]
+    vals = [v for v in _vals if v is not None]
+    for path, val in zip(args.paths, vals):
+        d = extra_info_from_fname(Path(path).name)
+        for k, v in d.items():
+            val.setdefault(k, v)
+
+    _key = [x.get(args.sort_by, float('inf')) for x in vals]
+    _order = sorted(range(len(vals)), key=lambda i: -_key[i])
+    vals = [vals[i] for i in _order]
+
+    _attrs: set[str] = set()
+    for v in vals:
+        _attrs.update(v.keys())
+    attrs = sorted(_attrs)
+    arr: list[list] = [attrs]
+    for v in vals:
+        arr.append([v.get(a, '') for a in attrs])
+
+    output = args.output
+    if output == 'stdout':
+        stdout_print(arr, args.full, args.columns)
+        return
+
+    with open(output, 'w') as f:
+        ext = Path(output).suffix
+        if ext == '.json':
+            json.dump(vals, f)
+        elif ext in ['.tsv', '.csv']:
+            sep = ',' if ext == '.csv' else '\t'
+            op = (lambda x: str(x) if ',' not in str(x) else f'"{str(x)}"') if ext == '.csv' else lambda x: str(x)
+            for row in arr:
+                f.write(sep.join(map(op, row)) + '\n')  # type: ignore
+        elif ext == '.md':
+            f.write('| ' + ' | '.join(map(str, arr[0])) + ' |\n')
+            f.write('|' + '|'.join(['---'] * len(arr[0])) + '|\n')
+            for row in arr[1:]:
+                f.write('| ' + ' | '.join(map(str, row)) + ' |\n')
+        elif ext == '.html':
+            f.write('<table>\n')
+            f.write('  <tr>' + ''.join([f'<th>{a}</th>' for a in arr[0]]) + '</tr>\n')
+            for row in arr[1:]:
+                f.write('  <tr>' + ''.join([f'<td>{a}</td>' for a in row]) + '</tr>\n')
+            f.write('</table>\n')
+        else:
+            raise ValueError(f'Unsupported output format: {ext}')
+
+
+def _add_report_args(parser: argparse.ArgumentParser):
+    parser.add_argument('paths', type=str, nargs='+', help='Paths to the directories containing HDL summaries')
+    parser.add_argument(
+        '--output',
+        '-o',
+        type=str,
+        default='stdout',
+        help='Output file name for the summary. Can be stdout, .json, .csv, .tsv, .md, .html',
+    )
+    parser.add_argument(
+        '--sort-by',
+        '-s',
+        type=str,
+        default='comb_metric',
+        help='Attribute to sort the summary by. Default is cost.',
+    )
+    parser.add_argument(
+        '--full',
+        '-f',
+        action='store_true',
+        help='Include full information for stdout output. For file output, all information will always be included.',
+    )
+    parser.add_argument(
+        '--columns',
+        '-c',
+        type=str,
+        nargs='+',
+        default=None,
+        help='Specify columns to include in the report. Only applicable for stdout output. Ignored if --full is set.',
+    )
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Load HDL summaries')
+    _add_report_args(parser)
+    args = parser.parse_args()
+    report_main(args)

da4ml/_version.py

@@ -0,0 +1,32 @@
+__all__ = [
+    '__version__',
+    '__version_tuple__',
+    'version',
+    'version_tuple',
+    '__commit_id__',
+    'commit_id',
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    VERSION_TUPLE = tuple[int | str, ...]
+    COMMIT_ID = str | None
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__full_version = "0.5.1post1"
+__version__ = version = __full_version.split('-')[0]
+__version_tuple__ = version_tuple = tuple(
+    int(part) if part.isdigit() else part
+    for part in __version__.split('.')
+)
+
+__commit_id__ = commit_id = __full_version.rsplit('-', 1)[-1] if '-' in __full_version else None

da4ml/cmvm/__init__.py

@@ -0,0 +1,4 @@
+from .api import minimal_latency, solve
+from .types import CombLogic, Op, QInterval
+
+__all__ = ['minimal_latency', 'solve', 'QInterval', 'Op', 'CombLogic']