added new find carry chain function to netlist utils

Author: nils1603

include/hal_core/netlist/netlist_utils.h

@@ -356,6 +356,18 @@ namespace hal
         [[deprecated("Will be removed in a future version, use NetlistModificationDecorator::replace_gate instead.")]] CORE_API Result<std::monostate>
             replace_gate(Gate* gate, GateType* target_type, std::map<GatePin*, GatePin*> pin_map);
 
+        /**
+         * Identify carry chains in a given netlist. The user has to provide the input pin of the carry
+         * gates and output pin that will go into the subsequent gate.
+         * Note that this function relies on having annotated carry gates in the netlist to work.
+         * 
+         * @param[in] nl - The netlist to detect the carry chains in.
+         * @param[in] input_pin - The input pin through which the carries must be connected.
+         * @param[in] output_pin - The output pin through which the carries must be connected.
+         * @returns A vector of vector of gates that form a chain on success, an error otherwise.
+         */
+        CORE_API Result<std::vector<std::vector<Gate*>>> find_carry_chains(const Netlist* nl, const const std::string input_pins, const const std::string output_pins);
+
         /**
          * Find a sequence of identical gates that are connected via the specified input and output pins.
          * The start gate may be any gate within a such a sequence, it is not required to be the first or the last gate.
@@ -365,7 +377,6 @@ namespace hal
          * @param[in] start_gate - The gate at which to start the chain detection.
          * @param[in] input_pins - The input pins through which the gates must be connected. Defaults to an empty vector.
          * @param[in] output_pins - The output pins through which the gates must be connected. Defaults to an empty vector.
-         * @param[in] filter - An optional filter function to be evaluated on each gate.
          * @returns A vector of gates that form a chain on success, an error otherwise.
          */
         CORE_API Result<std::vector<Gate*>> get_gate_chain(Gate* start_gate,

src/netlist/netlist_utils.cpp

@@ -336,7 +336,7 @@ namespace hal
             {
                 if (std::find(allowed_pin_types.begin(), allowed_pin_types.end(), endpoint->get_pin()->get_type()) != allowed_pin_types.end() || allowed_pin_types.empty())
                 {
-                    auto n = endpoint->get_net();
+                    auto n   = endpoint->get_net();
                     auto suc = get_next_sequential_gates(n, get_successors, allowed_pin_types, cache);
                     found_ffs.insert(found_ffs.end(), suc.begin(), suc.end());
                 }
@@ -831,6 +831,96 @@ namespace hal
             }
         }
 
+        Result<std::vector<std::vector<Gate*>>> find_carry_chains(const Netlist* nl, const std::string input_pin, const std::string output_pin)
+        {
+            if (input_pin.empty() || output_pin.empty())
+            {
+                return ERR("input or output pin is empty");
+            }
+
+            std::vector<std::vector<Gate*>> carry_chains;
+
+            // retrieve all carry gates
+            std::vector<Gate*> carry_gates  = nl->get_gates([](const Gate* g) { return g->get_type()->has_property(GateTypeProperty::c_carry); });
+            std::set<Gate*> carry_gates_set = std::set<Gate*>(carry_gates.begin(), carry_gates.end());
+            if (carry_gates_set.empty())
+            {
+                return ERR("no carry gates in netlists");
+            }
+
+            // collect carry chains until all carry gates have been analyzed
+            while (!carry_gates_set.empty())
+            {
+                Gate* current_gate         = *carry_gates_set.begin();
+                const GateType* carry_type = current_gate->get_type();
+
+                auto input_pin_type = carry_type->get_pin_by_name(input_pin);
+                if (input_pin_type == nullptr)
+                {
+                    return ERR("could not get input pin type, is nullptr");
+                }
+
+                auto output_pin_type = carry_type->get_pin_by_name(output_pin);
+                if (output_pin_type == nullptr)
+                {
+                    return ERR("could not get output pin type, is nullptr");
+                }
+
+                // get carry chains by defining appropriate filter function
+                auto chain_res = netlist_utils::get_gate_chain(current_gate, {input_pin_type}, {output_pin_type});
+                if (chain_res.is_error())
+                {
+                    return ERR(chain_res.get_error());
+                }
+                std::vector<Gate*> carry_chain = chain_res.get();
+
+                // remove shift register gates from candidate set
+                for (Gate* g : carry_chain)
+                {
+                    carry_gates_set.erase(g);
+                }
+
+                // only consider carry chains with more than 2 gates for now
+                if (carry_chain.size() >= 2)
+                {
+                    log_debug("netlist_utils", "\tcarry_gate: {}", carry_chain.front()->get_name());
+                    carry_chains.push_back(carry_chain);
+                }
+            }
+
+            // check whether a carry chain is a subset of another one
+            std::vector<std::vector<Gate*>> filtered_carry_chains;
+            for (u32 i = 0; i < carry_chains.size(); i++)
+            {
+                auto& c_test             = carry_chains.at(i);
+                std::set<Gate*> test_set = {c_test.begin(), c_test.end()};
+
+                bool is_subset = false;
+                for (u32 j = 0; j < carry_chains.size(); j++)
+                {
+                    if (i == j)
+                    {
+                        continue;
+                    }
+
+                    auto& c_other             = carry_chains.at(j);
+                    std::set<Gate*> other_set = {c_other.begin(), c_other.end()};
+
+                    if (std::includes(other_set.begin(), other_set.end(), test_set.begin(), test_set.end()))
+                    {
+                        is_subset = true;
+                        break;
+                    }
+                }
+
+                if (!is_subset)
+                {
+                    filtered_carry_chains.push_back(c_test);
+                }
+            }
+            return OK(filtered_carry_chains);
+        }
+
         Result<std::vector<Gate*>>
             get_gate_chain(Gate* start_gate, const std::vector<const GatePin*>& input_pins, const std::vector<const GatePin*>& output_pins, const std::function<bool(const Gate*)>& filter)
         {

src/python_bindings/bindings/netlist_utils.cpp

@@ -401,6 +401,37 @@ namespace hal
             :rtype: bool
         )");
 
+        py_netlist_utils.def(
+            "find_carry_chains",
+            [](const Netlist* nl, const std::string input_pin, const std::string output_pin)
+                -> std::vector<std::vector<Gate*>> {
+                auto res = netlist_utils::find_carry_chains(nl, input_pin, output_pin);
+                if (res.is_ok())
+                {
+                    return res.get();
+                }
+                else
+                {
+                    log_error("python_context", "error encountered while detecting gate chain:\n{}", res.get_error().get());
+                    return {};
+                }
+            },
+            py::arg("nl"),
+            py::arg("input_pin")  = std::string(),
+            py::arg("output_pin") = std::string(),
+            R"(
+            Identify carry chains in a given netlist. The user has to provide the input pin of the carry
+            gates and output pin that will go into the subsequent gate.
+            Note that this function relies on having annotated carry gates in the netlist to work.
+         
+
+            :param hal_py.Netlist nl: The netlist to detect the carry chains in.
+            :param list[hal_py.GatePin] input_pin: The input through which the gates must be connected.
+            :param set[hal_py.GatePin] output_pin: The output through which the gates must be connected.
+            @returns A vector of vector of gates that form a chain on success, an error otherwise.
+            :rtype: list[list[hal_py.Gate]]
+        )");
+
         py_netlist_utils.def(
             "get_gate_chain",
             [](Gate* start_gate, const std::vector<const GatePin*>& input_pins = {}, const std::vector<const GatePin*>& output_pins = {}, const std::function<bool(const Gate*)>& filter = nullptr)