On the Construction of $G_N$-coset Codes for Parallel Decoding

TL;DR

This paper introduces a new class of $G_N$-coset codes designed for highly parallel turbo-like decoding, enabling efficient decoding with comparable performance to polar codes.

Contribution

It proposes a novel $G_N$-coset code construction leveraging parallel decoding of component codes and a flexible information set selection method.

Findings

Achieves decoding parallelism superior to traditional codes.

Maintains coding performance comparable to polar codes.

Demonstrates effective heuristic code construction.

Abstract

In this paper, we propose a type of $G_N$-coset codes for a highly parallel stage-permuted turbo-like decoder. The decoder exploits the equivalence between two stage-permuted factor graphs of $G_N$-coset codes. Specifically, the inner codes of a $G_N$-coset code consist of independent component codes, thus are decoded in parallel. The extrinsic information of the code bits is obtained and iteratively exchanged between the two graphs until convergence. Accordingly, we explore a heuristic and flexible code construction method (information set selection) for various information lengths and coding rates. Simulations show that the proposed $G_N$-coset codes could achieve a coding performance comparable with polar codes but enjoy higher decoding parallelism.

Tables

Table 1. TABLE I: A comparison of the required time steps between the proposed coding schemes and polar codes.

Scheme	N	Rate	Time steps	Parallelism
Type-1: Soft-output SC list as inner decoder	65536	$0.8716$ $\left(\frac{57121}{65536}\right)$	20160	16
			10080	32
			5040	64
			2520	128
		$0.8563$ $\left(\frac{56121}{65536}\right)$	20032	16
			10016	32
			5008	64
			2504	128
Type-2: Soft-output SC permutation list as inner decoder	65536	0.8716	4736	16
			2368	32
			1184	64
			592	128
		0.8563	4864	16
			2432	32
			1216	64
			608	128
Type-3: Soft cancellation as inner decoder	65536	0.8716	10272	16
			5136	32
			2568	64
			1284	128
			642	256
		0.8563	11008	16
			5504	32
			2752	64
			1376	128
			688	256
Polar111This is evaluated with the double-package mode closed[14]. CA SC List 8	65536	$0.8716$	93097	1
		$0.8563$	93477	1
Polar SC	65536	0.8716	13146	1
		0.8563	13282	1

Equations

$$\begin{array}{r}{G}_N\triangleq F^{\otimes n}\end{array},$$

$$x_1^N=u_1^N{G}_N,$$

$$x_1^N=u(\mathcal{A})G_N(\mathcal{A}),$$

$$\begin{array}{r}{M}_i^l=\sum _{j=1}^{\sqrt{N}}(\frac{{\sigma }^2{L}_{i,j}^t}{2}-(1-2{\hat{x}}_{i,j}^l){)}^2\end{array}.$$

$$\begin{array}{r}{T}_{i,j}^t=\frac{{\min }_{\{l|{\hat{x}}_{i,j}^l=1\}}{M}_i^l-{\min }_{\{l|{\hat{x}}_{i,j}^l=0\}}{M}_i^l}{2{\sigma }^2}\end{array}.$$

$$p_{i}=\left\{\begin{array}[]{rcl}1&&{\text{The }i\text{-th bit is an information bit.}}\\ 0&&{\text{The }i\text{-th bit is a frozen bit.}}\\ \end{array}\right.$$

$$\begin{array}{r}I=P\otimes P\end{array}.$$

$$\begin{array}{r}P=[0111]\end{array}.$$

$$\begin{array}{r}I=P\otimes P=[0000011101110111]\end{array}.$$

Full text

I Introduction

I-A Preliminary

$G_{N}$-coset codes, as defined by Arıkan in [1], are a class of linear block codes with the generator matrix $G_{N}$.

$G_{N}$ is an $N\times N$ binary matrix defined as

[TABLE]

in which $N=2^{n}$ and $F^{\otimes n}$ denotes the $n$-th Kronecker power of $F=[\begin{smallmatrix}1&0\\ 1&1\end{smallmatrix}]$.

The encoding process is

[TABLE]

where $x_{1}^{N}\triangleq\{x_{1},x_{2},\cdots,x_{N}\}$ and $u_{1}^{N}\triangleq\{u_{1},u_{2},\cdots,u_{N}\}$ denote the code bit sequence and the information bit sequence respectively.

An $(N,K)$ $G_{N}$-coset code [1] is defined by an information set $\mathcal{A}\subset\{1,2,...,N\}$, $|{\cal A}|=K$. Its generator matrix $G_{N}(\mathcal{A})$ is composed of the rows indexed by $\mathcal{A}$ in $G_{N}$. Thus (2) is rewritten as

[TABLE]

where $u(\mathcal{A})\triangleq\{u_{i}|i\in\mathcal{A}\}$.

The key to constructing $G_{N}$-coset codes is to properly determine an information set $\mathcal{A}$. RM codes[2] and polar codes[1], two well-known examples of $G_{N}$-coset codes, determine $\mathcal{A}$ in terms of Hamming weight and sub-channel reliability, respectively, which are referred to as RM principle and polar principle.

Polar codes are the first capacity-achieving channel codes [1]. RM codes are proved to achieve the binary erasure channel capacity under the maximum-a-posteriori (MAP) decoding algorithm[2]. Both codes have been adopted for 5G control channel.

I-B Motivations and Contributions

Both RM codes and polar codes are not designed for parallel decoding. RM codes are only adopted for very short code lengths due to the lack of linear-complexity decoding algorithms. Polar codes exhibit superior performance with successive cancellation (SC) based decoders. But an SC decoder is serial in nature[1] as it requires $2N-2$ time steps for a length-$N$ code.

To seek parallelism on the decoding side, we propose a novel stage-permuted turbo-like decoding framework. As shown in Fig. 1(a), the encoding process of $G_{N}$-coset codes can be described by an $n$-stage encoding graph. Therefore, $G_{N}$-coset codes can be considered as concatenation codes. The former and latter stages respectively correspond to outer and inner codes. The inner code parts consist of independent component codes that can be decoded in parallel (the $j$-th code bit of the $i$-th inner component code is denoted by $x(i,j)$ in Fig. 1(a)) [3]. In contrast, the outer code parts must be decoded successively, which is the major source of latency of all SC-based decoding algorithms.

Based on the above observation, the proposed algorithm improves decoding parallelism as follows. First, equivalent encoding/decoding graphs (see Fig. 1) of the same $G_{N}$-coset code can be obtained by permuting the encoding stages [4]. Second, decoding is performed on each of these equivalent graphs. Within each graph, $\sqrt{N}$ inner component codes of length $\sqrt{N}$ are decoded in parallel, but the outer component codes are not processed. Finally, decoding results from different graphs about the same code bit are exchanged to reach a consensus. Fig. 1(a) and Fig. 1(b) show two equivalent graphs for $N=16$. In each decoding graph, the inner code parts consist of $4$ component codes of length $4$. Since only the inner code parts are decoded in parallel while the outer code processing is avoided, the proposed decoding algorithm exhibits a higher degree of parallelism.

Furthermore, we propose a new code construction principle (selection of $\cal A$) for the stage-permuted turbo-like decoding algorithm. In particular, we show that the principle to select $\cal A$ is to reduce the code rate of the inner codes. Accordingly, we explore a heuristic code construction that outperforms the RM and polar codes under the stage-permuted decoder.

I-C Related works

In [5, 6], product codes with polar codes as component codes are studied, with the same aim of improving decoding parallelism. As product codes, the codes are constructed from the component codes, which lead to a square number ($k^{2}$) of information bits. In contrast, we follow Arıkan’s $G_{N}$-coset code framework [1], which is more general and flexible in two folds. First, the code construction is defined directly by $\cal A$. It naturally supports “1-bit” fine-granularity of information length. Second, stage permutation potentially supports a more flexible framework with richer ($n!$ instead of two) combinations of outer-inner code concatenations. Accordingly, iterative decoding can be performed on at most $n!$ stage-permuted graphs.

II Stage-permuted turbo-like decoding algorithm

The aforementioned stage-permuted turbo-like decoder is formally described in Algorithm 1.

Denote by $\cal G$ the original decoding graph consisting of $n$ stages. There are $n!$ equivalent stage-permuted graphs [4]. Among them, we choose the permuted graph ${\cal G}_{\pi}$ with stage permutation $\pi\{1,2,...n\}=\{n/2+1,...n,1,...,n/2\}$. This results into a swap between the inner and outer code parts of the original decoding graph $\cal G$ (see Fig. 1). Because the inner code part of ${\cal G}_{\pi}$ is the outer code part of $\cal G$, by decoding the inner code parts of $\cal G$ and ${\cal G}_{\pi}$, full information (parity check functions) about $\cal G$ is exploited.

The decoding algorithm iterates by decoding the two graphs $\cal G$ and ${\cal G}_{\pi}$ alternately (line 3 in Algorithm 1) as follows. For decoding graph $\cal G$ (resp. ${\cal G}_{\pi}$), the $j$-th code bit of the $i$-th inner component code is denoted by $x(i,j)$ (resp. $x_{\pi}(j,i)$). Take the non-permuted graph $\cal G$ for example, $L_{i,j}^{t}$ is the log likelihood ratio (LLR) of the code bit $x(i,j)$ in the $t$-th iteration. Specifically, $L_{i,j}^{t}$ is the sum of channel LLR $L_{chan,i+(j-1)\sqrt{N}}$ and the soft extrinsic information $T_{\pi,i,j}^{t-1}$ from the previous decoding iteration (line 6). Following the method in [11], the extrinsic information is multiplied by a damping factor ${\alpha}_{t}$ to improve performance. The $i$-th soft-output component decoder, denoted by $SoftDecoder()$, takes $L_{i,j}^{t}$, $j=1,2,\cdots,\sqrt{N}$ as input, and generates extrinsic information $T_{i,j}^{t}$, $j=1\cdots\sqrt{N}$ as output (line 7). There are $\sqrt{N}$ inner component codes in each decoding graph and the $\sqrt{N}$ component decoders can be implemented in parallel. After $t_{\max}$ iterations, the algorithm outputs the hard decisions of combined LLRs as recovered code bits.

The decoding algorithm can exploit the parity check functions from both graphs. During decoding each graph, a $\sqrt{N}$-times parallelism gain is obtained thanks to the fully parallel decoding of inner component codes. Extrinsic information output of these component codes is iteratively exchanged until reaching a consensus. We will show next that various types of soft-output decoders can be implemented to trade off between performance and decoding latency.

II-A Soft-output decoders for inner codes

Since each inner component code is itself a short $G_{N}$-coset code, it is feasible to adopt low complexity SC-based decoders[7, 8] as follows.

• •

Type-1: Soft-output SC list decoder provides the best performance but has the highest complexity and latency. A Chase-like algorithm [11] is used to generate soft LLR estimation from the decoding paths.

• •

Type-2: Soft-output SC permutation list decoder runs several permuted SC decoders in parallel. These independent SC decoders requires no sorting, thus is faster than the SC list decoder. The same Chase-like soft LLR generation method is used.

• •

Type-3: Soft cancellation decoder [13] can directly output soft LLRs. It has the smallest complexity and latency.

The above SC-based component decoders imply that the inner component codes could be constructed as polar codes. Specifically, we may decode the inner codes using SC list $L$ decoders (Type-1). A recently proposed SC permutation list decoding method [9, 10] can also be adopted (Type-2). Specifically, for each inner component code, we perform SC decoding in parallel on $L$ permuted codewords. It does not involve any sorting operations among the list paths, therefore can further improve the parallelism and reduce latency within each component code. Either way, for the $i$-th inner code, we obtain $L$ estimated codewords denoted by $\textbf{x}_{i}^{l}=\{{\hat{x}}^{l}_{i,1},{\hat{x}}^{l}_{i,2},...,{\hat{x}}^{l}_{i,\sqrt{N}}\}$ for $l\in\{1,2,...,L\}$. The decoding results are then used to calculate the extrinsic information about code bits as follows. For each estimated codeword, a mean square error is calculated as follows:

[TABLE]

Then, inspired by Chase decoding[11], we take $M_{i}^{l}$ as the path metric to calculate the soft output $T_{i,j}^{t}$:

[TABLE]

When the decoded bits ${\hat{x}}^{l}_{i,j}$ are the same in all the $L$ estimated codewords, it means that the bit value is very likely to be correct and thus the soft output output $T_{i,j}^{t}$ is simply set to a large value.

The soft cancellation decoder (Type-3), proposed in [13], can also be adopted as the inner code decoder. This algorithm can produce (extrinsic) reliability information for the estimated code bits in a much simpler way. Specifically, only soft decisions are made and propagated in the factor graph following the same scheduling as an SC decoder. It does not require to maintain $L$ list paths as the SC list and SC permutation list decoders do. Therefore, the soft cancellation decoder has a latency similar to an SC decoder, and requires much smaller memory than the previous two list decoders.

III code construction principle for the stage-permuted decoder

As discussed, the extrinsic information from the inner code decoders are exchanged between the two graphs during the decoding. Therefore, the decoding performance of inner codes is essential for the overall performance. This requires specific code constructions (different from both polar and RM principles), as elaborated in the following example.

Consider a length-16 $G_{N}$-coset code consisting of four length-4 component codes. Assume that an outer component code has one information bit. As shown in Fig. 2(a), either RM or polar principle would request the last bit to be selected as the information bit[12]. As a result, all code bits are unknown and thus regarded as information bits of the inner component codes. In other words, the inner code rates become higher, leading to poorer performance of the corresponding inner component decoders.

In contrast, consider the case that the third bit be the information bit. As shown in Fig. 2(b), two of the code bits are known bits (set to [math]). For the inner component codes, these two code bits become frozen bits and thus reduce the code rate of inner codes.

This example demonstrates the disadvantage of RM/polar principle, and illustrates the heuristic of our code construction algorithm. In the following, we propose an information set selection rule that maximally reduces the inner code rates.

III-A Choose information set for $K=k^{2}$

The construction involves two steps:

$(\sqrt{N},k)$ component codes: since we proposed SC-based decoders for the inner codes, the ideal construction is a $(\sqrt{N},k)$ short polar code. Denote by $P=[p_{1},p_{2},...,p_{\sqrt{N}}]$ the information vector:

[TABLE] 2. 2.

$G_{N}$-coset codes: denote by $I$ the information vector of the stage-permuted $G_{N}$-coset codes. It can be derived from $P$ as follows:

[TABLE]

For example, consider a $(16,9)$ stage-permuted $G_{N}$-coset code construction. In the first step, we construct a $(4,3)$ polar code. The information vector $P$ is as follows:

[TABLE]

Then, the information vector $I$ of the stage-permuted $G_{N}$-coset code is obtained as follows:

[TABLE]

Compared with polar and RM constructions, this code construction reduces the perceived coding rates at the inner components decoders. All the inner component codes have the same information vector $P$. Since $P$ is constructed by the polar principle, inner component codes are efficiently decoded by SC-based decoders.

With either polar or RM principle to construct a $G_{N}$-coset code, several information bits would be allocated to consecutive bit positions at the ending part of an information block. This would significantly degrade the performance if a stage-permuted turbo-like decoder is applied, because they might as well yield all-rate-1 inner component codes. Fig. 3 provides a numerical simulation result to support this assertion. As expected, our code construction principle to avoid higher coding rate for inner codes generates better performance than both polar and RM ones if the stage-permuted turbo-like decoder is applied.

III-B General code construction

To construct an $(N,K)$ code, we first construct an $(N,K_{1})$ stage-permuted $G_{N}$-coset code according to the previous subsection, where $K_{1}\triangleq\lceil{\sqrt{K}}\rceil^{2}$ is the first square number larger than $K$. Then, among the $K_{1}$ information bit positions, we additionally freeze $K_{1}-K$ bit positions.

Unlike the polar principle that would freeze the $K_{1}-K$ least reliable bit positions, our heuristic construction reduces the code rates for the inner codes in an iterative way. In each iteration, we freeze one bit position that would reduce the inner code rate. This incremental freezing is performed alternately on the original decoding graph $\cal G$ and the stage-permuted decoding graph ${\cal G}_{\pi}$ until $K$ information bit positions are left. The details are given in Algorithm 2, Algorithm 3 and Algorithm 4, and explained as follows.

Firstly, we narrow down to the rate-reducing bit positions (RRBPs), which have the following property (also illustrated in Fig. 4). When an RRBP $u_{i}$ is freezed, at least one of the corresponding outer component code bits becomes a known bit, denoted by $x_{i}$. From the inner code’s perspective, bit $x_{i}$ is decoded as a frozen bit and thus reduces the code rate.

Secondly, we only freeze one bit position among the RRBPs in each iteration. When there are multiple RRBPs, we choose one RRBP $u_{i}$, such that the resultant frozen bit $x_{i}$ in the inner component codes has the least reliability $r_{i}$. As a result, the remaining information set of each inner component code is still optimal according to the polar principle, and thus can be efficiently decoded by SC-based decoders. The details are given in Algorithm 3 and Algorithm 4.

With the general algorithm, $G_{N}$-coset codes with arbitrary code rates can be constructed. The proposed method is designed such that the performance under the stage-permuted turbo-like decoder is optimized. The heuristic is to reduce the coding rate of the inner codes, as well as maximally preserving their sub-channel reliabilities.

IV Performance evaluation

In this section, we evaluate the performances and parallelism of several coding schemes. The coded symbols are modulated with binary phase-shift keying (BPSK) modulation and then transmitted over an additive white Gaussian noise (AWGN) channel.

The proposed $G_{N}$-coset codes are decoded by the stage-permuted decoding algorithms with 8 iterations. During the decoding of inner codes, the SC list 8 decoding algorithm (Type-1), the SC permutation algorithm with 8 permutations (Type-2), the soft successive cancellation algorithm (Type-3) are evaluated. In the simulations, the damping factors are set as follows. For the the SC list 8 decoding algorithm (Type-1) and SC permutation algorithm (Type-2), the damping factors $\alpha=[0.3,0.3,0.4,0.5,0.6,0.7,0.8,1]$. For the soft successive cancellation algorithm (Type-3), the damping factors $\alpha=[3/8,3/8,3/8,3/8,3/8,3/8,3/8,4/8]$.

We first evaluate the code construction with a square number of information bits. In the simulation, we construct $(65536,57121=239^{2})$ stage-permuted $G_{N}$-coset codes and then decode them with all types of decoding algorithms. Then, we evaluate the general code construction with $N=65536$ and $K=56121$.

Polar codes with different configurations are compared as benchmarks. In Scheme-1, the same number of information bits are encoded to a length-$65536$ polar code. This long code configuration obtains more coding gain but incurs larger decoding latency. In Scheme-2, 256 length-$256$ short polar codes are encoded and decoded in parallel. This short code configuration exhibits a similar degree of parallelism to ours, but suffers from performance loss. The polar codes are decoded by SC decoders and CRC-aided (CA with 19 CRC bits) SC list 8 decoders.

The block error rate (BLER) performances are provided in Fig. 5 and Fig. 6. Compared to Scheme-2, our scheme achieves significantly better performance. Compared to Scheme-1, our scheme achieves comparable error correction performance. However, the decoding latency of our scheme is much smaller than Scheme-1, as discussed below.

The decoding latency is evaluated with an ASIC implementation in a 16nm TSMC FinFET technology [14]. The required time steps of these coding schemes are given in Table I. It demonstrates that our scheme can significantly reduce the decoding latency thanks to the high degree of parallelism. Therefore, the proposed $G_{N}$-coset codes possess the benefits of both coding gain (comparable to that of Scheme-1) and parallelism (comparable to that of Scheme-2).

Finally, we compare the proposed three types of soft-output component decoders. With the Type-1 (SC list) component decoder, it achieves better decoding performance with more time steps. On the contrary, with the Type-2 (SC permutation list) and Type-3 (soft cancellation) component decoders, the required time steps can be reduced significantly. This only comes at a cost of 0.3 and 0.1 dB performance loss, respectively. The diverse choices of component decoders provide a flexible trade-off between performance and decoding latency to meet the requirements of various communication scenarios.

V Conclusion

We study the construction of $G_{N}$-coset codes decoded by a stage-permuted turbo-like decoding algorithm. Through stage permutation, the decoding algorithm can exploit the parity check functions from multiple equivalent factor graphs. Since only the inner code parts are decoded (in parallel) and the outer code processing is avoided, the decoding algorithm exhibits a higher degree of parallelism. Based on this decoding algorithm, we propose a new $G_{N}$-coset code construction for arbitrary information lengths and coding rates. The novel encoder-decoder framework is evaluated in terms of both performance and decoding latency. The simulations suggest that the constructed $G_{N}$-coset codes achieve comparable error correction performance to polar codes of the same length. The ASIC implementation evaluation verifies that the stage-permuted turbo-like decoding algorithm has a much lower decoding latency.