🎨 Refactored the technology mapping interface

.github/workflows/clang-tidy-review.yml

@@ -33,6 +33,7 @@ jobs:
             -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
             -DFICTION_CLI=ON
             -DFICTION_TEST=ON
+            -DFICTION_BENCHMARK=OFF
             -DFICTION_EXPERIMENTS=ON
             -DMOCKTURTLE_EXAMPLES=OFF
           build_dir: build

.github/workflows/codeql-analysis.yml

@@ -125,6 +125,7 @@ jobs:
           -DFICTION_ENABLE_PCH=ON
           -DFICTION_CLI=ON
           -DFICTION_TEST=ON
+          -DFICTION_BENCHMARK=OFF
           -DFICTION_EXPERIMENTS=ON
           -DFICTION_Z3=ON
           -DFICTION_ENABLE_MUGEN=ON

.github/workflows/coverage.yml

@@ -99,6 +99,7 @@ jobs:
           -DFICTION_ENABLE_PCH=ON
           -DFICTION_CLI=OFF
           -DFICTION_TEST=ON
+          -DFICTION_BENCHMARK=OFF
           -DFICTION_Z3=ON
           -DFICTION_ENABLE_MUGEN=ON
           -DFICTION_PROGRESS_BARS=OFF

Dockerfile

@@ -32,6 +32,7 @@ RUN . venv/bin/activate \
       -DFICTION_ENABLE_PCH=ON \
       -DFICTION_CLI=ON \
       -DFICTION_TEST=OFF \
+      -DFICTION_BENCHMARK=OFF \
       -DFICTION_EXPERIMENTS=OFF \
       -DFICTION_Z3=ON \
       -DFICTION_ENABLE_MUGEN=OFF \

bindings/pyfiction/include/pyfiction/algorithms/network_transformation/technology_mapping.hpp

@@ -0,0 +1,96 @@
+//
+// Created by marcel on 25.01.23.
+//
+
+#ifndef PYFICTION_TECHNOLOGY_MAPPING_HPP
+#define PYFICTION_TECHNOLOGY_MAPPING_HPP
+
+#include "pyfiction/documentation.hpp"
+#include "pyfiction/types.hpp"
+
+#include <fiction/algorithms/network_transformation/technology_mapping.hpp>
+
+#include <pybind11/pybind11.h>
+
+namespace pyfiction
+{
+
+namespace detail
+{
+
+template <typename Ntk>
+void technology_mapping(pybind11::module& m)
+{
+    using namespace pybind11::literals;
+
+    m.def("technology_mapping", &fiction::technology_mapping<Ntk>, "network"_a,
+          "params"_a = fiction::technology_mapping_params{}, "stats"_a = nullptr, DOC(fiction_technology_mapping));
+}
+
+}  // namespace detail
+
+inline void technology_mapping(pybind11::module& m)
+{
+    namespace py = pybind11;
+
+    py::class_<fiction::technology_mapping_params>(m, "technology_mapping_params",
+                                                   DOC(fiction_technology_mapping_params))
+        .def(py::init<>())
+
+        .def_readwrite("decay", &fiction::technology_mapping_params::decay,
+                       DOC(fiction_technology_mapping_params_decay))
+
+        .def_readwrite("inv", &fiction::technology_mapping_params::inv, DOC(fiction_technology_mapping_params_inv))
+
+        .def_readwrite("and2", &fiction::technology_mapping_params::and2, DOC(fiction_technology_mapping_params_and2))
+        .def_readwrite("nand2", &fiction::technology_mapping_params::nand2,
+                       DOC(fiction_technology_mapping_params_nand2))
+        .def_readwrite("or2", &fiction::technology_mapping_params::or2, DOC(fiction_technology_mapping_params_or2))
+        .def_readwrite("nor2", &fiction::technology_mapping_params::nor2, DOC(fiction_technology_mapping_params_nor2))
+        .def_readwrite("xor2", &fiction::technology_mapping_params::xor2, DOC(fiction_technology_mapping_params_xor2))
+        .def_readwrite("xnor2", &fiction::technology_mapping_params::xnor2,
+                       DOC(fiction_technology_mapping_params_xnor2))
+
+        .def_readwrite("and3", &fiction::technology_mapping_params::and3, DOC(fiction_technology_mapping_params_and3))
+        .def_readwrite("xor_and", &fiction::technology_mapping_params::xor_and,
+                       DOC(fiction_technology_mapping_params_xor_and))
+        .def_readwrite("or_and", &fiction::technology_mapping_params::or_and,
+                       DOC(fiction_technology_mapping_params_or_and))
+        .def_readwrite("onehot", &fiction::technology_mapping_params::onehot,
+                       DOC(fiction_technology_mapping_params_onehot))
+        .def_readwrite("maj3", &fiction::technology_mapping_params::maj3, DOC(fiction_technology_mapping_params_maj3))
+        .def_readwrite("gamble", &fiction::technology_mapping_params::gamble,
+                       DOC(fiction_technology_mapping_params_gamble))
+        .def_readwrite("dot", &fiction::technology_mapping_params::dot, DOC(fiction_technology_mapping_params_dot))
+        .def_readwrite("mux", &fiction::technology_mapping_params::mux, DOC(fiction_technology_mapping_params_mux))
+        .def_readwrite("and_xor", &fiction::technology_mapping_params::and_xor,
+                       DOC(fiction_technology_mapping_params_and_xor))
+
+        ;
+
+    py::class_<fiction::technology_mapping_stats>(m, "technology_mapping_stats", DOC(fiction_technology_mapping_stats))
+        .def(py::init<>())
+
+        .def("report", &fiction::technology_mapping_stats::report, DOC(fiction_technology_mapping_stats_report))
+
+        ;
+
+    m.def("and_or_not", &fiction::and_or_not, DOC(fiction_and_or_not));
+
+    m.def("and_or_not_maj", &fiction::and_or_not_maj, DOC(fiction_and_or_not_maj));
+
+    m.def("all_standard_2_input_functions", &fiction::all_standard_2_input_functions,
+          DOC(fiction_all_standard_2_input_functions));
+
+    m.def("all_standard_3_input_functions", &fiction::all_standard_3_input_functions,
+          DOC(fiction_all_standard_3_input_functions));
+
+    m.def("all_supported_standard_functions", &fiction::all_supported_standard_functions,
+          DOC(fiction_all_supported_standard_functions));
+
+    detail::technology_mapping<py_logic_network>(m);
+}
+
+}  // namespace pyfiction
+
+#endif  // PYFICTION_TECHNOLOGY_MAPPING_HPP

bindings/pyfiction/include/pyfiction/pybind11_mkdoc_docstrings.hpp

@@ -187,6 +187,41 @@ Parameter ``n``:
 Returns:
     A vector of all possible edge paths leading from terminals to `v`.)doc";
 
+static const char *__doc_fiction_all_standard_2_input_functions =
+R"doc(Auxiliary function to create technology mapping parameters for AND,
+OR, NAND, NOR, XOR, XNOR, and NOT gates.
+
+Returns:
+    Technology mapping parameters.)doc";
+
+static const char *__doc_fiction_all_standard_3_input_functions =
+R"doc(Auxiliary function to create technology mapping parameters for AND3,
+XOR_AND, OR_AND, ONEHOT, MAJ3, GAMBLE, DOT, MUX, and AND_XOR gates.
+
+Returns:
+    Technology mapping parameters.)doc";
+
+static const char *__doc_fiction_all_supported_standard_functions =
+R"doc(Auxiliary function to create technology mapping parameters for all
+supported standard functions.
+
+Returns:
+    Technology mapping parameters.)doc";
+
+static const char *__doc_fiction_and_or_not =
+R"doc(Auxiliary function to create technology mapping parameters for AND,
+OR, and NOT gates.
+
+Returns:
+    Technology mapping parameters.)doc";
+
+static const char *__doc_fiction_and_or_not_maj =
+R"doc(Auxiliary function to create technology mapping parameters for AND,
+OR, NOT, and MAJ gates.
+
+Returns:
+    Technology mapping parameters.)doc";
+
 static const char *__doc_fiction_apply_gate_library =
 R"doc(Applies a gate library to a given gate-level layout and, thereby,
 creates and returns a cell-level layout. The gate library type should
@@ -6412,6 +6447,36 @@ Parameter ``param``:
 Returns:
     The string representation of the sweep parameter.)doc";
 
+static const char *__doc_fiction_detail_technology_mapping_impl = R"doc()doc";
+
+static const char *__doc_fiction_detail_technology_mapping_impl_ntk = R"doc(Input network to be mapped.)doc";
+
+static const char *__doc_fiction_detail_technology_mapping_impl_params = R"doc(Technology mapping parameters.)doc";
+
+static const char *__doc_fiction_detail_technology_mapping_impl_perform_mapping =
+R"doc(Perform technology mapping with the given number of inputs.
+
+Template parameter ``NumInp``:
+    Maximum input number of the gates in the technology library.
+
+Parameter ``gates``:
+    Technology library.
+
+Returns:
+    Mapped network.)doc";
+
+static const char *__doc_fiction_detail_technology_mapping_impl_run = R"doc()doc";
+
+static const char *__doc_fiction_detail_technology_mapping_impl_set_up_gates =
+R"doc(Create a mockturtle gate library from the given parameters.
+
+Returns:
+    A vector of mockturtle gates.)doc";
+
+static const char *__doc_fiction_detail_technology_mapping_impl_stats = R"doc(Technology mapping statistics.)doc";
+
+static const char *__doc_fiction_detail_technology_mapping_impl_technology_mapping_impl = R"doc()doc";
+
 static const char *__doc_fiction_detail_to_hex =
 R"doc(Utility function to transform a Cartesian tile into a hexagonal one.
 
@@ -14558,6 +14623,74 @@ static const char *__doc_fiction_technology_dot_drawer_node_label = R"doc()doc";
 
 static const char *__doc_fiction_technology_dot_drawer_node_label_callback = R"doc()doc";
 
+static const char *__doc_fiction_technology_mapping =
+R"doc(Performs technology mapping on the given network. Technology mapping
+is the process of replacing the gates in a network with gates from a
+given technology library. This function utilizes `mockturtle::map` to
+perform the technology mapping. This function is a wrapper around that
+interface to provide a more convenient usage.
+
+Template parameter ``Ntk``:
+    Input logic network type.
+
+Parameter ``ntk``:
+    Input logic network.
+
+Parameter ``params``:
+    Technology mapping parameters.
+
+Parameter ``pst``:
+    Technology mapping statistics.
+
+Returns:
+    Mapped network exclusively using gates from the provided library.)doc";
+
+static const char *__doc_fiction_technology_mapping_params = R"doc()doc";
+
+static const char *__doc_fiction_technology_mapping_params_and2 = R"doc(2-input AND gate.)doc";
+
+static const char *__doc_fiction_technology_mapping_params_and3 = R"doc(3-input AND gate.)doc";
+
+static const char *__doc_fiction_technology_mapping_params_and_xor = R"doc(3-input AND-XOR gate.)doc";
+
+static const char *__doc_fiction_technology_mapping_params_decay =
+R"doc(Enforce the application of at least one constant input to three-input
+gates.)doc";
+
+static const char *__doc_fiction_technology_mapping_params_dot = R"doc(3-input DOT gate.)doc";
+
+static const char *__doc_fiction_technology_mapping_params_gamble = R"doc(3-input GAMBLE gate.)doc";
+
+static const char *__doc_fiction_technology_mapping_params_inv = R"doc()doc";
+
+static const char *__doc_fiction_technology_mapping_params_maj3 = R"doc(3-input MAJ gate.)doc";
+
+static const char *__doc_fiction_technology_mapping_params_mapper_params = R"doc(mockturtle's mapper parameters.)doc";
+
+static const char *__doc_fiction_technology_mapping_params_mux = R"doc(3-input MUX gate.)doc";
+
+static const char *__doc_fiction_technology_mapping_params_nand2 = R"doc(2-input NAND gate.)doc";
+
+static const char *__doc_fiction_technology_mapping_params_nor2 = R"doc(2-input NOR gate.)doc";
+
+static const char *__doc_fiction_technology_mapping_params_onehot = R"doc(3-input ONEHOT gate.)doc";
+
+static const char *__doc_fiction_technology_mapping_params_or2 = R"doc(2-input OR gate.)doc";
+
+static const char *__doc_fiction_technology_mapping_params_or_and = R"doc(3-input OR-AND gate.)doc";
+
+static const char *__doc_fiction_technology_mapping_params_xnor2 = R"doc(2-input XNOR gate.)doc";
+
+static const char *__doc_fiction_technology_mapping_params_xor2 = R"doc(2-input XOR gate.)doc";
+
+static const char *__doc_fiction_technology_mapping_params_xor_and = R"doc(3-input XOR-AND gate.)doc";
+
+static const char *__doc_fiction_technology_mapping_stats = R"doc(Statistics for technology mapping.)doc";
+
+static const char *__doc_fiction_technology_mapping_stats_mapper_stats = R"doc(Statistics for mockturtle's mapper.)doc";
+
+static const char *__doc_fiction_technology_mapping_stats_report = R"doc(Report statistics.)doc";
+
 static const char *__doc_fiction_technology_network =
 R"doc(A `mockturtle` logic network type that extends `klut_network`. It
 reimplements all node creation functions to disable structural

bindings/pyfiction/pyfiction.cpp

@@ -6,6 +6,7 @@
 
 #include "pyfiction/algorithms/network_transformation/fanout_substitution.hpp"
 #include "pyfiction/algorithms/network_transformation/network_balancing.hpp"
+#include "pyfiction/algorithms/network_transformation/technology_mapping.hpp"
 #include "pyfiction/algorithms/path_finding/a_star.hpp"
 #include "pyfiction/algorithms/path_finding/distance.hpp"
 #include "pyfiction/algorithms/path_finding/enumerate_all_paths.hpp"
@@ -145,6 +146,7 @@ PYBIND11_MODULE(pyfiction, m)
      */
     pyfiction::fanout_substitution(m);
     pyfiction::network_balancing(m);
+    pyfiction::technology_mapping(m);
     /**
      * Algorithms: Path Finding
      */

bindings/pyfiction/test/algorithms/network_transformation/test_fanout_substitution.py

@@ -28,11 +28,11 @@ def test_substitution(self):
         self.assertEqual(substituted_breadth.num_gates(), 6)
         self.assertTrue(is_fanout_substituted(substituted_breadth, breadth_params))
 
-        threashold_params = fanout_substitution_params()
-        threashold_params.threshold = 2
-        substituted_threshold = fanout_substitution(network, threashold_params)
+        threshold_params = fanout_substitution_params()
+        threshold_params.threshold = 2
+        substituted_threshold = fanout_substitution(network, threshold_params)
         self.assertEqual(substituted_threshold.num_gates(), 5)
-        self.assertTrue(is_fanout_substituted(substituted_threshold, threashold_params))
+        self.assertTrue(is_fanout_substituted(substituted_threshold, threshold_params))
         self.assertFalse(is_fanout_substituted(substituted_threshold, depth_params))
         self.assertFalse(is_fanout_substituted(substituted_threshold, breadth_params))
 

bindings/pyfiction/test/algorithms/network_transformation/test_technology_mapping.py

@@ -0,0 +1,40 @@
+from mnt.pyfiction import *
+import unittest
+import os
+
+dir_path = os.path.dirname(os.path.realpath(__file__))
+
+
+class TestTechnologyMapping(unittest.TestCase):
+    def test_mapping_default(self):
+        network = read_technology_network(dir_path + "/../../resources/mux21.v")
+        self.assertEqual(network.num_gates(), 5)
+
+        mapped_network = technology_mapping(network)
+
+        self.assertEqual(equivalence_checking(network, mapped_network), eq_type.NO)
+
+    def test_mapping_with_parameters(self):
+        network = read_technology_network(dir_path + "/../../resources/mux21.v")
+
+        for params in [and_or_not(), and_or_not_maj(), all_standard_2_input_functions(),
+                       all_standard_3_input_functions(),
+                       all_supported_standard_functions()]:
+            mapped_network = technology_mapping(network, params)
+
+            self.assertEqual(equivalence_checking(network, mapped_network), eq_type.STRONG)
+
+    def test_mapping_with_stats(self):
+        network = read_technology_network(dir_path + "/../../resources/mux21.v")
+
+        for params in [and_or_not(), and_or_not_maj(), all_standard_2_input_functions(),
+                       all_standard_3_input_functions(),
+                       all_supported_standard_functions()]:
+            stats = technology_mapping_stats()
+            mapped_network = technology_mapping(network, params=params, stats=stats)
+
+            self.assertEqual(equivalence_checking(network, mapped_network), eq_type.STRONG)
+
+
+if __name__ == '__main__':
+    unittest.main()