Skip to content

[Pack] Removed Pb Pin Scratchpad #3333

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Nov 5, 2025
Merged

[Pack] Removed Pb Pin Scratchpad #3333

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
4adac46
[Pack] Removed Pb Pin Scratchpad
AlexandreSinger Nov 4, 2025
faf6813
[Pack] Added Comments for Map Lookups
AlexandreSinger Nov 5, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 0 additions & 2 deletions libs/libarchfpga/src/physical_types.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1388,8 +1388,6 @@ class t_pb_graph_pin {
t_pb_graph_node* parent_node = nullptr;
int pin_count_in_cluster = 0;

int scratch_pad = 0; /* temporary data structure useful to store traversal info */

enum e_pb_graph_pin_type type = PB_PIN_NORMAL; /* The type of this pin (sequential, i/o etc.) */

/* sequential timing information */
Expand Down
120 changes: 56 additions & 64 deletions vpr/src/pack/cluster_feasibility_filter.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -27,13 +27,14 @@
* Date: May 16, 2012
*/

#include <unordered_map>
#include <unordered_set>
#include <vector>
#include "physical_types.h"
#include "vtr_assert.h"
#include "vtr_log.h"
#include "vpr_types.h"

#include "hash.h"
#include "cluster_feasibility_filter.h"

/* header functions that identify pin classes */
Expand All @@ -42,18 +43,21 @@ static int get_max_depth_of_pb_graph_node(const t_pb_graph_node* pb_graph_node);
static void load_pin_class_by_depth(t_pb_graph_node* pb_graph_node,
const int depth,
int* input_count,
int* output_count);
int* output_count,
std::unordered_map<t_pb_graph_pin*, int>& pin_marker);
static void load_list_of_connectable_input_pin_ptrs(t_pb_graph_node* pb_graph_node);
static void expand_pb_graph_node_and_load_output_to_input_connections(t_pb_graph_pin* current_pb_graph_pin,
t_pb_graph_pin* reference_pin,
const int depth);
static void unmark_fanout_intermediate_nodes(t_pb_graph_pin* current_pb_graph_pin);
static void reset_pin_class_scratch_pad_rec(t_pb_graph_node* pb_graph_node);
const int depth,
std::unordered_set<t_pb_graph_pin*>& seen_pins);
static void unmark_fanout_intermediate_nodes(t_pb_graph_pin* current_pb_graph_pin,
std::unordered_set<t_pb_graph_pin*>& seen_pins);
static void expand_pb_graph_node_and_load_pin_class_by_depth(t_pb_graph_pin* current_pb_graph_pin,
const t_pb_graph_pin* reference_pb_graph_pin,
const int depth,
int* input_count,
int* output_count);
int* output_count,
std::unordered_map<t_pb_graph_pin*, int>& pin_marker);
static void sum_pin_class(t_pb_graph_node* pb_graph_node);

static void discover_all_forced_connections(t_pb_graph_node* pb_graph_node);
Expand All @@ -72,12 +76,13 @@ void load_pin_classes_in_pb_graph_head(t_pb_graph_node* pb_graph_node) {
depth = get_max_depth_of_pb_graph_node(pb_graph_node);
for (i = 0; i < depth; i++) {
input_count = output_count = 0;
reset_pin_class_scratch_pad_rec(pb_graph_node);
load_pin_class_by_depth(pb_graph_node, i, &input_count, &output_count);
// The following function marks pins based on the pin count. This is
// used when traversing the pb heirarchy.
std::unordered_map<t_pb_graph_pin*, int> pin_marker;
load_pin_class_by_depth(pb_graph_node, i, &input_count, &output_count, pin_marker);
}

/* Load internal output-to-input connections within each cluster */
reset_pin_class_scratch_pad_rec(pb_graph_node);
load_list_of_connectable_input_pin_ptrs(pb_graph_node);
discover_all_forced_connections(pb_graph_node);
}
Expand Down Expand Up @@ -156,39 +161,12 @@ static int get_max_depth_of_pb_graph_node(const t_pb_graph_node* pb_graph_node)
return max_depth;
}

static void reset_pin_class_scratch_pad_rec(t_pb_graph_node* pb_graph_node) {
int i, j, k;

for (i = 0; i < pb_graph_node->num_input_ports; i++) {
for (j = 0; j < pb_graph_node->num_input_pins[i]; j++) {
pb_graph_node->input_pins[i][j].scratch_pad = UNDEFINED;
}
}
for (i = 0; i < pb_graph_node->num_output_ports; i++) {
for (j = 0; j < pb_graph_node->num_output_pins[i]; j++) {
pb_graph_node->output_pins[i][j].scratch_pad = UNDEFINED;
}
}
for (i = 0; i < pb_graph_node->num_clock_ports; i++) {
for (j = 0; j < pb_graph_node->num_clock_pins[i]; j++) {
pb_graph_node->clock_pins[i][j].scratch_pad = UNDEFINED;
}
}

for (i = 0; i < pb_graph_node->pb_type->num_modes; i++) {
for (j = 0; j < pb_graph_node->pb_type->modes[i].num_pb_type_children; j++) {
for (k = 0; k < pb_graph_node->pb_type->modes[i].pb_type_children[j].num_pb; k++) {
reset_pin_class_scratch_pad_rec(&pb_graph_node->child_pb_graph_nodes[i][j][k]);
}
}
}
}

/* load pin class based on limited depth */
static void load_pin_class_by_depth(t_pb_graph_node* pb_graph_node,
const int depth,
int* input_count,
int* output_count) {
int* output_count,
std::unordered_map<t_pb_graph_pin*, int>& pin_marker) {
int i, j, k;

if (pb_graph_node->is_primitive()) {
Expand All @@ -199,7 +177,8 @@ static void load_pin_class_by_depth(t_pb_graph_node* pb_graph_node,
if (pb_graph_node->input_pins[i][j].parent_pin_class[depth] == UNDEFINED) {
expand_pb_graph_node_and_load_pin_class_by_depth(&pb_graph_node->input_pins[i][j],
&pb_graph_node->input_pins[i][j], depth,
input_count, output_count);
input_count, output_count,
pin_marker);
(*input_count)++;
}
}
Expand All @@ -209,7 +188,8 @@ static void load_pin_class_by_depth(t_pb_graph_node* pb_graph_node,
if (pb_graph_node->output_pins[i][j].parent_pin_class[depth] == UNDEFINED) {
expand_pb_graph_node_and_load_pin_class_by_depth(&pb_graph_node->output_pins[i][j],
&pb_graph_node->output_pins[i][j], depth,
input_count, output_count);
input_count, output_count,
pin_marker);
(*output_count)++;
}
}
Expand All @@ -219,7 +199,8 @@ static void load_pin_class_by_depth(t_pb_graph_node* pb_graph_node,
if (pb_graph_node->clock_pins[i][j].parent_pin_class[depth] == UNDEFINED) {
expand_pb_graph_node_and_load_pin_class_by_depth(&pb_graph_node->clock_pins[i][j],
&pb_graph_node->clock_pins[i][j], depth,
input_count, output_count);
input_count, output_count,
pin_marker);
(*input_count)++;
}
}
Expand Down Expand Up @@ -253,7 +234,7 @@ static void load_pin_class_by_depth(t_pb_graph_node* pb_graph_node,
for (j = 0; j < pb_graph_node->pb_type->modes[i].num_pb_type_children; j++) {
for (k = 0; k < pb_graph_node->pb_type->modes[i].pb_type_children[j].num_pb; k++) {
load_pin_class_by_depth(&pb_graph_node->child_pb_graph_nodes[i][j][k], depth,
input_count, output_count);
input_count, output_count, pin_marker);
}
}
}
Expand All @@ -278,14 +259,20 @@ static void load_pin_class_by_depth(t_pb_graph_node* pb_graph_node,
static void load_list_of_connectable_input_pin_ptrs(t_pb_graph_node* pb_graph_node) {
int i, j, k;

// We keep track of the pins we have already seen when expanding the pb
// graph.
std::unordered_set<t_pb_graph_pin*> seen_pins;

if (pb_graph_node->is_primitive()) {
/* If this is a primitive, discover what input pins the output pins can connect to */
for (i = 0; i < pb_graph_node->num_output_ports; i++) {
for (j = 0; j < pb_graph_node->num_output_pins[i]; j++) {
for (k = 0; k < pb_graph_node->pb_type->depth; k++) {
expand_pb_graph_node_and_load_output_to_input_connections(&pb_graph_node->output_pins[i][j],
&pb_graph_node->output_pins[i][j], k);
unmark_fanout_intermediate_nodes(&pb_graph_node->output_pins[i][j]);
&pb_graph_node->output_pins[i][j], k,
seen_pins);
unmark_fanout_intermediate_nodes(&pb_graph_node->output_pins[i][j],
seen_pins);
}
}
}
Expand All @@ -305,16 +292,18 @@ static void load_list_of_connectable_input_pin_ptrs(t_pb_graph_node* pb_graph_no
*/
static void expand_pb_graph_node_and_load_output_to_input_connections(t_pb_graph_pin* current_pb_graph_pin,
t_pb_graph_pin* reference_pin,
const int depth) {
const int depth,
std::unordered_set<t_pb_graph_pin*>& seen_pins) {
int i;

if (current_pb_graph_pin->scratch_pad == UNDEFINED
if (seen_pins.count(current_pb_graph_pin) == 0
&& current_pb_graph_pin->parent_node->pb_type->depth > depth) {
current_pb_graph_pin->scratch_pad = 1;
seen_pins.insert(current_pb_graph_pin);
for (i = 0; i < current_pb_graph_pin->num_output_edges; i++) {
VTR_ASSERT(current_pb_graph_pin->output_edges[i]->num_output_pins == 1);
expand_pb_graph_node_and_load_output_to_input_connections(current_pb_graph_pin->output_edges[i]->output_pins[0],
reference_pin, depth);
reference_pin, depth,
seen_pins);
}
if (current_pb_graph_pin->is_primitive_pin()
&& current_pb_graph_pin->port->type == IN_PORT) {
Expand Down Expand Up @@ -343,15 +332,17 @@ static void expand_pb_graph_node_and_load_output_to_input_connections(t_pb_graph
}

/**
* Clear scratch_pad for all fanout of pin
* Mark all fanout of pin as un-seen.
*/
static void unmark_fanout_intermediate_nodes(t_pb_graph_pin* current_pb_graph_pin) {
static void unmark_fanout_intermediate_nodes(t_pb_graph_pin* current_pb_graph_pin,
std::unordered_set<t_pb_graph_pin*>& seen_pins) {
int i;
if (current_pb_graph_pin->scratch_pad != UNDEFINED) {
current_pb_graph_pin->scratch_pad = UNDEFINED;
if (seen_pins.count(current_pb_graph_pin) != 0) {
seen_pins.erase(current_pb_graph_pin);
for (i = 0; i < current_pb_graph_pin->num_output_edges; i++) {
VTR_ASSERT(current_pb_graph_pin->output_edges[i]->num_output_pins == 1);
unmark_fanout_intermediate_nodes(current_pb_graph_pin->output_edges[i]->output_pins[0]);
unmark_fanout_intermediate_nodes(current_pb_graph_pin->output_edges[i]->output_pins[0],
seen_pins);
}
}
}
Expand All @@ -363,7 +354,8 @@ static void expand_pb_graph_node_and_load_pin_class_by_depth(t_pb_graph_pin* cur
const t_pb_graph_pin* reference_pb_graph_pin,
const int depth,
int* input_count,
int* output_count) {
int* output_count,
std::unordered_map<t_pb_graph_pin*, int>& pin_marker) {
int i;
int marker;
int active_pin_class;
Expand All @@ -378,9 +370,9 @@ static void expand_pb_graph_node_and_load_pin_class_by_depth(t_pb_graph_pin* cur
VTR_ASSERT(reference_pb_graph_pin->is_primitive_pin());
VTR_ASSERT(current_pb_graph_pin->parent_node->pb_type->depth >= depth);
VTR_ASSERT(current_pb_graph_pin->port->type != INOUT_PORT);
if (current_pb_graph_pin->scratch_pad != marker) {
if (pin_marker.count(current_pb_graph_pin) == 0 || pin_marker[current_pb_graph_pin] != marker) {
if (current_pb_graph_pin->is_primitive_pin()) {
current_pb_graph_pin->scratch_pad = marker;
pin_marker[current_pb_graph_pin] = marker;
/* This is a primitive, determine what pins cans share the same pin class as the reference pin */
if (current_pb_graph_pin->parent_pin_class[depth] == UNDEFINED
&& reference_pb_graph_pin->port->is_clock == current_pb_graph_pin->port->is_clock
Expand All @@ -391,16 +383,16 @@ static void expand_pb_graph_node_and_load_pin_class_by_depth(t_pb_graph_pin* cur
VTR_ASSERT(current_pb_graph_pin->input_edges[i]->num_input_pins == 1);
expand_pb_graph_node_and_load_pin_class_by_depth(current_pb_graph_pin->input_edges[i]->input_pins[0],
reference_pb_graph_pin, depth, input_count,
output_count);
output_count, pin_marker);
}
for (i = 0; i < current_pb_graph_pin->num_output_edges; i++) {
VTR_ASSERT(current_pb_graph_pin->output_edges[i]->num_output_pins == 1);
expand_pb_graph_node_and_load_pin_class_by_depth(current_pb_graph_pin->output_edges[i]->output_pins[0],
reference_pb_graph_pin, depth, input_count,
output_count);
output_count, pin_marker);
}
} else if (current_pb_graph_pin->parent_node->pb_type->depth == depth) {
current_pb_graph_pin->scratch_pad = marker;
pin_marker[current_pb_graph_pin] = marker;
if (current_pb_graph_pin->port->type == OUT_PORT) {
if (reference_pb_graph_pin->port->type == OUT_PORT) {
/* This cluster's output pin can be driven by primitive outputs belonging to this pin class */
Expand All @@ -410,7 +402,7 @@ static void expand_pb_graph_node_and_load_pin_class_by_depth(t_pb_graph_pin* cur
VTR_ASSERT(current_pb_graph_pin->input_edges[i]->num_input_pins == 1);
expand_pb_graph_node_and_load_pin_class_by_depth(current_pb_graph_pin->input_edges[i]->input_pins[0],
reference_pb_graph_pin, depth, input_count,
output_count);
output_count, pin_marker);
}
}
if (current_pb_graph_pin->port->type == IN_PORT) {
Expand All @@ -422,23 +414,23 @@ static void expand_pb_graph_node_and_load_pin_class_by_depth(t_pb_graph_pin* cur
VTR_ASSERT(current_pb_graph_pin->output_edges[i]->num_output_pins == 1);
expand_pb_graph_node_and_load_pin_class_by_depth(current_pb_graph_pin->output_edges[i]->output_pins[0],
reference_pb_graph_pin, depth, input_count,
output_count);
output_count, pin_marker);
}
}
} else if (current_pb_graph_pin->parent_node->pb_type->depth > depth) {
/* Inside an intermediate cluster, traverse to either a primitive or to the cluster we're interested in populating */
current_pb_graph_pin->scratch_pad = marker;
pin_marker[current_pb_graph_pin] = marker;
for (i = 0; i < current_pb_graph_pin->num_input_edges; i++) {
VTR_ASSERT(current_pb_graph_pin->input_edges[i]->num_input_pins == 1);
expand_pb_graph_node_and_load_pin_class_by_depth(current_pb_graph_pin->input_edges[i]->input_pins[0],
reference_pb_graph_pin, depth, input_count,
output_count);
output_count, pin_marker);
}
for (i = 0; i < current_pb_graph_pin->num_output_edges; i++) {
VTR_ASSERT(current_pb_graph_pin->output_edges[i]->num_output_pins == 1);
expand_pb_graph_node_and_load_pin_class_by_depth(current_pb_graph_pin->output_edges[i]->output_pins[0],
reference_pb_graph_pin, depth, input_count,
output_count);
output_count, pin_marker);
}
}
}
Expand Down