Authors (all from Huawei 6G research team): Jiajie Tong 1, Xianbin Wang 1, Qifan Zhang 2, Huazi Zhang 2, Rong Li 1, Jun Wang 1
 Wireless Technology Lab
 Ottawa Wireless Advanced System Competency Centre
1 Introduction
1.1 Motivations and Background
Higher throughput has always been a primary target during the evolution of mobile communications. Driven by high data rate applications such as virtual/augmented reality (VR/AR) applications, the sixth generation of wireless technology (6G) requires a peak throughput of 1 Tbps. This is roughly a 50×–100× increase over the 10–20 Gbps throughput targeted for 5G standards.
To support such a high data rate, we need to propose a new physical layer design to reduce implementation complexity, save energy, and improve spectral efficiency. This is particularly true when the peak throughput requirement is imposed on a resourceconstrained device (e.g., with limited processing power, storage, and energy supply). As channel coding is widely known to consume a substantial proportion of computational resources, it poses a bottleneck for extreme throughput. To this end, channel coding is one of the most relevant physical layer technologies used to guarantee 1Tbps peak throughput for 6G.
Polar codes, defined by Arikan, are a class of linear block codes with a generator matrix \(G_{N}\) of size N, defined by \( G_{N} \triangleq F^{\otimes n} \) , in which \( N=2^{n} \) and \( F^{\bigotimes n} \) denotes the nth Kronecker power of \( F=\begin{bmatrix} 10\\ 11\end{bmatrix} \). Successive cancellation (SC) is a basic decoding algorithm for polar codes.
Although the SC decoding algorithm seems unsuitable for highthroughput applications due to its serial nature, state oftheart SC decoders managed to significantly simplify and parallelize the decoding process such that the area efficiency of SC decoding has far exceeded that of belief propagation (BP) decoding for lowdensity paritycheck codes (LDPC). In particular, these works represent SC decoding as a binary tree traversal, as shown in Figure 1a, with each subtree therein representing a shorter polar code. The original SC decoding algorithm traverses the tree by visiting all the nodes and edges, leading to high decoding latency. Simplified SC decoders can fast decode certain subtrees (shorter polar codes) and thus "prune" those subtrees. The resulting decoding latency is largely determined by the number of remaining edges and nodes in the pruned binary tree. Several treepruning techniques have been proposed. To achieve 1Tbps throughput, more aggressive techniques need to be proposed on both the decoding and encoding sides.
Figure 1 (a) Decoding architecture as a binary tree; (b) Node v received/response information
1.2 Contributions
This paper introduces a novel polar code construction method, referred to as "fast polar codes", to facilitate parallelized processing at an SC decoder. In contrast to some existing decodingonly techniques, we take a joint encodingdecoding optimization approach. Similar to existing methods, our main ideas can be better understood from the binary tree traversal perspective. They include (a) pruning more subtrees, (b) replacing some nonprunable subtrees with other fastdecodable short codes of the same code rates, and then pruning these "grafted" subtrees, and (c) eliminating the remaining nonprunable subtrees by altering their code rates. As can be seen, both (b) and (c) involve a modified code construction. Consequently, we are able to fast decode any subtree (short code) of a certain size, without sacrificing parallelism.
The algorithmic contributions are summarized below:
 We introduce four new fast decoding modules for nodes with the code rates \(\left \{ \frac{2}{M},\frac{3}{M},\frac{M2}{M},\frac{M3}{M} \right \}\). Here \( M=2^{s} \) is the number of leaf nodes in a subtree, where s is the stage number. These nodes are called dualREP (REP2), repeated parity check (RPC), parity checked repetition (PCR), and dualSPC (SPC2) nodes, respectively. More importantly, these modules reuse existing decoding circuits for repetition (REP) and single parity check (SPC) nodes.
 For mediumcoderate nodes that do not natively support fast decoding, we graft two extended BCH codes to replace the original outer polar codes. As BCH codes enjoy a good minimum distance and natively support efficient hardinput decoding algorithms, they strike a good balance between performance and latency. The extension method is also customized to enhance performance.
 We propose the reallocation of code rates globally, such that all nodes up to a certain size support the aforementioned fast decoding algorithms. This approach completely avoids traversal into certain "slow" nodes.
For code length N=1024 and code rate R=0.875, the proposed fast polar codes enable parallel decoding of all length16 nodes. The proposed decoding algorithm reduces node visits by 55% and edge visits by 43.5% when compared with the original polar codes, with a performance cost of under 0.3 dB. Two types of decoder hardware are designed to evaluate the area efficiency and energy efficiency.
The implementation contributions are summarized below:
 We have designed a recursive decoder to flexibly support any code rates and code lengths N ≤ 1024. We estimate that this decoder layout area is only 0.045 mm^{2}. For code length N=1024 and code rate R=0.875, it achieves a 25.6 Gbps code bit throughput, with an area efficiency of 561 Gbps/mm^{2}.
 We have also designed an unrolled decoder that only supports one code rate and code length. We estimate that this decoder layout area is 0.3 mm^{2}. For code length N=1024 and code rate R=0.875, it provides a 1229Gbps code bit throughput, with an area efficiency of 4096 Gbps/mm^{2}.
2 From Simplified SC Decoding to Fast Polar Codes
Following the notations, node v in a tree is directly connected to a parent node \(p_{v}\), left child node \(v_{l}\) and right child node \(v_{r}\), respectively. The stage of node v is defined by the number of edges between it and its nearest leaf node. All leaf nodes are at stage s=0. The set of nodes of the subtree rooted at node v is denoted by \(V_{v}\). As such, \(V_{root}\) denotes the full binary decoding tree. The set of all leaf nodes is denoted by U, the index of a leaf u is denoted by i(u), and the indices of U is denoted by i(U). Meanwhile, the set of the leaf nodes in subtree Vv is denoted by Uv, and the indices of \(U_{v}\) is denoted by \( i\left ( U_{v} \right ) \).
The set of all information bit positions is denoted by I and that of all frozen bits by \(L^{C}\). The set of the information bit positions in subtree \(V_{v}\) is denoted by \(L_{v}\) and the remaining frozen bit positions therein by \( L_{V}^{C}\).
2.1 Simplified SC Decoding
If ICv matches patterns, patternbased simplified decoding can be triggered to process the node in parallel rather than bitbybit. From the binary tree traversal perspective, all child nodes of v do not need to be traversed. As a result, decoding latency is reduced.
The existing patternbased simplified decoding includes 4 different types. Node v is a Rate1 node if all leaves in the subtree \(V_{v}\) are information bits, and a Rate0 node if all leaves in the subtree \(V_{v}\) are frozen bits. To improve the decoder’s efficiency, references define the single parity check (SPC) and repetition (REP) nodes. We can employ patternspecific parallel processing for each type of node. However, we need to identify and exploit additional special nodes or patterns for improved latency reduction.
In this paper, we present four new types of corresponding nodes:
 Define node v as a dualSPC (SPC2) node if \(V_{v}\) includes only two frozen bits, and the frozen bits indices are the two smallest in \( i\left ( U_{v} \right ) \).
 Define node v as a dualREP (REP2) node if \(V_{v}\) includes only two information bits, and the information bits indices are the two largest in the \( i\left ( U_{v} \right ) \).
 Define node v as a repeated parity check (RPC) node if \(V_{v}\) includes only three frozen bits, and the frozen bits indices are the three smallest in the \( i\left ( U_{v} \right ) \).
 Define node v as parity checked repetition (PCR) node if \(V_{v}\) includes only three information bits, and the information bits indices are the three largest in the \( i\left ( U_{v} \right ) \).
The corresponding fast decoding methods are described in Section 3.
Patternbased simplified decoding skips the traversal of certain subtrees when it matches the above patterns.
Currently, there are eight pattern types to cover eight code rates in a subtree: \( \left \{0, \frac{1}{M},\frac{2}{M},\frac{3}{M},\frac{M3}{M},\frac{M2}{M},\frac{M1}{M},1 \right \} \) . In other words, nodes with other code rates cannot be decoded fast, and we need to work on the following two parameters.
 Ratio of simplified nodes: currently eight out of the M+1 code rates support simplified decoding, and the ratio is \( \frac{8}{M+1} \). Note that only the lowest and highest codes rates can be simplified, meaning code rates between \( \frac{3}{M} \) and \( \frac{M3}{M} \) do not benefit from the fast decoding algorithm. For short and medium length codes, many nodes fall into this range due to insufficient polarization. We hope to further reduce latency by introducing more fastdecodable patterns to cover additional code rates.
 Degree of parallelism: this can be represented by M, since the M bits in a simplified node are decoded in parallel. A larger M means a larger proportion of the binary tree can be pruned due to simplified decoding. We hope to increase M for higher throughput as well.
For M=8, the ratio of simplified nodes is 8/9, with only one unsupported code rate\( \left ( \frac{4}{8} \right ) \), but the degree of parallelism is only 8. For M=16, the ratio of simplified nodes reduces to 8/17, leaving a wide gap of nine unsupported code rates \( \left ( \frac{14}{16},... ,\frac{12}{16} \right ) \), but the degree of parallelism doubles.
2.2 BCH Code
To cover medium code rates, we need to find patterns that can be fast decoded with good BLER performance. Unfortunately, to the best of our knowledge, there exists no parallel decoding method for polar codes with code rates between \( \frac{M3}{M} \) and \( \frac{3}{M} \). The good news, however, is that the outer codes represented by a subtree can be replaced by any codes, as shown in many previous works. A good solution involves removing the polar nodes with code rate falling into the gap, and grafting a different code that allows for fast decoding.
BCH codes are ideal candidates due to their good minimum distance property and fast hardinput decoding algorithms. If the error correcting capability is t, it is easy to design BCH codes with a minimum Hamming distance larger than 2 × t. This leads to good BLER performance. Meanwhile, the BerlekampMassey (BM) algorithm can decode a BCH code with t=1 or t=2 within a few clock cycles. When grafted to polar codes as fastdecodable nodes, hard decisions are applied to the LLRs from the inner polar codes (parent nodes) before being sent to the outer BCH codes (child nodes). Here, the BCH codes are called "BCH nodes".
But BCH codes cannot immediately solve our problem. They only support a few code rates and code lengths, meaning they cannot cover all codes rates within the gap. For the degree of parallelism M=16, the target code length is \( 2^{4} \), so the nearest code length of BCH is 15. Meanwhile, BCH codes only support code rates \( \frac{7}{15} \) and \( \frac{11}{15} \) within the gap, and the corresponding number of information bits are k=7, k=11.
To overcome these issues, we must first extend the code length to 16 bits. For BCH codes with k=7 and t=2, the original codes can correct two error bits, and we add an additional bit to be the parity check of all BCH code bits. The proposed twostep hard decoding works as follows: When the hard decision incurs three bit errors and one has the minimum amplitude, the SPC bit can help correct one error bit first. The remaining two error bits can then be corrected by the BM algorithm. However, the same SPC extension does not work for BCH codes with k=11 and t=1. This is because if there are two or more bit errors in the node, the SPC function and the BM algorithm both fail. Alternatively, if there is one error, the SPC decoding failure will lead to further errors during BM decoding. Instead of SPC extension, we repeat one BCH code bit to improve its reliability.
Now that we have grafted two types of BCH nodes, patternbased decoding can support 10 code rates. The ratio of simplified nodes increases to 10/17, and the maximum gap reduces to \(\frac{4}{16}\). Figure 3 shows the code rates supported by patternbased decoding for a degree of parallelism M=16.
Figure 2 Nodes (code rates) supporting fast decoding for degree of parallelism
Figure 3 BLER Performance comparison between GA and fast polar code construction
2.3 Fast Polar Codes via Rate Re Allocation
Even with the inclusion of BCH nodes, the fast decoding algorithm could not cover all the code rates of length16 subtrees. As the second part of the solution, we propose the construction of fast polar codes to avoid the "slow" nodes, and the use of the existing ten patterns only. Here "fast" resembles the speed of fast SC decoding, but is achieved by altering code construction instead of decoding. Our demonstration shows that it greatly reduces decoding latency and increases throughput with only a slight performance loss.
The following steps show how to construct fast polar codes using only the node patterns of discontinuous code rates:
1. Employ traditional methods such as Gaussian approximation (GA) or polarization weight (PW) to build polar codes with the parameters of code length N and code rate R.
2. Split all N synthesized subchannels to N/16 segments. Each segment constitutes a 16bit long block code, equivalent to a subtree with 16 leaf nodes.
3. Identify all "slow" segments which do not match the supported code rates or patterns. Reallocate the code rates among segments to match the nearest supported code rate or pattern, which has K information bits.
4. If the number of information bits of the current segment exceeds or falls short of K, we remove or add a few information bits according to reliability. Apply this process to the remaining "slow" segments until all segments become fastdecodable.
The resulting code is coined as "fast polar code". A detailed description of the construction algorithm for fast polar codes can be found in Algorithm 1.
Take code length N=1024 and code rate R=0.875 as examples. We count the number of fastdecodable nodes to be visited, \(f_{+/}\) functions to be executed, and edges to be traversed. These numbers provide a good estimate for SC decoding latency, and are thus used to compare the construction proposed in this section with the GA construction in Table 1. As we can see, the traversed nodes and edges reduce by 55% and 43.5%, respectively, while the \(f_{+/}\) function executions reduce only by 8.9%. Note that the former two parameters have a greater influence than \(f_{+/}\) functions, because they cannot be parallelized in any form.
Table 1 A summary of current spatial nonstationary channel models and their pros and cons
It is worth noting that the proposed fast polar code construction algorithm reallocates the code rates of some nodes against their actual capacity which is derived from channel polarization. This inevitably incurs a BLER performance loss. We run simulations to evaluate the loss, and Figure 3 compares the BLER curves of both constructions under code length N=1024 and code rates R={0.75, 0.8125, 0.875, 0.9375}. There is a maximum of 0.3 dB loss at BLER \(10^{2}\) between GA polar codes and the fast polar codes when adopting QPSK modulation.
3 Fast Decoding Algorithms
In this section, we describe the algorithms used to support fast decoding of the newly defined SPC2, REP2, RPC, and PCR nodes. For BCH nodes, we employ the classic BM algorithm which takes hard inputs and supports hardwarefriendly fast decoding.
Each fastdecodable node v at stage s can be viewed as an outer code of length \( M=2^{s}\). The code bits of v as an outer code are denoted by \( X_{v} \), with M bits.
3.1 SPC2
For a dualSPC node v, we divide its code bits \( X_{v} \) into two groups, \(X_{v}^{even}\) with evennumbered indices, and \(X_{v}^{odd}\) with oddnumbered indices. According to the definition of an SPC2 node, there are two paritycheck bits in the subtree \( V_{v} \) , and the corresponding parity functions p[0] and p[1] can be written as
\(\left\{\begin{array}{l} p[0]: \oplus x=0, x \in X_{v} \\ p[1]: \oplus x=0, x \in X_{v}^{o d d} \end{array}\right.\)
We add the two parity functions to get a parity function p[2]:
\(p[2]=p[0] \oplus p[1]: \oplus x=0, x \in X_{v}^{\text {even }}\)
Since the two parity functions p[1] and p[2] involve two disjointed sets of code bits, the decoding of an SPC2 node can be parallelized to two SPC nodes, each of which inherits half of the elements from \( X_{v} \). We can reuse two SPC decoding modules to fast decode the SPC2 node.
3.2 REP2
For a dualREP node v, we divide its code bits \( X_{v} \) into two groups, \(X_{v}^{even}\) with evennumbered indices, and \(X_{v}^{odd}\) with oddnumbered indices. There are two information bits in the subtree \( V_{v} \) according to the definition of a REP2 node, and these are denoted by \( U_{M2} \) and \( U_{M1} \).
It can be easily verified that \(X_{v}^{odd}\) are the repetition of \( U_{M1}\), and \(X_{v}^{even}\)n are the repetition of \( U_{M2} \bigoplus U_{M1} \). Consequently, we can divide a lengthM dualREP node into two M/2 REP nodes, and we can reuse two REP decoding modules in parallel to fast decode the REP2 node.
3.3 RPC
For an RPC node v, we divide its code bits \( X_{v} \) into four groups as follows:
\( X_{v}^{i}=\left\{x \in X_{v}, \bmod (I(x), 4)=i\right\}, i \in\{0,1,2,3\} \)
According to the definition of an RPC node, there are three paritycheck bits in the subtree Vv, and the parity functions p[0], p[1] and p[2] can be written as
\(\left\{\begin{array}{l} p[0]: \oplus x=0, x \in X_{v}^{0} \cup X_{v}^{1} \cup X_{v}^{2} \cup X_{v}^{3} \\ p[1]: \oplus x=0, x \in X_{v}^{1} \cup X_{v}^{3} \\ p[2]: \oplus x=0, x \in X_{v}^{2} \cup X_{v}^{3} \end{array}\right.\)
We add the latter two parity functions to get parity function p[3]:
\(p[3]=p[1] \oplus p[2]: \oplus x=0, x \in X_{v}^{1} \cup X_{v}^{2}\)
And we add this parity function to the first one to get parity function p[4]:
\(p[4]=p[0] \oplus p[3]: \oplus x=0, x \in X_{v}^{0} \cup X_{v}^{3}\)
We define ^c i=⊕ x, x ∈ Xiv , i ∈ [0,1,2,3]. According to parity functions p[1] to p[4], we can easily verify that the following relationship holds true:
\( \hat{C}_{1} \oplus \hat{C}_{3}=\hat{C}_{2} \oplus \hat{C}_{3}=\hat{C}_{1} \oplus \hat{C}_{2}=\hat{C}_{0} \oplus \hat{C}_{3}=0 \) (2)
Equation (2) implies the existence of a virtual repetition code of rate, because:
\( \hat{c}_{0}=\hat{c}_{1}=\hat{c}_{2}=\hat{c}_{3}=0 \) or
\( \hat{c}_{0}=\hat{c}_{1}=\hat{c}_{2}=\hat{c}_{3}=1 \)
where \( \hat{C}_{0},\hat{C}_{1},\hat{C}_{2},\hat{C}_{3}\) are the virtual repeated code bits. Given the above knowledge, the decoding algorithm for an RPC node at stage s where s ≤ 2, can be easily derived as Algorithm 2, in which
3.4 PCR
For a PCR node v, we divide its code bits \( X_{v} \) into four groups, just like in (1). There are three information bits in this node according to the definition of a PCR node, and these are denoted by \(U_{M3}\), \(U_{M2}\), \(U_{M1} \). We define \(C_{i}\) , i ∈ {0, 1, 2, 3} according to the following equation
\( \left[\begin{array}{llll} c_{0} & c_{1} & c_{2} & c_{3} \end{array}\right]=\left[\begin{array}{llll} 0 & u_{M3} & u_{M2} & u_{M1} \end{array}\right] \times G_{4} \) （3）
It can be easily verified that \( X_{v} \)0 are the repetition of \(C_{0}\), \( X_{v} \)1 are the repetition of \(C_{1}\), \( X_{v} \)2 are the repetition of \(C_{1}\), and \( X_{v} \)3 are the repetition of \(C_{3}\). Consequently, we divide the input signal \(\alpha_{v}\) into four groups according the indices, and combine the input signals within each group into four enhanced signals \(\Delta _{i}\), i ∈ {0, 1, 2, 3}, as in an REP node.
Equation (3) implies the existence of a virtual single parity check code of rate \(\frac{3}{4}\) , with virtual code bits \(C_{i}\), i ∈ {0, 1, 2, 3}, so that we can reuse the SPC module to decode it. A detailed description of PCR decoding is provided in Algorithm 3.
4 Hardware Implementation
We designed two types of hardware architectures to verify performance, area efficiency, and energy efficiency.
 Recursive Decoder: This architecture supports flexible code lengths and coding rates of mother code length N from 32 to 1024 with the power of 2. With rate matching, flexible code lengths with 0 < N ≤ 1024 and code rates with 0 < R ≤ 1 are supported. The \( f_{+/} \) functions in nodes are processed by single PE (processing element) logic, and one decision module supports all 9 patterns. The decoder processes one packet at a time.
 Unrolled Decoder: This architecture only supports a fixed code length and code rate. In our architecture, we hard coded code length N=1024 and code rate R=0.875. This fully unrolled pipelined design combines exclusive dedicated PEs to process each \( f_{+/} \) function in the binary tree. The same applies to the decision modules where 21 dedicated node specific logic is implemented to support 21 nodes patterns. With 25 packets simultaneously decoding, and thanks to the unrolled full utilization of processing logic and storage, this decoder provides extremely high throughput with high area efficiency and low decoding energy.
Both of the decoder implementations mentioned above adopt successive cancellation algorithms accelerated by patternbased fast decoding. The maximum degrees of parallelization are 128 for SPC and SPC2 nodes, and 256 for R1 nodes. All other nodes enjoy a degree of parallelism of 16.
4.1 Parallel Comparison Circuit
We can observe that there are several large SPC nodes in the right half of the binary tree. As described, these SPC nodes need to be processed with a higher degree of parallelism to achieve a higher throughput. The SPC decoding algorithm is very simple, and can be explained as follows. First, obtain the signs of an SPC node’s input signals. Then find the minimum amplitude of input signals and record its position. Next, perform a parity check on the signs. If it passes, return these signs. Otherwise, reverse the sign of the recorded minimumamplitude position and return the updated signs.
To process a large SPC node, a circuit is required to locate a minimum amplitude from a large number of input signals. The traditional pairwise comparison method requires a circuit of depth \( log_{2}(M) \), where M is the number of amplitudes to be compared. Finding the smallest among, for example, 128 amplitudes requires 7 comparison steps. Considering that clock frequency is set to 1 GHz, it is very challenging to meet the timing constraints and complete all comparisons in one clock cycle.
To address these issues, we advocate a parallel comparison architecture to replace the traditional one. For node v at stage s, its input signals \( \alpha_{v}\) include \( M=2^{s} \) elements, the amplitudes of which are denoted as [\(A_{0} A_{1} ... A_{M1}\)]. Each amplitude has x bit quantization, and we fill the xbit quantized binary vectors into the columns of a matrix as follows:
If we rewrite the matrix with respect to its row vectors bits matrix we will have \( [B_{0}...B_{j}...B_{M1}...]^{T} \), in which \(B_{j}=\left[b_{0}^{j} \cdots b_{i}^{j} \cdots b_{M1}^{j}\right]\), j ∈ {0, 1 ··· x − 1} is a row vector. We propose Algorithm 4 to determine the minimumamplitude position through reverse mask D, in which the bit "1" indicates the minimum. The parallel comparison algorithm reduces the comparison logic depth from \( log_{2}(M) \) to 1. However, the reverse mask D may have two or more minimum positions, which means that the input signals \( \alpha_{v}\) include two or more minimum amplitudes, and it must generate an error in such cases. To prevent this error, we can apply an additional circuit to ensure the uniqueness of the selected minimum position.
4.2 Bit Quantization
An attractive property of polar codes is that SC decoding works well under lowprecision quantization (4 bits to 6 bits). Lower precision quantization is the key to higher throughput, as it effectively reduces implementation.
Figure 4 Performance comparison between Floating Point and Fixed Point
There are two types of quantization numbers — one for channel LLR and another for internal LLR. We first test a case with 6bit input quantization and 6bit internal quantization. According to Figure 4, this setting achieves the same performance as floatingpoint. The second case is 5bit quantization and 5bit internal quantization, which incurs < 0.1 dB loss. Finally, 4bit input quantization and 5bit internal quantization incurs < 0.2 dB loss. In this paper, we evaluate the physical implementation result under 5bit quantization for both input and internal signals to strike a good balance between complexity and throughput.
At the same time, we also compare the BLER performance between the original SPC and parallelized SPC. None of the quantization schemes result in a harmful loss.
4.3 Estimation of Layout Area
We carry out the two FPGA implementations for both the recursive and unrolled architectures and convert the results to the physical implementations.
According the FPGA synthesis results, the recursive decoder has 10170 LUTs and 12772 FFs; meanwhile, the unrolled decoder has 66192 LUTs and 55187 FFs. Both decoders avoid the use of memories, making it is easy to convert the FPGA results to ASIC. Converted to 16 nm technology, the recursive decoder estimated synthesis area and the layout size are
0.032 mm^{2} and 0.045 mm^{2}, respectively, at a clock frequency of 1 GHz. The unrolled decoder's estimated synthesis area and the layout size are 0.17 mm^{2} and 0.30 mm^{2}, respectively, at a clock frequency of 1.20 GHz.
5 Key Performance Indicators
The key performance indicators (KPIs) are reported in this section. First of all, we evaluate the area efficiency using equation:
AreaEff ( Gbps/mm^{2} )= InfoSize (bits)/(Latency (ns)×Area (mm^{2} ))
The recursive decoder takes 40 clock cycles to decode one packet under fast polar code construction with code length N=1024 and code rate R=0.875. As such, the throughput is (1024 bits × 1 GHz)/40 cycles=25.6 Gbps for coded bits, and ((1024 × 0.875) bits × 1 GHz)/40 cycles=22.4 Gbps for information bits. Converting to 16 nm process, the area efficiency for coded bits is 561 Gbps/mm^{2}.
The unrolled decoder takes 25 clock cycles to decode one packet. It is fully pipelined, meaning a new packet of decoded results is generated continuously every cycle after the first 25 clock cycles of the first packet processing time. The throughput is thus 1024 bits × 1.2 GHz=1229 Gbps for coded bits, and (1024 × 0.875) bits × 1 GHz=1075 Gbps for information bits. Converting to 16 nm process, the area efficiency for coded bits is 4096 Gbps/mm^{2}.
Table 2 Comparison with the high throughput polar decoder
Table 3 Comparison with high throughput polar decoder
We further evaluate the power consumption and decoding energy per bit through a simulation in which 200 packets are decoded. The process, voltage, and temperature (PVT) condition of evaluation is TT corner, 0.8 V, and 20°C, the result of the recursive decoder’s power consumption is 30.9 mW, and decoding each bit costs 1.21 pJ of energy on average; while the unrolled decoder’s power consumption is 784 mW, and decoding each bit costs 0.63 pJ of energy on average.
We also compare the decoding throughput, area efficiency, and power consumption with several other highthroughput decoders, and present the results in Table 3. From the KPIs, we conclude that unrolled decoders are more suitable for scenarios requiring extremely high throughput but only support fixed code length and rate. Recursive decoders are much smaller, which are better for resource constrained devices, and at the same time provide flexible code rates and lengths — a desirable property for wireless communications.
6 Conclusions
In this paper, we propose a new construction method for fast polar codes, which is solely composed of fastdecodable special nodes at length 16. By viewing the decoding process as a binary tree traversal, the fast polar codes can reduce 55% of node visits, 8.9% of \( f_{+/} \) calculation, and 43.5% of edge traversal over the original polar construction at code length N=1024 and code rate R=0.875, at the cost of slight BLER performance loss.
We implement two types of decoders for the fast polar codes. The recursive decoder can support flexible code lengths and code rates, with support for code lengths of up to 1024. This decoder layout area is only 0.045 mm^{2}, and it can provide 25.6 Gbps coded bits throughput with an area efficiency of 561 Gbps/mm^{2}.
The unrolled decoder only supports one code length N=1024 and one code rate R=0.875. However, the fully pipelined structure leads to hardware offering ultrahigh area efficiency and low decoding power consumption. The estimated layout area of this decoder is 0.3 mm^{2}, and it can provide a code bit throughput of 1229 Gbps with an area efficiency as high as 4096 Gbps/mm^{2}.
These results indicate that fast polar codes can meet the highthroughput demand of nextgeneration wireless communication systems, and that recursive and unrolled hardware designs can be adopted to satisfy different system requirements.
More Stories

01
ITUR WP5D Completed the Recommendation Framework for IMT2030 (Global 6G Vision)
By Yan Chen, Peiying Zhu, Wen Tong 
02
Joint Message Passing and Autoencoder for Deep Learning

03
6G Native Trustworthiness

04
Terahertz Sensing and Communication Towards Future Intelligence Connected Networks

05
VeryLowEarthOrbit Satellite Networks for 6G

06
NET4AI: Supporting AI as a Service in 6G