A Novel Global Routing Algorithm for Printed Circuit Boards Based on Triangular Grid

Abstract

Global routing plays a crucial role in printed circuit board (PCB) design and affects the cost of the design significantly. Conventional methods based on rectangular grids have some limitations, whereas this paper introduces a new algorithm that employs a triangular grid model, which offers a more efficient solution to the problem. Firstly, we present a technique to sort all unconnected two-pin nets. Next, a triangular grid graph is constructed to represent the routing resources on the printed circuit board. Finally, we use the concept of maximum flow to identify the paths for global routing and apply detailed routing for the completion of wires. Results from experiments demonstrate that our algorithm is faster than two state-of-the-art routers and does not have any design rule violations for all industrial PCB instances.

1. Introduction

Printed circuit boards (PCBs) are widely used in various fields due to their small size and light weight. As integrated circuits continue to develop on a larger scale and electronic products require more complex functions, the number of pins on PCBs has significantly increased. Manual design methods alone can no longer meet market demands, leading to the emergence of Electronic Design Automation (EDA). EDA tools efficiently find reasonable solutions for complex circuits, reducing labor and cost while improving design efficiency and production processes, making them popular among many enterprises.

Routing is the most crucial process in PCB design, but it is both time-consuming and challenging. It directly impacts the performance of the entire circuit system and can be divided into two parts: global routing and detailed routing. Global routing plans the approximate routing path for each net, reducing the complexity of the routing problem and laying the foundation for detailed routing. Detailed routing calculates the final routing path based on the results of preliminary global routing planning. The key problems in global routing algorithms are how to reduce algorithm running time and how to improve the utilization of routing space.

1.1. Previous Works

In the field of integrated circuits (ICs), the global routing problem [1] can be modeled as a grid graph $G(V,E)$, where each vertex $v_i$ corresponds to a rectangular area of the chip, referred to as the global routing cell (G-cell). If G-cell i and G-cell j are adjacent, then we construct an edge $e_{ij}$, as illustrated in Figure 1. A maximum wiring resource $m_{ij}$ is assigned to each edge $e_{ij}$. The goal of global routing is to find a path through $G(V,E)$ that connects the pins in G-cells for each net.

In recent years, several high-quality global routers have been developed to solve this problem. FastRoute 4.0 [2] and NTHU-Route 2.0 [3] focus on generating routing paths on a grid graph with a given edge capacity. They employ the ripping-up and rerouting techniques to obtain overflow-minimized solutions. BoxRouter [4] uses a minimum Steiner tree to decompose multi-pin nets into two-pin nets and applies integer programming to find routes for nets in a routing region. VFGR [5] and SPRouter [6] utilize parallelization techniques to handle congestion effectively.

Given that modern integrated circuits and chips frequently comprise multi-layered structures, CUGR [7] operates directly on the 3D grid graph. Conversely, COALA [8] employs a strategy of 2D global routing followed by layer assignment. These approaches cater to the complexities of contemporary IC designs and contribute to the advancement of efficient global routing algorithms.

The differences between PCB global routing and integrated circuit global routing are notable. In PCB global routing, initial topological bus routes are created by routing buses on a single layer that encompasses the routing resources of all routing layers. To encompass all routing resources on the circuit board, Wong et al. [9] proposed the utilization of the data structure of the Hanan grid and dynamic routing graph. The Hanan grid is formed from the components by extending their boundaries until they intersect with other components or the board boundaries. Both the board and its components are represented by bounding boxes. The dynamic routing graph features vertices that represent the middle points of all Hanan grid edges, with its edges connecting vertices within the same cell. When an edge is occupied by a bus, the cell is divided into two parts, leading to the creation of new vertices and edges, as illustrated in Figure 2. However, it is worth noting that this method incurs high time and space costs. Processing a few hundred nets can take several tens of minutes. Furthermore, unordered routing may intensify the complexity and impact the routing quality. As a result, Lin et al. [10] proposed a concurrent hierarchical SER method, which incorporates both escape and area routing to compensate for the absence of unordered escape routing.

In the final phase of the routing process, detailed routing is conducted to establish the specific wires on the board that fulfill the requirements of industrial production based on the outcomes of global routing. During this stage, designers must account for the boundaries of actual obstacles, wire width, spacing between wires and obstacles, and the wire topology. Detailed routing has been the subject of extensive research, including investigations by Yan and Chen [11], who devised length-matching paths for obstacle-aware bus routing. Ozdal et al. [12,13] used a Lagrangian relaxation (LR) framework to allocate extra routing resources around nets simultaneously. Kim et al. [14] introduced a compact topology-aware bus routing approach capable of synthesizing the routing topology of the bus while minimizing design rule violations in designs with high bus density and track utilization. Chen et al. [15] proposed a maze routing method to address non-uniform track resources using a concurrent and hierarchical scheme for buses, whereas Hsu et al. [16] applied a directed acyclic graph (DAG)-based algorithm to connect buses and alleviate routing congestion through rip-up and rerouting. Additionally, Zhang et al. [17] introduced the concept of topological Boolean satisfiability to verify the legality of a segment during the detailed routing stage and determine the existence of feasible bit ordering. Finally, Merrill et al. [18] put forward a novel algorithm capable of managing multiple real-world, intricate constraints such as differential-pair couple routing constraints, pad entry constraints, and more to facilitate printed circuit board routing and generate high-quality, manufacturable layouts.

1.2. Our Contributions

In response to the 135-degree routing requirements of PCBs, the efficiency of routing methods based on rectangular grid graphs, including Hanan graphs, needs to be further improved. Therefore, we propose an efficient global routing method based on triangular construction. The main contributions of this paper are summarized as follows:

• A new global routing algorithm for PCB is proposed. It does not use the conventional rectangular grid but uses the triangular grid data structure to obtain all the routing resources on the circuit board.
• We propose a decomposition ordering algorithm which prioritizes the connection between important components and nets to reduce the degree of local congestion, and we obtain a better global routing result.
• We put forward the idea of using the maximum flow to find the path and increase the speed of searching.
• Experimental results show that our algorithm has excellent performance in running speed and routing result, while the other two state-of-the-art routers spend more time and violate some constraints.

The remainder of this paper is organized as follows. Section 2 introduces some related terms and routing design rules for PCBs and formulates the addressed problem. Section 3 details the core techniques of our algorithm. Experimental results are shown in Section 4. Finally, Section 5 concludes our work.

2. Preliminaries

In this section, we introduce the basics of the maximum flow model, provide the formal definition of the PCB global routing problem, and explain the relevant terms and routing design rules associated with our problem.

2.1. Maximum Flow Model

Our problem involves a directed graph $G(V,E)$, where each edge $(v_i,v_j)\in E$ has a non-negative capacity $c(v_i,v_j)\ge 0$. There is only one source point $v_s$ and one sink point $v_t$, with other vertices on a path between $v_s$ and $v_t$, which is referred to as a flow network. The flow from vertex $v_i$ to vertex $v_j$ is denoted by $f(v_i,v_j)$. The objective of the maximum flow problem is to find a flow that maximizes its value, $v\left(f\right)$, and satisfies the following conditions [19]:

$$0\le f(v_i,v_j)\le c(v_i,v_j)$$

(1)

$$\sum f(v_i,v_j)-\sum f(v_j,v_i)=\left\{\begin{array}{cc}v\left(f\right),\hfill & i=s\hfill \\ 0,\hfill & i\ne s,t\hfill \\ -v\left(f\right),\hfill & i=t\hfill \end{array}\right.$$

(2)

Let $\mu$ be a path from $v_s$ to $v_t$. A forward arc ${\mu }^{+}$ is in the same direction as the path and a backward arc ${\mu }^{-}$ is in the opposite direction to the path. If $\mu$ satisfies [19]:

$$\left\{\begin{array}{cc}0\le f(v_i,v_j)<c(v_i,v_j),\hfill & (v_i,v_j)\in {\mu }^{+}\hfill \\ 0<f(v_i,v_j)\le c(v_i,v_j),\hfill & (v_i,v_j)\in {\mu }^{-}\hfill \end{array}\right.$$

(3)

it is called an augmenting path. Given a cut set $(V_1,\overline{V_1})$, the sum of $(V_1,\overline{V_1})$ is called the capacity of this cut set, i.e.,

$$c(V_1,\overline{V_1})=\sum _{(v_i,v_j)\in (V_1,\overline{V_1})}^{}c(v_i,v_j)$$

(4)

and $v\left(f\right)\le c(V_1,\overline{V_1})$. In the flow network G, if $f^{*}$ is a maximal flow, then there is no augmenting path with respect to it, and the value $v\left(f^{*}\right)$ of the flow starting with $v_s$ and ending with $v_t$ is equal to the capacity of the minimal cut set separating $v_s$ and $v_t$. According to this theorem, the Ford–Fulkerson algorithm [19] is a well-known iterative algorithm to solve the max-flow problem, which is a special linear programming problem, and it is an iterative method. In the beginning, $f(u,v)=0$ for all $u,v\in V$, that is, the value of the flows in the network are 0 in the initial state. In each iteration, the flow value can be increased by finding an augmenting path, along which more flows can be pressed. This process is repeated until all the augmenting paths are found.

2.2. Routing Design Rules

In this paper, we aim to simplify the design process while ensuring better manufacturability. To achieve this, our algorithm must accommodate multiple routing design rules. Our problem involves four major design rules, which are detailed below:

• Non-crossing constraint: Net crossing is not permitted on the same layer.
• Wire width and spacing constraint: Each wire has its own width, and there are specific spacing requirements that must be adhered to between wires, obstacles and other elements.
• Routing angle constraint: Our algorithm allows for routing angles of 135 degrees between two tracks, while routing angles of 45 degrees are prohibited. Additionally, routed nets entering a pad must not introduce an acute angle between each other (see Figure 3).
• Topology matching constraint: Multiple wires should try to meet the same topology structure. This involves four considerations: (1) they should have the same number of segments, (2) they should go through the same layer, (3) they should be routed in the same direction, and (4) the order of each segment should be the same or opposite to the starting order. Topology failures are illustrated in Figure 4.

2.3. Problem Formulation

Given a set of items such as pads, vias, tracks, a netlist N, and routing design rules, we connect all the nets $n_i\in N$ so that there are no design rule violations.

3. Algorithms

In this section, we present our routing algorithm. Figure 5 summarizes our algorithm flow, which consists of four major stages. The algorithm flow comprises four primary stages. Firstly, we begin by decomposing all multi-pin nets into two-pin nets, utilizing the information obtained from the PCB. This step facilitates the subsequent process of connecting all the nets comprehensively, thus enhancing the overall routability of the design.

Following that, we establish a routing order to determine the sequence in which the nets will be connected. This step is essential for efficient routing. Subsequently, we construct a triangular grid graph and carefully select the starting and ending points that are crucial for the max-flow pathfinding process. This ensures an approximately optimal pathfinding solution.

Lastly, once all the unconnected nets have been planned, we proceed with the detailed routing phase to achieve the final routing result. This stage involves meticulous attention to detail in order to maximize the effectiveness and reliability of the routing process.

3.1. Multi-Pin Nets Decomposition

The shortest path problem for two-pin nets is one of the fundamental challenges in PCB routing. It involves finding the shortest routing path between two pins, taking into account any obstacles present on the PCB. However, in practical routing scenarios, nets often comprise more than just two pins. To address this issue, a common approach is to decompose multi-pin nets into a series of two-pin nets.

The first step in this decomposition process is to view all the pins within a multi-pin net as individual points and apply the Delaunay triangulation [20]. This method maximizes the sum of the interior angles of all generated triangles while avoiding the creation of highly acute triangles (refer to Figure 6b).

Next, the Kruskal algorithm is used to construct the minimum spanning tree (MST) for all the points which have a lower complexity compared to the minimal Steiner tree. In this tree, the weight of each edge corresponds to the distance between the two points (refer to Figure 6c).

Finally, any connections that violate the set rules are removed, for example, two connected pins are not allowed to connect within the same component, or one pin should not have more than one connection, resulting in the generation of the required two-pin nets.

The time complexity of the Delaunay triangulation construction is $O\left(plogp\right)$[20], where p is the number of pins. The complexity of constructing the minimum spanning tree is $O\left(plogp\right)$. Therefore, the complexity of multi-pin nets decomposition is $O\left(plogp\right)$.

3.2. Route Ordering

The routing order has an important effect on the quality of the routing, so we propose an algorithm to determine the routing order in this section. Note that the overall connection relationship on a PCB can be quite complex, with potentially numerous connections between each component. To address this issue, we can consider a hypothetical scenario where the PCB predominantly consists of larger components that are connected to smaller ones. Additionally, there exists a definite connection relationship between these larger components, forming a composite star topology. The basic idea behind the Comp-Star algorithm for sequencing involves decomposing the routing graph into smaller components, routing the pin pairs within these smaller components first, connecting the small components to the larger ones, and finally, establishing connections between the larger components themselves.

It is worth noting that this problem can be classified as a vertex cover problem, which is known to be NP-complete. As a result, finding an optimal solution in deterministic polynomial time is challenging. Nonetheless, there are several approximate algorithms available that can identify the minimum value of vertex coverage in a given undirected graph. One such algorithm is the 2-approximation algorithm, which can be utilized to find a vertex cover set that is at most twice the size of the optimal vertex cover. As illustrated in Figure 7, the first step involves constructing the connection graph $G_C$ using the components as vertices. These components can be in the form of pads, vias, or complex footprints. An edge in the graph represents a connection between two components, with at least one net linking them. The weight assigned to each edge corresponds to the number of nets between the two components. To distinguish the importance of each component, a weight function is defined on the vertex set $V\left(G_C\right)$. This weight function assigns higher priority to components with more nets. For a given vertex $v\in V\left(G_C\right)$, the number of nets containing at least one component pin associated with v is denoted as $\delta \left(v\right)$. The weight function $w:\delta \left(v\right)\to {\mathbb{N}}^{+}$ is defined as follows.

$$w\left(v\right)={\left(\delta \left(v\right)\right)}^{-c_1}-c_2·\delta \left(v\right)+c_3,$$

(5)

where the constants $c_1,c_2,c_3>0$. We consider the minimum-weight vertex cover problem on the graph $(G_C,w)$. Our Comp-Star algorithm applies Bar-Yehuda and Even’s algorithm, which constructs both a primal integral solution and a dual feasible solution simultaneously, without solving either the primal or dual programs. This approach is known as the primal-dual schema and provides a 2-approximation for finding the minimum-weight overlapping cover [21]. The time complexity of the algorithm is $O(m+nlogn)$, where n represents the number of vertices and m represents the number of edges in the graph $G_C$.

Based on the results obtained from Algorithm 1, we are able to identify all the component stars. We select the first component in the queue Q, which is considered the most important, and proceed to route it first. To begin routing, we choose a net that has the shortest distance between two pins within the component. From there, we can either route clockwise or counterclockwise around this net. Once this component has been successfully routed, we move on to the next component in the queue and route its unconnected nets. We continue this process of selecting and routing component stars until the queue Q is empty, thus determining the entire routing order.

Algorithm 1 Comp-Star decomposition

Require: a component graph $G_C$. Ensure: a queue of component stars Q.   1: Set $R=\varnothing ,W=\varnothing ,M=\varnothing$.   2: while  $W\ne E\left(G_C\right)$  do   3:  Pick an edge $uv\in E\left(G_C\right)\setminus W$.   4:  By relabeling, assume $w\left(u\right)\le w\left(v\right)$.   5:  $w\left(v\right)\leftarrow w\left(v\right)-w\left(u\right)$ and $R\leftarrow R\cup \left\{u\right\}$.   6:  Put all edges connected with u as $u{x}_1,u{x}_2,\dots ,u{x}_n$ into W.   7:  for $i=1$ to n do   8:   $M\left(u\right)\leftarrow \left\{u{x}_i\right\}$.   9: Sort R as $u_1,u_2,\dots ,u_{\left|R\right|}$ such that $\delta \left(u_1\right)\ge \dots ,\ge \delta \left(u_{\left|R\right|}\right)$. 10: for $u_i\in R$ do 11:  put all component stars $G_C[\left\{u_i\right\}\cup M\left(u_i\right)]$ into Q. 12:  $G_C\leftarrow G_C-G_C[\left\{u_i\right\}\cup M\left(u_i\right)]$. 13: return Q.

3.3. Global Routing Based on Triangular Grid

In this section, we present a novel global routing algorithm that forms the core of our methodology. By utilizing a triangular grid graph and a maximum flow model, the algorithm efficiently discovers paths for global planning. The algorithm consists of four main stages. In the initial stage, we construct a global triangular grid graph, enabling us to effectively identify and utilize all available routing resources on the PCB. Moving to the second stage, we update the graph based on the determined routing order. In the third stage, we formulate the global routing problem as a maximum flow model. To solve this model, we employ the Edmonds–Karp algorithm [22], which efficiently discovers the global routing.

3.3.1. Triangular Grid Graph Construction

We consider all items on the printed circuit board as vertices in our diagram, including center points of pads, vias or obstacles, boundary vertices, and end points of tracks. These vertices are treated as obstacles, restricting direct passage. We then calculate the Euclidean distance between all pairs of vertices and sort them. Using an R-tree, we add edges to the graph and determine if they intersect with existing edges. Once all edges are constructed, we start from the first edge and traverse all connected vertices to build the first triangular face, and then we repeat this process to locate all triangular faces. We record all vertex, edge, and face relations as $Neigs\left(G\right)$ and construct the triangular grid graph $G(V,E,F)$, where V represents the set of vertices, E represents the set of edges, and F represents the set of faces, as shown in Figure 8.

We choose to use triangles instead of rectangles to reduce model size and simplify construction and calculation. Assuming there is only one pad in each footprint on the printed circuit board and n pads in total, the number of vertices generated in the triangular grid graph is $n+4$. If we were to use a rectangle grid like the Hanan grid, we would need to include even more vertices—totaling over $4n+4$—as we would need to add the vertices of the boundary of each pad’s component. This would result in a great increase in the number of data needed to represent the graph. Furthermore, traversing each cell in the Hanan grid would take significantly longer than in the triangular grid.

3.3.2. Graph Local Modification

Our model not only supports the sequential routing of nets in a given order but also enables the simultaneous routing of multiple nets with adjacent starting and ending points. This is achieved by merging several nets into a super-net. Prior to routing, we must update the area where the starting and ending points are located. Using the triangular grid graph G as a basis, we delete the vertices, edges, and faces where the starting and ending points reside. Then, we construct the smallest rectangular grid that can contain all starting points as the starting face, and the same is performed for the ending face. These rectangular faces are constructed to ensure that the paths are at a 90-degree angle from the starting or ending points, which facilitates subsequent path search and calculations. The remaining vertices are then reconnected to construct a new dynamic updating graph $G_U(V,E,F)$, as shown in Figure 9.

In $G_U$, we can identify edge sequences that represent the gaps and regions that the routing must traverse. Each face in $G_U$ is viewed as a point, and the dual graph $G_U^{\prime }$ of this graph is a flow network, as depicted in Figure 10. In this network, the starting face serves as the source point and the ending face serves as the sink point. The direction of the network is always from the source point to the sink point, and the capacity of the network is defined as the maximum capacity allowed on each edge in $G_U$. Therefore, $G_U$ can also be interpreted as a flow network model, where the vertices of $G_U^{\prime }$ correspond to the faces of $G_U$ and the edges of $G_U^{\prime }$ pass through the edges of $G_U$.

3.3.3. Capacity Definition

In the graph $G_U$, the capacity of all edges should be determined based on the actual boundary of the PCB items corresponding to the vertices, rather than simply calculating the Euclidean distance between the two vertices on the edge. Figure 11 illustrates this concept, where the vertices A and B correspond to rectangular items. We define the left-bottom coordinate and right-top coordinate of their boundary as $lb$ and $rt$, respectively. The horizontal capacity, vertical capacity, and maximum capacity of this edge are denoted as $horCap$, $verCap$, and $maxCap$, respectively, and they can be calculated as follows:

$$horCap=max(0,max(x_B^{lb}-x_A^{rt},x_A^{lb}-x_B^{rt}))$$

(6)

$$verCap=max(0,max(y_B^{lb}-y_A^{rt},y_A^{lb}-y_B^{rt}))$$

(7)

$$maxCap=max(herCap,verCap)$$

(8)

By applying these equations, we can obtain the preliminary capacity of all edges. However, in order to reduce the error, we need to calculate the capacity of edges that do not belong to the starting face and ending face a few more times. This is because there is a relationship among the capacities of each edge in a triangular grid. As shown in Figure 11b, when calculating the capacity $C_e$ of an edge e, we consider the two adjacent triangular grids that share the edge, as well as the other edges a, b, c, and d of these grids. The capacity $C_e$ can be calculated as follows:

$$\left\{\begin{array}{ccc}{C}_e^{\left(n\right)}=\hfill & maxCa{p}_e,\hfill & n=0\hfill \\ \hfill C_e^{\left(n\right)}=& min(C_e^{(n-1)},min(C_a^{(n-1)}+C_b^{(n-1)},\hfill & \\ & C_c^{(n-1)}+C_d^{(n-1)}\left)\right),\hfill & n>0\hfill \end{array}\right.$$

(9)

By incorporating these iterative calculations, the capacity of the entire graph will reflect the actual boundaries of the PCB items more accurately. Consequently, this refined capacity estimation will yield improved results when searching for the maximum flow.

3.3.4. Global Routing Problem Modeling

We have provided the fundamental definition of the maximum flow model in Section 2.1 and introduced our network flow model in Section 3.3.2. Now, we can integrate the current global routing problem into our constructed model. The notation utilized in this section is summarized in

Table 1. Notation description in global routing problem modeling.

Global Routing Problem Modeling
$G_U(V,E,F)$	network flow model
V	the set of all vertices in $G(V,E,F)$
E	the set of all edges in $G(V,E,F)$
F	the set of all faces in $G(V,E,F)$
N	the set of all nets that need to be routed
k	any net that needs to be routed
n	the number of nets that can be routed
$f_k$	the flow value of the net k
$s_k$	the source point of the net k
$d_k$	the sink point of the net k
$(i,j)$	a directed flow from face i to face j
$e^{ij}$	the edge passed through by flow $(i,j)$
$x_k^{e^{ij}}$	whether net k flows through edge $e^{ij}$
$c_k^{e^{ij}}$	the cost of net k on edge $e^{ij}$
$u^{e^{ij}}$	the capacity of edge $e^{ij}$

.

According to the graph $G_U(V,E,F)$, we officially declare the global routing problem to be an integer linear programming (ILP) formulation as follows:

$$min\sum _{i,j\in F,k\in N}{c}_k^{e^{ij}}{x}_k^{e^{ij}}$$

(10)

$$\mathrm{s}.\mathrm{t}.\sum _{k\in N}{x}_k^{e^{s_{k}j}}-\sum _{k\in N}{x}_k^{e^{j{s}_k}}=n,s_k,\forall j\in F$$

(10a)

$$\sum _{k\in N}{x}_k^{e^{d_{k}j}}-\sum _{k\in N}{x}_k^{e^{j{d}_k}}=-n,d_k,\forall j\in F$$

(10b)

$$\sum _{k\in K}{x}_k^{e^{ij}}-\sum _{k\in N}{x}_k^{e^{ji}}=0,\forall i,j\in F,i\ne s_k,d_k$$

(10c)

$$0\le \sum _{i,j\in F,k\in N}{f}_k{x}_k^{e^{ij}}\le u^{e^{ij}}$$

(10d)

$$x_k^{e^{ij}}\in \{0,1\},e^{ij}\in E,k\in N,n\in {\mathbb{N}}^{+}$$

(10e)

We propose a model for computing the optimal flow of nets in a given graph $G_U(N,E,F)$, where each face of the graph represents a possible area for routing the nets. We define directed flows $(i,j)$ as those where i and j correspond to the center points of two faces, and $e^{ij}$ is the edge shared by these faces. The decision variable $x_k^{e_{ij}}$ denotes whether net k flows through the edge $e^{ij}$, and it can only take values of 0 or 1. The objective function (10) aims to minimize the cost of routing nets through the graph, where $c_k^{e^{ij}}$ is the cost of net k on edge $e^{ij}$, typically defined as the distance between i and j.

To ensure a feasible routing solution, we impose four constraints on the model. Constraints (10a) and (10b) ensure that the maximum flow of each net is limited, and the flow must follow the direction from the source $s_k$ to the sink $d_k$. The maximum value of n corresponds to the total number of nets, in order to maximize the total flow. Constraint (10c) guarantees balance between the net flows entering and leaving each vertex, except for the source and sink vertices. This is the most fundamental constraint of the network flow model, ensuring that each net path is continuous from start to end. Finally, constraint (10d) limits the total flow of all nets on each edge, considering their capacity $u^{e^{ij}}$ and the flow value $f_k$ of each net.

Due to the strict constraints and decision variables of the maximum flow problem, solving this ILP problem is NP-hard, requiring enormous time and computational resources. For a medium-sized PCB, the runtime may require several hours [23]. To address this, we apply maximum flow algorithms to more efficiently solve the problem.

3.3.5. Maximum Flow Algorithm Pathfinding

A maximum flow can only be achieved through available edges from the starting face to the ending face. While obtaining the specific value of this maximum flow is not necessary, it is crucial to find all the augmenting paths of the graph. Our algorithm utilizes the Edmond–Karp (EK) algorithm, which employs the Breadth-First Search (BFS) method to locate these paths.

To begin, we use a minimum priority queue Q to store the visited face and its weight, sorting elements from smallest to largest by their weight. We set the starting face and its initial weight value and add it to Q. We then iterate through the elements in the queue, obtaining the current face and continuing to find adjacent faces, updating their weights, and adding them to the queue.

When the face reaches the ending face, we retrace all the visited faces to obtain the result of the augmenting path. Lastly, we update the flow value of all the edges that the path goes through. Each time we search for a net, we find an augmenting path.

Algorithm 2 provides the pseudo-code for our process.

Algorithm 2 Our maximum flow algorithm

Require: the dynamic updating triangular gird graph $G_U(V,E,F)$. Ensure: a triangular grid face augmenting path $P_{result}$.   1: Set minimum priority queue $Q=\varnothing$, the result of path $P_{result}=\varnothing$, all attempt paths $P_{test}=\varnothing$.   2: Set starting face $f_{start}$, ending face $f_{end}$, $Q\leftarrow Q\cup \{<0,f_{start}>\}$, mark the starting face as visited.   3: while  $Q\ne \varnothing$  do   4:  pick the first element $q\in Q,w_{cur}\leftarrow q.first,f_{cur}\leftarrow q.second$.   5:  Obtain all neighbor relations of $f_{cur}:neigs\left(G_U(v,e,f_{cur})\right)$.   6:  for $neig\in neigs$ do   7:   $e_{next}\leftarrow neig.edge,f_{next}\leftarrow neig.face$.   8:   if $CONDITION(e_{next},f_{next})$ then   9:    $w_{next}\leftarrow w_{cur}+w\left(f_{next}\right)$. 10:    $P_{test}\leftarrow P_{test}\cup \{f_{cur}\to f_{next}\}$. 11:    $Q\leftarrow Q\cup <w_{next},f_{next}>$, mark $f_{next}$ as visited. 12:    if $f_{next}=f_{end}$ then 13:     while $f_{cur}\ne f_{start}$ do 14:      Obtain all elements ending with $f_{next}:\{f_{cur}\to f_{next}\}\in P_{test}$. 15:      Update the value of the flow through the edge between $f_{cur}$ and $f_{next}$. 16:      $P_{result}\leftarrow P_{result}\cup \{f_{cur}\to f_{next}\}$. 17:     return $P_{result}$. 18: return not found.

In Algorithm 2, the $CONDITION$ includes several conditions:

• Forward arc condition: The sum of the flow value of an edge and the new flow value cannot exceed the edge’s capacity.
• Backward arc condition: The flow value of an edge cannot be less than the new net cost, i.e., the difference between the flow value and the net cost must be greater than or equal to zero.
• Access condition: This face must not have been visited before.

The correctness of the max-flow algorithm can only be guaranteed if these three conditions are satisfied. The first two conditions are significant as they ensure the existence of augmented paths in the flow network, as discussed in Equation (3). The calculation of the weight $w\left(f_{next}\right)$ is as follows.

$$\begin{array}{c}w\left(pt\right)=c_1·Manhattan(pt,start)+c_2·Manhattan(pt,end)\\ +c_3·Guideline(start{s}_{mid},end{s}_{mid})\end{array}$$

(11)

where $pt, start, end, start{s}_{mid}, end{s}_{mid}$ represent the center of the next face $f_{next}$, the starting point, the ending point, the middle point of all starting points, and the middle point of all ending points, and their coordinates will be added to the calculation. $Manhattan$ is the formula for calculating the Manhattan distance between two points:

$$Manhattan(A,B) = |x_A-x_B| + |y_A-y_B|$$

(12)

The term $Guideline(start{s}_{mid},end{s}_{mid})$ refers to a guide line that connects directly from $start{s}_{mid}$ to $end{s}_{mid}$. This guide line adjusts the weight of the faces it passes through to concentrate all wires in the intermediate region, thereby improving the utilization and routability of the routing area. The constants $c_1,c_2,c_3>0$ also play an important role in determining W. When $c_3\gg c_1,c_2$, the algorithm’s result will be closer to the guide line. On the other hand, if $c_3$ is not much larger than $c_1$ and $c_2$, the algorithm’s result depends more on a heuristic search, which may deviate significantly from the expected outcome and require more time.

The algorithm is called in a loop. Once augmented paths in the form of triangular grids are found for all nets, the flow values on edges of $G_U$ are updated, and the directions of flows passing through all edges roughly follow from the source point to the sink point. The time complexity of the algorithm is $O\left(mn\right)$, where m is the number of nets and n is the number of faces in the graph $G_U$.

3.3.6. Flow Decomposition

We utilize flow decomposition to extract the approximate set of routing paths for each net. This technique enables us to determine the number and direction of flows that can pass through each edge, based on the flow value and previously obtained face paths. In triangular grids, there are only three simple cases of flow direction on each triangular face, as illustrated in Figure 12.

Based on the three aforementioned cases, our triangular grid algorithm has an edge over rectangular ones as it can easily decompose flow. In rectangular grids, the number and direction of flow in each of the four edges make the situations to be discussed more numerous and complicated. To avoid crossing during decomposition, we follow the “same direction principle”. We start by obtaining the first starting point $S_1$, the first ending point $E_1$, and the last ending point $E_n$, and then we obtain a cross product $\overrightarrow{D_1}$:

$$\overrightarrow{D_1}=\overrightarrow{S_1{E}_1}\times \overrightarrow{S_1{E}_n}$$

(13)

In a triangular grid face, we obtain the midpoint $M_{cur}$ of the current edge $e_{cur}$ and the midpoint $M_1,M_2$ on the other two edges $e_1,e_2$ of the face, and we obtain another cross product $\overrightarrow{D_2}$:

$$\overrightarrow{D_2}=\overrightarrow{M_{cur}{M}_1}\times \overrightarrow{M_{cur}{M}_2}$$

(14)

If the directions of $\overrightarrow{D_1}$ and $\overrightarrow{D_2}$ are the same, the situation indicates that vectors $\overrightarrow{S_1{E}_1}$ to $\overrightarrow{S_1{E}_n}$ and $\overrightarrow{M_{cur}{M}_1}$ to $\overrightarrow{M_{cur}{M}_2}$ have been rotated clockwise or counterclockwise in the same direction. We choose to use edge $e_1$ for flow decomposition, and if it is not feasible, edge $e_2$ is chosen. We then subtract the flow value of the chosen edge from the total flow value of the wire which includes the wire width and spacing to ensure that the decomposed path satisfies the constraints. If the flow value of one of the edges is 0, we consider choosing the other edge. We ensure that paths starting from other starting points are as similar as possible to paths that have been in decomposition in turn and there is no crossover. Finally, we obtain the planned paths of all wires, which can be used in future detail routing. These paths are added to the triangular grid graph and partake in the global routing of the rest of the unrouted nets.

3.4. Detail Routing

After the global routing process, the planned path is determined for each unconnected net. To convert these paths into complete wires, various factors need to be taken into account during the detail routing stage. These factors include wire width, spacing, real obstacle boundaries, and achieving a well-structured topology, all while adhering to the rules of routing design.

To achieve this, we propose the construction of an average grid that spans the entire printed circuit board. Each cell in this grid represents the smallest allowable square width on the board. As depicted in Figure 13, when the planned paths are obtained within a triangular grid face, we can project each path onto the average grid. Subsequently, a series of lines are drawn parallel, perpendicular, or intersecting with the grid lines at a ${45}^{\circ }$ angle based on these paths. These lines are then connected sequentially, resulting in a specific wire corresponding to that particular path.

We repeat this adjustment process for the remaining paths, considering the position and direction of the first wire as well as the aforementioned factors, such as calculating the spacing from the first wire and the wire width of the current wire, until all specific wires are calculated and routed accordingly.

4. Experimental Results

We implemented our algorithm using the C++ programming language and conducted all experiments on a single machine equipped with an Intel Core 3.40GHz CPU and 16 GB of memory.

Table 2. Benchmark PCB design statistics.

Designs	$\mathit{W}\times \mathit{H}$ (mm)	$\left|\mathit{P}\right|$	$\left|\mathit{V}\right|$	$\left|\mathit{T}\right|$	$\left|\mathit{N}\right|$
PCB1	33 × 21	16	0	0	8
PCB2	42 × 32	40	30	0	10
PCB3	38 × 38	65	28	14	22
PCB4	48 × 42	100	45	36	35
PCB5	50 × 47	144	81	0	48
PCB6	72 × 58	325	80	198	70
PCB7	91 × 62	520	98	0	92
PCB8	120 × 104	605	103	403	112
PCB9	170 × 170	732	164	1203	140
PCB10	200 × 168	1250	345	785	380

presents the benchmarks for the industry-designed PCBs, where the dimensions of width and height are denoted by “$W\times H$”. “$\left|P\right|$”, “$\left|V\right|$”, “$\left|T\right|$”, and “$\left|N\right|$” denote the numbers of PCB pads, vias, routed tracks, and unrouted nets, respectively.

4.1. Effectiveness of Route Ordering

To evaluate the effectiveness of our proposed route ordering algorithm, we conducted additional experiments comparing the results with and without the ordering method. A summary of the routing results, including routability, runtime, and the total number of design rule violations (DRVs), is presented in

Table 3. Comparison of routing results without ordering and with ordering.

Designs	Without Ordering			With Ordering
	Routability (%)	Runtime (s)	DRVs	Routability (%)	Runtime (s)	DRVs
PCB1	100	0.2	0	100	0.1	0
PCB2	100	0.5	0	100	0.3	0
PCB3	100	2.1	0	100	1.2	0
PCB4	94	4.1	0	100	2.3	0
PCB5	92	8.6	0	100	3.7	0
PCB6	90	21.7	1	100	6.1	0
PCB7	86	40.3	3	100	10.3	0
PCB8	83	89.6	7	100	22.4	0
PCB9	80	162.8	12	99	35.1	0
PCB10	80	432.4	20	98	52.6	0

.

In scenarios where no ordering was applied, there was a significant amount of randomness in the selection of nets to be routed. As a consequence, the starting and ending points of these nets could be widely dispersed, making it impractical to utilize our updated triangular grid graph to combine them as a cohesive flow for global path searching. This resulted in considerable time overhead.

Moreover, due to the poor results from the global routing stage, the specific wires after the detailed routing process could occupy excessive space that could have been utilized by other nets. Furthermore, there were no methods available to mitigate the number of conflicts in the routing space, such as using techniques like rip-up and reroute. Consequently, this led to a decrease in routability and an increase in the number of DRVs.

4.2. Comparison with State-of-the-Art Routers

We compared our algorithm with two state-of-the-art non-academic routers, FreeRouting [24] and Cadance Allegro [25]. FreeRouting is an open-source PCB routing software written in Java that is widely used. Cadence Allegro is a leading commercial tool for PCB design, which is a high-end software in Electronic Design Automation (EDA) tools. We used the default setting for both routers and applied the same input designs and design rules in our experiments. We selected examples where the components were separated from each other to facilitate bus routing, and our algorithm was implemented on other commercial software to clearly demonstrate the routing results.

Table 4. Comparison of routing results between FreeRouting, Allegro, and ours.

Designs	Routability (%)			Runtime (s)			DRVs
	FreeRouting	Allegro	Ours	FreeRouting	Allegro	Ours	FreeRouting	Allegro	Ours
PCB1	100	100	100	8.0	2.0	0.1	0	0	0
PCB2	100	100	100	16.0	4.8	0.3	0	0	0
PCB3	100	100	100	26.9	9.3	1.2	1	0	0
PCB4	100	100	100	36.2	14.1	2.3	3	0	0
PCB5	100	100	100	60.3	22.3	3.7	10	1	0
PCB6	92	100	100	88.6	35.3	6.1	19	3	0
PCB7	88	100	100	125.1	52.8	10.3	31	10	0
PCB8	80	98	100	340.5	80.7	22.4	45	20	0
PCB9	-	96	99	-	170.5	35.1	-	30	0
PCB10	-	-	98	-	-	52.6	-	-	0

summarizes the experimental results by comparing the routability, runtime, and design rule violations (DRVs) of the three routers. A hyphen in the table indicates that the design could not run on the software or that the running time exceeded one hour. As shown in the table, our algorithm outperforms FreeRouting and Allegro in terms of routability, runtime, and DRVs. It should be noted that these two routers use a serial approach to routing, meaning that only one net is selected at a time for routing. They do not use global planning before routing, which causes them to reassess congestion on the board after every wire has been routed. If enough space is not available for routing, they take measures such as layer reassignment, rip-up, and reroute, resulting in additional time and space costs. However, our algorithm tries to route all the nets on the same layer, resulting in better results.

Figure 14 shows the routing result of PCB5 using our algorithm. After the Comp-Star decomposition algorithm runs, the component $U_1$ is selected as the component star, and the net of the seventh pad counted from the top down on its left side has the shortest length, making it the first net to be routed. All 12 nets to the left of $U_1$ have adjacent starting and ending points, so they can be routed simultaneously in the global triangular grid, with all completed wires concentrated in the center region. Finally, the remaining nets are routed according to the clockwise routing sequence, taking into account pads, vias, and tracks on the board as obstacles. These results demonstrate that our algorithm is effective, applicable, and efficient in routing PCB designs.

5. Conclusions

In this paper, we have presented a novel global routing algorithm for PCB designs that takes into account the 135-degree routing requirements. Additionally, we have incorporated the use of the Comp-Star decomposition algorithm to determine the routing order for the nets. This algorithm helps identify the most critical components that should be given priority during the routing process, thereby reducing congestion and wire crossover. We have proposed a triangular grid model that enables more effective searching for optimal paths during the global routing stage. Furthermore, by employing the maximum flow scheme, we can efficiently find paths that connect all the nets, ensuring a complete global routing stage. Extensive experimental comparisons with two state-of-the-art routers demonstrate the superiority of our algorithm in terms of performance.