da4ml 0.1.2__tar.gz → 0.2.0__tar.gz

da4ml-0.2.0/.clang-format

@@ -0,0 +1,191 @@
+---
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignArrayOfStructures: None
+AlignConsecutiveMacros: None
+AlignConsecutiveAssignments: None
+AlignConsecutiveBitFields: None
+AlignConsecutiveDeclarations: None
+AlignEscapedNewlines: Right
+AlignOperands:   Align
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortEnumsOnASingleLine: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: MultiLine
+AttributeMacros:
+  - __capability
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: Never
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  BeforeLambdaBody: false
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: true
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     125
+CommentPragmas:  '^ IWYU pragma:'
+QualifierAlignment: Leave
+CompactNamespaces: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DeriveLineEnding: true
+DerivePointerAlignment: false
+DisableFormat:   false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: LogicalBlock
+ExperimentalAutoDetectBinPacking: false
+PackConstructorInitializers: BinPack
+BasedOnStyle:    ''
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+AllowAllConstructorInitializersOnNextLine: true
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IfMacros:
+  - KJ_IF_MAYBE
+IncludeBlocks:   Preserve
+IncludeCategories:
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        3
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '.*'
+    Priority:        1
+    SortPriority:    0
+    CaseSensitive:   false
+IncludeIsMainRegex: '(Test)?$'
+IncludeIsMainSourceRegex: ''
+IndentAccessModifiers: false
+IndentCaseLabels: false
+IndentCaseBlocks: false
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentExternBlock: AfterExternBlock
+IndentRequires:  false
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+InsertTrailingCommas: None
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+LambdaBodyIndentation: Signature
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakOpenParenthesis: 0
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PenaltyIndentedWhitespace: 0
+PointerAlignment: Right
+PPIndentWidth:   -1
+ReferenceAlignment: Pointer
+ReflowComments:  true
+RemoveBracesLLVM: false
+SeparateDefinitionBlocks: Leave
+ShortNamespaceLines: 1
+SortIncludes:    CaseSensitive
+SortJavaStaticImport: Before
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeParensOptions:
+  AfterControlStatements: true
+  AfterForeachMacros: true
+  AfterFunctionDefinitionName: false
+  AfterFunctionDeclarationName: false
+  AfterIfMacros:   true
+  AfterOverloadedOperator: false
+  BeforeNonEmptyParentheses: false
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  Never
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInLineCommentPrefix:
+  Minimum:         1
+  Maximum:         -1
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+BitFieldColonSpacing: Both
+Standard:        Latest
+StatementAttributeLikeMacros:
+  - Q_EMIT
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        8
+UseCRLF:         false
+UseTab:          Never
+WhitespaceSensitiveMacros:
+  - STRINGIZE
+  - PP_STRINGIZE
+  - BOOST_PP_STRINGIZE
+  - NS_SWIFT_NAME
+  - CF_SWIFT_NAME
+...

{da4ml-0.1.2 → da4ml-0.2.0}/.gitignore

@@ -1,3 +1,11 @@
+# test files
+_*_codegen/
+
+# Verilator generated files
+obj_dir/
+*.vcd
+*.vpd
+
 # Notebooks
 *.ipynb
 

da4ml-0.2.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: da4ml
+Version: 0.2.0
+Summary: Digital Arithmetic for Machine Learning
+Author-email: Chang Sun <chsun@cern.ch>
+License: GNU Lesser General Public License v3 (LGPLv3)
+Project-URL: repository, https://github.com/calad0i/da4ml
+Keywords: CMVM,distributed arithmetic,hls4ml,MCM,subexpression elimination
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: llvmlite>=0.44
+Requires-Dist: numba>=0.61
+Dynamic: license-file
+
+# da4ml: Distributed Arithmetic for Machine Learning
+
+This project performs Constant Matrix-Vector Multiplication (CMVM) with Distributed Arithmetic (DA) for Machine Learning (ML) on a Field Programmable Gate Arrays (FPGAs).
+
+CMVM optimization is done through greedy CSE of two-term subexpressions, with possible Delay Constraints (DC). The optimization is done in jitted Python (Numba), and a list of optimized operations is generated as traced Python code.
+
+At the moment, the project only generates Vitis HLS C++ code for the FPGA implementation of the optimized CMVM kernel. HDL code generation is planned for the future. Currently, the major use of this repository is through the `distributed_arithmetic` strategy in the [`hls4ml`](https://github.com/fastmachinelearning/hls4ml/) project.
+
+
+## Installation
+
+The project is available on PyPI and can be installed with pip:
+
+```bash
+pip install da4ml
+```
+
+Notice that `numba>=6.0.0` is required for the project to work. The project does not work with `python<3.10`. If the project fails to compile, try upgrading `numba` and `llvmlite` to the latest versions.
+
+## `hls4ml`
+
+The major use of this project is through the `distributed_arithmetic` strategy in the `hls4ml`:
+
+```python
+model_hls = hls4ml.converters.convert_from_keras_model(
+    model,
+    hls_config={
+        'Model': {
+            ...
+            'Strategy': 'distributed_arithmetic',
+        },
+        ...
+    },
+    ...
+)
+```
+
+Currently, `Dense/Conv1D/Conv2D` layers are supported for both `io_parallel` and `io_stream` dataflows. However, notice that distributed arithmetic implies `reuse_factor=1`, as the whole kernel is implemented in combinational logic.
+
+### Notice
+
+Currently, only the `da4ml-v3` branch of `hls4ml` supports the `distributed_arithmetic` strategy. The `da4ml-v3` branch is not yet merged into the `main` branch of `hls4ml`, so you need to install it from the GitHub repository.

da4ml-0.2.0/README.md

@@ -0,0 +1,42 @@
+# da4ml: Distributed Arithmetic for Machine Learning
+
+This project performs Constant Matrix-Vector Multiplication (CMVM) with Distributed Arithmetic (DA) for Machine Learning (ML) on a Field Programmable Gate Arrays (FPGAs).
+
+CMVM optimization is done through greedy CSE of two-term subexpressions, with possible Delay Constraints (DC). The optimization is done in jitted Python (Numba), and a list of optimized operations is generated as traced Python code.
+
+At the moment, the project only generates Vitis HLS C++ code for the FPGA implementation of the optimized CMVM kernel. HDL code generation is planned for the future. Currently, the major use of this repository is through the `distributed_arithmetic` strategy in the [`hls4ml`](https://github.com/fastmachinelearning/hls4ml/) project.
+
+
+## Installation
+
+The project is available on PyPI and can be installed with pip:
+
+```bash
+pip install da4ml
+```
+
+Notice that `numba>=6.0.0` is required for the project to work. The project does not work with `python<3.10`. If the project fails to compile, try upgrading `numba` and `llvmlite` to the latest versions.
+
+## `hls4ml`
+
+The major use of this project is through the `distributed_arithmetic` strategy in the `hls4ml`:
+
+```python
+model_hls = hls4ml.converters.convert_from_keras_model(
+    model,
+    hls_config={
+        'Model': {
+            ...
+            'Strategy': 'distributed_arithmetic',
+        },
+        ...
+    },
+    ...
+)
+```
+
+Currently, `Dense/Conv1D/Conv2D` layers are supported for both `io_parallel` and `io_stream` dataflows. However, notice that distributed arithmetic implies `reuse_factor=1`, as the whole kernel is implemented in combinational logic.
+
+### Notice
+
+Currently, only the `da4ml-v3` branch of `hls4ml` supports the `distributed_arithmetic` strategy. The `da4ml-v3` branch is not yet merged into the `main` branch of `hls4ml`, so you need to install it from the GitHub repository.

{da4ml-0.1.2 → da4ml-0.2.0}/pyproject.toml

@@ -29,7 +29,7 @@ classifiers = [
   "Programming Language :: Python :: 3.13",
 ]
 dynamic = [ "version" ]
-dependencies = [ "llvmlite>=0.43", "numba>=0.60" ]
+dependencies = [ "llvmlite>=0.44", "numba>=0.61" ]
 urls.repository = "https://github.com/calad0i/da4ml"
 
 [tool.setuptools]
@@ -54,7 +54,7 @@ format.skip-magic-trailing-comma = false
 format.docstring-code-line-length = 130
 format.docstring-code-format = true
 lint.select = [ "E", "F", "F401", "I", "W" ]
-lint.ignore = [ "E501", "F403", "F405" ]
+lint.ignore = [ "E501", "E741", "F403", "F405" ]
 lint.explicit-preview-rules = true
 lint.fixable = [ "ALL" ]
 lint.unfixable = [  ]

da4ml-0.2.0/src/da4ml/__init__.py

@@ -0,0 +1,17 @@
+# from .cmvm.api import cost, fn_from_kernel
+# from .cmvm.cmvm import compile_kernel
+# from .cmvm.codegen import PyCodegenBackend, VitisCodegenBackend
+# from .cmvm.graph_compile import graph_compile_states
+# from .cmvm.utils import DAState, OpCode, Score
+
+# __all__ = [
+#     'DAState',
+#     'OpCode',
+#     'Score',
+#     'cost',
+#     'compile_kernel',
+#     'fn_from_kernel',
+#     'graph_compile_states',
+#     'PyCodegenBackend',
+#     'VitisCodegenBackend',
+# ]

{da4ml-0.1.2 → da4ml-0.2.0}/src/da4ml/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.2'
-__version_tuple__ = version_tuple = (0, 1, 2)
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)

da4ml-0.2.0/src/da4ml/cmvm/__init__.py

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

da4ml-0.2.0/src/da4ml/cmvm/api.py

@@ -0,0 +1,257 @@
+from math import ceil, log2
+
+import numpy as np
+from numba import jit, prange
+
+from .core import _solve, create_state, to_solution
+from .types import CascadedSolution, QInterval
+from .util import kernel_decompose
+
+
+@jit(cache=True)
+def minimal_latency(
+    kernel: np.ndarray,
+    qintervals: list[QInterval],
+    latencies: list[float],
+    carry_size: int = -1,
+    adder_size: int = -1,
+):
+    """Fast latency calculation for a given kernel, QInterval, and input latencies.
+    When carry_size=-1, and the input latency is constant `l`:
+    this will be the same as `l + max(ceiling(log2(max(#CSD bits for each column, 1))))`.
+
+    Parameters
+    ----------
+    kernel : np.ndarray
+        The input kernel matrix.
+    qintervals : list[QInterval]
+        List of QIntervals for each input.
+    latencies : list[float]
+        List of latencies for each input
+    carry_size : int, optional
+        The size of the carry unit for latency computation, by default -1 (fixed latency for each addition operation)
+    adder_size : int, optional
+        The size of the adder unit for latency computation, by default -1 (fixed cost for each addition operation)
+
+    Returns
+    -------
+    float
+        The minimal latency for the given kernel, QInterval, and input latencies.
+    """
+
+    state = create_state(kernel, qintervals, latencies, no_stat_init=True)
+    sol = to_solution(state, adder_size=adder_size, carry_size=carry_size)
+    latencies = [sol.ops[i].latency if i >= 0 else 0.0 for i in sol.out_idxs]
+    return max(latencies)
+
+
+@jit(cache=True)
+def jit_solve(
+    kernel: np.ndarray,
+    method0: str = 'wmc',
+    method1: str = 'auto',
+    hard_dc: int = -1,
+    decompose_dc: int = -2,
+    qintervals: list[QInterval] | None = None,
+    latencies: list[float] | None = None,
+    adder_size: int = -1,
+    carry_size: int = -1,
+) -> CascadedSolution:
+    """Optimized implementation of a CMVM computation with cascaded two matrices.
+
+    Parameters
+    ----------
+    kernel : np.ndarray
+        The input kernel matrix to be implemented.
+    method0 : str, optional
+        Optimization method for the first stage. Must be one of [`wmc`, `wmc-dc`, `wmc-pdc`, `mc`, `mc-dc`, `mc-pdc`].
+    method1 : str, optional
+        Optimization method for the second stage. When 'auto', it will select based on hard_dc and method0, by default 'auto'
+    hard_dc : int, optional
+        Hard depth constraint (additional latency allowed beyond minimal latency), by default -1 (no constraint)
+    decompose_dc : int, optional
+        Decomposition depth constraint, by default -1 (no constraint, follows hard_dc)
+    qintervals : list[QInterval] | None, optional
+        List of quantization intervals for each input, by default None ([-128, 127, 1] for all inputs)
+    inp_latencies : list[float] | None, optional
+        List of input latencies, by default None (0. for all inputs)
+    adder_size : int, optional
+        Size of the adder unit for latency computation, by default -1 (fixed cost for each addition)
+    carry_size : int, optional
+        Size of the carry unit for latency computation, by default -1 (fixed latency for each addition)
+
+    Returns
+    -------
+    CascadedSolution
+        A solution containing the optimized implementation of the CMVM computation with cascaded stages.
+    """
+
+    if hard_dc < 0:
+        hard_dc = int(1e9)
+
+    if method1 == 'auto':
+        if hard_dc >= 6 or method0.endswith('dc'):
+            method1 = method0
+        else:
+            method1 = method0 + '-dc'
+    if hard_dc == 0 and not method0.endswith('dc'):
+        method0 = method0 + '-dc'
+
+    if qintervals is None:
+        _qintervals = [QInterval(-128.0, 127.0, 1.0)] * kernel.shape[0]
+    else:
+        _qintervals = list(qintervals)
+    if latencies is None:
+        _inp_latencies = [0.0] * kernel.shape[0]
+    else:
+        _inp_latencies = [float(lat) for lat in latencies]
+    assert len(_qintervals) == kernel.shape[0]
+    assert len(_inp_latencies) == kernel.shape[0]
+
+    min_lat = minimal_latency(kernel, _qintervals, _inp_latencies, carry_size=carry_size, adder_size=adder_size)
+    latency_allowed = hard_dc + min_lat
+    if decompose_dc == -2:
+        decompose_dc = min(hard_dc, ceil(log2(kernel.shape[0])))
+    else:
+        decompose_dc = min(hard_dc, decompose_dc, ceil(log2(kernel.shape[0])))
+
+    while True:
+        if decompose_dc < 0 and hard_dc >= 0:
+            if method0 != 'dummy':
+                method0, method1 = 'wmc-dc', 'wmc-dc'
+            else:
+                method0, method1 = 'dummy', 'dummy'
+        mat0, mat1 = kernel_decompose(kernel, dc=decompose_dc)
+        sol0 = _solve(
+            mat0, method=method0, qintervals=_qintervals, latencies=_inp_latencies, adder_size=adder_size, carry_size=carry_size
+        )
+        latencies0 = [sol0.ops[i].latency if i >= 0 else 0.0 for i in sol0.out_idxs]
+        qintervals0 = [sol0.ops[i].qint if i >= 0 else QInterval(0.0, 0.0, np.inf) for i in sol0.out_idxs]
+        if max(latencies0) > latency_allowed:
+            if not method0 == method1 == 'wmc-dc' or decompose_dc >= 0:
+                decompose_dc -= 1
+                continue
+        sol1 = _solve(
+            mat1, method=method1, qintervals=qintervals0, latencies=latencies0, adder_size=adder_size, carry_size=carry_size
+        )
+        latencies1 = [sol1.ops[i].latency if i >= 0 else 0.0 for i in sol1.out_idxs]
+        if max(latencies1) > latency_allowed:
+            # Prevent infinite loop, shouldn't happen though
+            if not method0 == method1 == 'wmc-dc' or decompose_dc >= 0:
+                decompose_dc -= 1
+                continue
+        if sum([op.cost for op in sol1.ops]) * 4 > sum([op.cost for op in sol0.ops]) and decompose_dc > 0:
+            # If the second stage is too expensive, the decomposition usually doesn't worth it
+            decompose_dc -= 1
+            continue
+        break
+    if max(latencies1) > latency_allowed:
+        # When latency depends on the bw, may happen
+        print(f'Latency constraint not satisfied: {int(latency_allowed)} < {int(max(latencies1))}')
+    return CascadedSolution((sol0, sol1))
+
+
+@jit(cache=True, parallel=True)
+def solve(
+    kernel: np.ndarray,
+    method0: str = 'wmc',
+    method1: str = 'auto',
+    hard_dc: int = -1,
+    decompose_dc: int = -2,
+    qintervals: tuple[QInterval, ...] | None = None,
+    latencies: tuple[float, ...] | None = None,
+    adder_size: int = -1,
+    carry_size: int = -1,
+    search_all_decompose_dc: bool = True,
+) -> CascadedSolution:
+    """Solve the CMVM problem with cascaded two matrices.
+
+    Parameters
+    ----------
+    kernel : np.ndarray
+        The input kernel matrix to be implemented.
+    method0 : str, optional
+        Optimization method for the first stage. Must be one of [`wmc`, `wmc-dc`, `wmc-pdc`, `mc`, `mc-dc`, `mc-pdc`].
+    method1 : str, optional
+        Optimization method for the second stage. When 'auto', it will select based on hard_dc and method0, by default 'auto'
+    hard_dc : int, optional
+        Hard depth constraint (additional latency allowed beyond minimal latency), by default -1 (no constraint)
+    decompose_dc : int, optional
+        Decomposition depth constraint, by default -1 (no constraint, follows hard_dc)
+    qintervals : list[QInterval] | None, optional
+        List of quantization intervals for each input, by default None ([-128, 127, 1] for all inputs)
+    inp_latencies : list[float] | None, optional
+        List of input latencies, by default None (0. for all inputs)
+    adder_size : int, optional
+        Size of the adder unit for latency computation, by default -1 (fixed cost for each addition)
+    carry_size : int, optional
+        Size of the carry unit for latency computation, by default -1 (fixed latency for each addition)
+    search_all_decompose_dc : bool, optional
+        If True, search for all possible decomposition depth constraints. If False, use the provided decompose_dc value.
+        Default is True.
+
+    Returns
+    -------
+    CascadedSolution
+        A solution containing the optimized implementation of the CMVM computation with cascaded stages.
+    """
+
+    if qintervals is None:
+        _qintervals = [QInterval(-128.0, 127.0, 1.0)] * kernel.shape[0]
+    else:
+        _qintervals = list(qintervals)
+    if latencies is None:
+        _latencies = [0.0] * kernel.shape[0]
+    else:
+        _latencies = [float(lat) for lat in latencies]
+
+    if not search_all_decompose_dc:
+        return jit_solve(
+            kernel,
+            method0=method0,
+            method1=method1,
+            hard_dc=hard_dc,
+            decompose_dc=decompose_dc,
+            qintervals=_qintervals,
+            latencies=_latencies,
+            adder_size=adder_size,
+            carry_size=carry_size,
+        )
+
+    if hard_dc < 0:
+        hard_dc = int(1e9)
+
+    max_decompose_dc = min(hard_dc, ceil(log2(kernel.shape[0])))
+    try_decompose_dcs = list(range(-1, max_decompose_dc + 1))
+
+    costs = np.empty(len(try_decompose_dcs), dtype=np.float64)
+
+    for i in prange(len(try_decompose_dcs)):
+        decompose_dc = try_decompose_dcs[i]
+        _csol = jit_solve(
+            kernel,
+            method0=method0,
+            method1=method1,
+            hard_dc=hard_dc,
+            decompose_dc=decompose_dc,
+            qintervals=_qintervals,
+            latencies=_latencies,
+            adder_size=adder_size,
+            carry_size=carry_size,
+        )
+        _cost = sum([sum([op.cost for op in sol.ops]) for sol in _csol.solutions])
+        costs[i] = _cost
+
+    decompose_dc = try_decompose_dcs[np.argmin(costs)]
+    csol = jit_solve(
+        kernel,
+        method0=method0,
+        method1=method1,
+        hard_dc=hard_dc,
+        decompose_dc=decompose_dc,
+        qintervals=_qintervals,
+        latencies=_latencies,
+        adder_size=adder_size,
+        carry_size=carry_size,
+    )
+    return csol