vpr: utils: add second variant of primitive_type_feasible() check

Signed-off-by: Pawel Czarnecki <pczarnecki@antmicro.com>

Author: lpawelcz

vpr/src/util/vpr_utils.cpp

@@ -905,6 +905,92 @@ bool primitive_type_feasible(const AtomBlockId blk_id, const t_pb_type* cur_pb_t
     //Feasible
     return true;
 }
+bool primitive_type_feasible(const AtomBlockId blk_id, t_pb_graph_node* curr_pb_graph_node) {
+    t_pb_type* cur_pb_type = curr_pb_graph_node->pb_type;
+
+    if (cur_pb_type == nullptr) {
+        return false;
+    }
+
+    auto& atom_ctx = g_vpr_ctx.atom();
+    if (cur_pb_type->model != atom_ctx.nlist.block_model(blk_id)) {
+        if ((strcmp(atom_ctx.nlist.block_model(blk_id)->name, MODEL_LATCH) == 0) &&
+            (strcmp(atom_ctx.nlist.block_model(blk_id)->name, cur_pb_type->model->name) == 0)) {
+           /**
+            * Special case for .latch: this model exists in 2 variations which are
+            * defined one after another in linked list, check if the second variant match
+            */
+
+            if (cur_pb_type->model->next == atom_ctx.nlist.block_model(blk_id) && atom_ctx.nlist.block_model(blk_id)->inputs[1].trigg_edge == TriggeringEdge::FALLING_EDGE) {
+                //Next primitive match atom - add secondary references
+                if (!curr_pb_graph_node->has_secondary)
+                        curr_pb_graph_node->update_pins();
+            } else {
+                //Next primitive and atom do not match
+                return false;
+            }
+        } else {
+          //Primitive and atom do not match
+          return false;
+        }
+    }
+
+    VTR_ASSERT_MSG(atom_ctx.nlist.is_compressed(), "This function assumes a compressed/non-dirty netlist");
+
+    //Keep track of how many atom ports were checked.
+    //
+    //We need to do this since we iterate over the pb's ports and
+    //may miss some atom ports if there is a mismatch
+    size_t checked_ports = 0;
+
+    //Look at each port on the pb and find the associated port on the
+    //atom. To be feasible the pb must have as many pins on each port
+    //as the atom requires
+    for (int iport = 0; iport < cur_pb_type->num_ports; ++iport) {
+        t_port* pb_port;
+        if(curr_pb_graph_node->has_secondary)
+                pb_port = &cur_pb_type->ports_sec[iport];
+        else
+                pb_port = &cur_pb_type->ports[iport];
+
+        const t_model_ports* pb_model_port = pb_port->model_port;
+
+        //Find the matching port on the atom
+        auto port_id = atom_ctx.nlist.find_atom_port(blk_id, pb_model_port);
+
+        if (port_id) { //Port is used by the atom
+
+            //In compressed form the atom netlist stores only in-use pins,
+            //so we can query the number of required pins directly
+            int required_atom_pins = atom_ctx.nlist.port_pins(port_id).size();
+
+            int available_pb_pins = pb_port->num_pins;
+
+            if (available_pb_pins < required_atom_pins) {
+                //Too many pins required
+                return false;
+            }
+
+            //Note that this port was checked
+            ++checked_ports;
+        }
+    }
+
+    //Similarly to pins, only in-use ports are stored in the compressed
+    //atom netlist, so we can figure out how many ports should have been
+    //checked directly
+    size_t atom_ports = atom_ctx.nlist.block_ports(blk_id).size();
+
+    //See if all the atom ports were checked
+    if (checked_ports != atom_ports) {
+        VTR_ASSERT(checked_ports < atom_ports);
+        //Required atom port was missing from physical primitive
+        return false;
+    }
+
+    //Feasible
+    return true;
+}
 
 //Returns the sibling atom of a memory slice pb
 //  Note that the pb must be part of a MEMORY_CLASS

vpr/src/util/vpr_utils.h

@@ -109,6 +109,7 @@ int get_max_primitives_in_pb_type(t_pb_type* pb_type);
 int get_max_depth_of_pb_type(t_pb_type* pb_type);
 int get_max_nets_in_pb_type(const t_pb_type* pb_type);
 bool primitive_type_feasible(AtomBlockId blk_id, const t_pb_type* cur_pb_type);
+bool primitive_type_feasible(AtomBlockId blk_id, t_pb_graph_node* curr_pb_graph_node);
 t_pb_graph_pin* get_pb_graph_node_pin_from_model_port_pin(const t_model_ports* model_port, const int model_pin, const t_pb_graph_node* pb_graph_node);
 const t_pb_graph_pin* find_pb_graph_pin(const AtomNetlist& netlist, const AtomLookup& netlist_lookup, const AtomPinId pin_id);
 t_pb_graph_pin* get_pb_graph_node_pin_from_block_pin(ClusterBlockId iblock, int ipin);