Soft Decision Decoding with Cyclic Information Set and the Decoder Architecture for Cyclic Codes

Abstract

The soft decision decoding algorithm for cyclic codes, especially the maximum likelihood (ML) decoding algorithm, can obtain significant performance superior to that of algebraic decoding, but the complexity is much higher. To deal with this problem, an improved soft decision decoding algorithm based on a cyclic information set and its efficient implementation architecture are proposed. This algorithm employs the property of the cyclic codes to generate a series of cyclic information sequences by circularly shifting, constructing the cyclic information set. Then, a limited number of candidate information sequences are efficiently generated using an iterative computation method, and the candidate codewords are generated using the very concise encoding method of the cyclic codes. Furthermore, the efficient hardware architecture based on systolic arrays is also proposed to generate candidate information sequences and to select the optimal candidate codewords. An emulation platform is constructed to verify the error correction performance and to determine the optimal decoder parameters. Emulation results indicate that, with appropriate parameter selection, the proposed decoding algorithm can achieve a bit error rate approaching the ML performance while maintaining low complexity.

1. Introduction

Interest in short block length codes has been rising recently, mainly due to emerging applications that require high reliability and low latency data transmission. Examples of such applications are machine-type communications in 5G/6G, the Internet of Things, smart metering networks, remote command links, and messaging services [1,2,3,4,5,6,7,8]. Short block length codes play a crucial role in satisfying the low latency requirements of 5G communication. However, for short block length codes, the necessary trade-off between good error correction performance and decoding complexity leads to a significant gap between error correction performance and the theoretical lower bound, and on the other hand, leads to a dearth of practical decoding solutions [9,10].

The cyclic codes, first proposed in the 1960s [11], can be soft decision decoded based on their code structure such as the trellis graph or the bit reliability [12,13,14,15,16]. Decoding algorithms based on the trellis graphs can approach the maximum likelihood (ML) soft decision decoding performance, but the decoding complexity is the main concern, especially when the code length n is not so small and the states grow exponentially with k or $n-k$, where k is the information bit number [12,13]. The generalized minimum distance decoding has a relatively low decoding complexity. However, the gap to the performance of the ML decoding could not be neglected [14,15]. The decoding schemes based on ordered statistics can approach ML performance and have recently become a hot topic, showing great potential in future wireless communications for short or moderate length codes [16,17]. The ordered statistic decoding (OSD) algorithm was proposed by Fossorier and Lin in [16]. The traditional algorithms based on ordered statistics need to find the most reliable basis (MRB), which involves sorting the soft information of all the bits and finding k independent columns of the generation matrix associated with the k most reliable bits [16]. In order to eliminate the burden of identifying the MRB, many efforts have been paid to reduce the complexity and some significant progress has been achieved [17]. The main ideas of the existing improved OSD algorithms include skipping and/or discarding unlikely test patterns to avoid unnecessary calculations [18,19,20,21,22,23,24,25,26]. A double re-encoding technique was proposed in [27]. Two groups of independent candidates are chosen for a particular class of rate-1/2 systematic block codes. Without using the MRB, this method only needs a few candidate codewords, which is practical for hardware implementation [28,29]. The application of the OSD algorithms for short codes in wireless communications, especially the ultra-reliable and low latency communication (URLLC), has also been investigated [30,31,32].

Decoder architectures of all kinds of decoding algorithms, including the soft decision decoding algorithms, have also been comprehensively evaluated. As a classical example, the Golay code is popular for its perfect structure and good error correction capability. Many important decoding algorithms have been proposed for Golay codes in various application scenarios [33,34,35,36,37,38]. Besides the traditional URLLC applications, the code was also applied in some other new scenarios [39,40]. There are many decoder examples for Golay codes [41,42,43,44]. For example, Sarangi et al. proposed a decoder for extended binary Golay codes based on the incomplete ML decoding scheme with low latency and low complexity [41]. Reviriego et al. exploited the properties of the Golay code to implement a parallel decoder that corrects single and double-adjacent errors [42]. Short BCH codes are another type of important block code suitable for soft decision decoding. Their implementation architectures have also been proposed [45,46,47,48,49]. In [50,51], the implementations of soft decision decoding of a Golay code fully based on channel observation values were presented, which can achieve a performance close to ML performance. However, the complexity is much higher compared with some decoders using hard decision results. Therefore, in this paper, we choose the Golay code and several BCH codes as examples to evaluate the proposed decoding algorithm and decoder architecture.

Inspired by the permutation decoding algorithms [52,53,54], a new soft decision decoding algorithm, which utilizes a cyclic information set, is proposed in this paper. The proposed method is based on the cyclic property of cyclic block codes to generate the information set, which is suitable for hardware implementation, thereby the MRB is not needed. Furthermore, an efficient hardware implementation architecture is also designed to reduce the complexity of generating candidate codewords and selecting the most possible member. The decoders for several cyclic codes are implemented on the hardware platform and the performance of the proposed algorithm is verified. Experimental results demonstrate that the proposed decoding algorithm shows the error correction performance close to that of the ML decoding. It can achieve a good trade-off between complexity and performance, which renders this new decoding algorithm to be quite practical. The key parameters of the decoding algorithm are also optimized based on the hardware platform. The proposed soft decision decoding algorithm can make full use of channel information and provide a significant performance improvement compared with the algebraic decoding. In summary, our contributions lie in two points. First, the proposed algorithm employs the cyclic property of cyclic block codes, enabling the utilization of a uniform systematic generator matrix in re-encoding, which can eliminate the complex transformation to obtain the new generator matrices. Then, the hardware implementation is based on the systolic array architecture, which has low complexity and short critical paths. It offers the ability to arbitrarily set the number of information sequences and candidate codewords, supporting a flexible range of applications.

The rest of this paper is organized as follows. Section 2 introduces the calculation method of the metric used in the proposed soft decision decoding of cyclic codes. The proposed soft decision decoding algorithm based on the cyclic information set is illustrated in Section 3. Section 4 presents the efficient hardware implementation architecture of the proposed soft decision decoding algorithm. The verification and parameter optimization of the algorithm based on the hardware platform are presented in Section 5. Finally, conclusions are drawn in Section 6.

2. Metrics for the Proposed Soft Decision Decoding

In this paper, for cyclic codes, a binary phase shift keying (BPSK) constellation is transmitted over an additive white Gaussian noise (AWGN) channel. Soft decision decoding metrics commonly used include the likelihood function, Euclidean distance, correlation, correlation discrepancy, etc. In the proposed decoding algorithm, the correlation discrepancy is adopted as the decoding metric [12].

Let $\mathit{r}=\left(r_0,r_1,\dots ,r_{n-1}\right)$ denote the received soft information sequence and $\mathit{v}=\left(v_0,v_1,\dots ,v_{n-1}\right)$ represent an arbitrary codeword, where n is the code length. The log-likelihood function of $\mathit{r}$ is expressed as

$$logP\left(\mathit{r}\left|\mathit{v}\right.\right)=\sum _{i=0}^{n-1}logP\left(r_i\left|v_i\right.\right).$$

(1)

If the log-likelihoodfunction is used as the decoding metric, the soft decision ML decoding algorithm selects the codeword $\mathit{v}$ with the largest $logP(\mathit{r}\left|\mathit{v}\right)$.

For the AWGN channel with a bilateral power spectral density of $N_0/2$, the conditional probability $P\left(\mathit{r}\left|\mathit{v}\right.\right)$ is given by

$$P\left(\mathit{r}\left|\mathit{v}\right.\right)=\frac{1}{{\left(\pi N_0\right)}^{-\pi /2}}exp\left[-\sum _{i=0}^{n-1}{\left(r_i-c_i\right)}^2/N_0\right],$$

(2)

where $c_i$ is a BPSK symbol mapped by $v_i$, satisfying $c_i=1-2v_i$ [12], i.e.,

$$\left\{\begin{array}{cc}{c}_i=-1,\hfill & v_i=1,\hfill \\ c_i=1,\hfill & v_i=0,\hfill \end{array}\right.$$

(3)

where $\mathit{c}=(c_0,c_1,\cdots ,c_{n-1})$ is a symbol sequence for BPSK modulation mapped by $\mathit{v}$. The summation term in (2) is called the squared Euclidean distance between the received sequence $\mathit{r}$ and the codeword $\mathit{c}$. It is denoted as $d_E^2(\mathit{r},\mathit{c})$, i.e.,

$$d_E^2\left(\mathit{r},\mathit{c}\right)=\sum _{i=0}^{n-1}{\left(r_i-c_i\right)}^2.$$

(4)

Obviously, to maximize $logP\left(\mathit{r}\left|\mathit{v}\right.\right)$ is equivalent to minimizing $d_E^2(\mathit{r},\mathit{c})$. Extend the expression on the right side of (4), that is,

$$d_E^2\left(\mathit{r},\mathit{c}\right)=\sum _{i=0}^{n-1}{r}_i^2+n-2\sum _{i=0}^{n-1}{r}_i·c_i.$$

(5)

Define the summation term as a correlation between $\mathit{r}$ and $\mathit{c}$, denoted as $m(\mathit{r},\mathit{c})$ [12], that is,

$$m\left(\mathit{r},\mathit{c}\right)=\sum _{i=0}^{n-1}{r}_i·c_i.$$

(6)

Then, it can be rewritten as [12]

$$m\left(\mathit{r},\mathit{c}\right)=\sum _{i=0}^{n-1}\left|r_i\right|-2\sum _{i:r_i·c_i<0}\left|r_i\right|.$$

(7)

Similarly, finding the maximum value of $m(\mathit{r},\mathit{c})$ is equivalent to finding the minimum value of the second summation term in (7). Define the summation term as the correlation discrepancy between $\mathit{r}$ and $\mathit{c}$, denoted as $\lambda (\mathit{r},\mathit{c})$ [12], i.e.,

$$\lambda \left(\mathit{r},\mathit{c}\right)=\sum _{i:r_i·c_i<0}\left|r_i\right|=\sum _{i:u_i\oplus v_i=1}\left|r_i\right|,$$

(8)

where $u_i$ is the hard decision result of $r_i$, satisfying

$$\left\{\begin{array}{cc}{u}_i=-1,\hfill & r_i\ge 0,\hfill \\ u_i=1,\hfill & r_i<0,\hfill \end{array}\right.$$

(9)

$\mathit{u}=(u_0,u_1,\cdots ,u_{n-1})$ is the binary sequence obtained after hard decision for $\mathit{r}$.

3. Soft Decision Decoding Algorithm Based on Cyclic Information Set

A low complexity soft decision decoding algorithm based on a series of cyclic information sequences, called an information set, is proposed in this paper. The proposed decoding procedure is decomposed into two steps. First, using the cyclic property of cyclic codes, generate predetermined multiple cyclic information sequences, which form the cyclic information set. Then, a group of C candidates for each information sequence is tested to find the most possible codeword.

3.1. The Proposed Soft Decision Decoding Algorithm

In this paper, multiple information sequences are used for re-encoding to generate the candidate codewords. We generate the information set using the cyclic property of the cyclic codes. The proposed soft decision decoding algorithm is depicted in Figure 1. Assuming that the received soft information sequence is $\mathit{r}=(r_0,r_1,\cdots ,r_{n-1})$. First, the $(I-1)$ circular shifts are performed on $\mathit{r}$ to obtain n-dimensional soft information sequences ${\mathit{r}}^{\left(i_1\right)},{\mathit{r}}^{\left(i_2\right)},\cdots ,{\mathit{r}}^{\left(i_{I-1}\right)}$, where $i_1,i_2,\cdots i_{I-1}$ denote the number of circular shifts. Then, the first k components in $\mathit{r}$, ${\mathit{r}}^{\left(i_1\right)},{\mathit{r}}^{\left(i_2\right)},\cdots ,{\mathit{r}}^{\left(i_{I-1}\right)}$ are selected to form the k-dimensional sequences ${\mathit{m}}^{\left(0\right)},{\mathit{m}}^{\left(i_1\right)},\cdots ,{\mathit{m}}^{\left(i_{I-1}\right)}$, namely the information sequences. The information sequences represent the equivalent information bits in the codewords. The process of generating multiple information sequences by circularly shifting is shown in Figure 2. For each information sequence ${\mathit{m}}^{\left(i\right)}$, a group of k-dimensional sequences with the minimum correlation discrepancy to ${\mathit{m}}^{\left(i\right)}$ are obtained, denoted as ${\mathit{s}}_j^{\left(i\right)}(1\le j\le C)$, where the correlation discrepancy is calculated by the hard decision of the corresponding information sequence. All candidate information sequences are encoded to yield $I·C$ candidate codewords via the cyclic encoding method. In essence, the codewords of the cyclic code are still legitimate after circular shifting. The information sequence corresponding to each candidate information sequence is obtained by the circular shifting of ${\mathit{r}}^{\left(i\right)}$. The simple encoding circuits of cyclic codes can be used to encode the candidate information sequence based on the encoder using shift-registers [12]. This method saved the burden of computing the new generator matrices. Finally, the candidate codeword with the minimum correlation discrepancy to the corresponding information sequence in the received channel observation soft information sequence $\mathit{r},{\mathit{r}}^{\left(i_1\right)},{\mathit{r}}^{\left(i_2\right)},\cdots ,{\mathit{r}}^{\left(i_{I-1}\right)}$ is selected as the optimal candidate codeword. If the candidate codeword is generated by the information sequence ${\mathit{m}}^{\left(0\right)}=\mathit{m}$ from $\mathit{r}$, it is directly selected as the optimal decoding result. Otherwise, the candidate codeword needs to be circularly shifted to obtain the optimal decoding result. The four main steps of the algorithm are summarized in Algorithm 1.

Algorithm 1 The soft decision decoding algorithm based on cyclic information set

Input: the received soft information sequence $\mathit{r}=(r_0,r_1,\cdots ,r_{n-1})$. Output: the optimal decoding result. 1. Generate I independent information sequences.     1.1 Circularly shift $\mathit{r}$ uniformly, and obtain ${\mathit{r}}^{\left(i_1\right)},{\mathit{r}}^{\left(i_2\right)},\cdots ,{\mathit{r}}^{\left(i_{I-1}\right)}$.     1.2 Take the first k components of $\{\mathit{r},{\mathit{r}}^{\left(i_1\right)},{\mathit{r}}^{\left(i_2\right)},\cdots ,{\mathit{r}}^{\left(i_{I-1}\right)}\}$ to generate the information sequences ${\mathit{m}}^{\left(0\right)},{\mathit{m}}^{\left(i_1\right)},\cdots ,{\mathit{m}}^{\left(i_{I-1}\right)}$. 2. For each information sequence ${\mathit{m}}^{\left(i\right)}$, generate C candidate information sequences with the minimum correlation discrepancy, i.e., ${\mathit{s}}_1^{\left(i\right)},{\mathit{s}}_2^{\left(i\right)},\cdots ,{\mathit{s}}_C^{\left(i\right)}$. 3. Encode the candidate sequences to obtain candidate codewords. 4. Select the optimal candidate codeword and make a decision.     4.1 Select the candidate codeword with the minimum correlation discrepancy and obtain the associated information sequence in $\{\mathit{r},{\mathit{r}}^{\left(i_1\right)},{\mathit{r}}^{\left(i_2\right)},\cdots ,{\mathit{r}}^{\left(i_{I-1}\right)}\}$.     4.2 If the codeword is generated by ${\mathit{m}}^{\left(0\right)}=\mathit{m}$, it is directly used as the decoding result. Otherwise, it is circularly shifted to obtain the decoding result.

In the proposed soft decision decoding algorithm, the correlation discrepancy is used as a metric to generate the candidate sequence and select the optimal candidate codeword. First, I information sequences are generated using cyclic shifting, and for each information sequence, the C nearest sequences in correlation discrepancy are selected as candidate information sequences. Then, the list of candidate codewords is established using the concise cyclic encoding method. Finally, the candidate codeword having the minimum correlation discrepancy with the received soft information sequence $\mathit{r}$ is selected as the decoding result. The size of the candidate codeword list is reduced from $2^k$ to $I·C$ based on the minimum correlation discrepancy, which can effectively reduce the search range of the decoding results. Meanwhile, for each information sequence, it only needs to calculate the correlation discrepancy of the two k-dimensional sequences once, and calculate the $(n-k)$-dimensional correlation discrepancy for C times. The proposed algorithm avoids the complex calculation and sorting of the correlation discrepancy between all $2^k$ binary k-dimensional sequences compared with the ML decoding.

3.2. Efficient Iterative Generating Method for Adjacent Candidate Sequences

The generation of the candidate information sequences and the metric calculation of candidate codewords are the main steps and have high computation complexity in the proposed soft decision decoding algorithm. For each information sequence, we only need to generate a small number, denoted as C, of candidate information sequences to generate candidate codewords. Among all the $2^k$ members, the candidate information sequences include C members, which have the most minimal correlation discrepancy with the information sequence.

Aiming at reducing the complexity of generating candidate information sequences, an iterative algorithm is adopted to generate the candidate information sequence in this paper. This method avoids calculating the correlation discrepancies of all $2^k$ sequences and sorting all the correlation discrepancies. This algorithm is first employed to calculate the log-likelihood ratio of non-binary symbols for non-binary low density parity check (LDPC) codes [55]. In this paper, this method is extended for the generation of candidate information sequences with some modifications.

The algorithm works in the iterative mode with a total of k iterations. In the d-th iteration, the subsequence ${\mathit{m}}_d=(m_0,m_1,\cdots ,m_{d-1})$, consisting of the first d components of the information sequence, needs to be considered. The set ${\phi }_d$ of the two-dimensional variables represents the generated partial binary sequence and its correlation discrepancy with ${\mathit{m}}_d$. If $d=1$, ${\phi }_1=\{(u_0,0),({\overline{u}}_0,\left|m_0\right|)\}$, where $u_0$ represents the hard decision result of $m_0$, ${\overline{u}}_0$ represents the negative of $u_0$. The calculation in the d-th iteration is divided into two steps. Take the l-th pair of elements, ${\phi }_d^0\left(l\right)$ and ${\phi }_d^1\left(l\right)$, as an example. Each element is expanded into two elements according to the d-th component $m_{d-1}$ of the information sequence and the hard decision result $u_{d-1}$. Extending the l-th element $({\mathit{s}}_l^{(d-1)},\lambda ({\mathit{m}}_{d-1},{\mathit{s}}_l^{(d-1)}))$ in ${\phi }_{d-1}$ to two elements ${\phi }_d^0\left(l\right)$ and ${\phi }_d^1\left(l\right)$ can be specifically expressed as

$$\left\{\begin{array}{c}{\phi }_d^0\left(l\right)=({\mathit{s}}_l^{(d-1)}\&u_{d-1},\lambda ({\mathit{m}}_{d-1},{\mathit{s}}_l^{(d-1)})),\hfill \\ {\phi }_d^1\left(l\right)=({\mathit{s}}_l^{(d-1)}\&{\overline{u}}_{d-1},\lambda ({\mathit{m}}_{d-1},{\mathit{s}}_l^{(d-1)})+\left|m_{d-1}\right|),\hfill \end{array}\right.$$

(10)

where ‘&’ is the concatenation operation of two binary sequences. The two-dimensional variable sets ${\phi }_d^0$ and ${\phi }_d^1$ extended by ${\phi }_{d-1}$ can be obtained by calculating all ${\phi }_d^0\left(l\right)$ and ${\phi }_d^1\left(l\right)$.

Then, the two sets ${\phi }_d^0$ and ${\phi }_d^1$ are merged to construct a new set ${\phi }_d$. It should be ensured that the elements in ${\phi }_d$ are arranged in descending order of the correlation discrepancy value. Considering that the algorithm is iterative, the elements in ${\phi }_d^0$ and ${\phi }_d^1$ are also in descending order. Therefore, only the first elements of the two sets that have not been placed into ${\phi }_d$ need to be compared and the element with smaller correlation discrepancy is put into the set ${\phi }_d$. When the number of elements in ${\phi }_d$ reaches the required number of candidate codewords, the construction of ${\phi }_d$ is stopped. After the k-th iteration, the first dimension component of each element in the obtained set ${\phi }_k$ constitutes C candidate sequences. The two main steps in the iterative algorithm are described in Algorithm 2.

The candidate information sequences are the sequences with the minimum distance (correlation discrepancy) to the information sequence. In the extending process, the correlation discrepancy metric of the extended sequences may become larger and larger, and it is impossible to be a candidate sequence. Thus, discarding these sequences does not affect the results of the candidate information sequence generation. The discarding process significantly reduces the complexity of generating the candidate information sequences, because the number of calculations and comparisons of the correlation discrepancy is reduced, especially for cyclic codes of long code length.

Algorithm 2 The d-th iteration of the candidate sequence generating algorithm

Input: the set ${\phi }_{d-1}$ of the $(d-1)$ iteration, the absolute value $\left|m_{d-1}\right|$ of the d-th component of the information sequence, and the hard decision result $u_{d-1}$. Output: the set ${\phi }_d.$ 1. Extend the set ${\phi }_{d-1}$ to ${\phi }_d^0$ and ${\phi }_d^1$.     1.1 Add $u_{d-1}$ to the binary sequence of each element in ${\phi }_{d-1}$ and obtain the set ${\phi }_d^0$.     1.2 Add the negative of $u_{d-1}$, i.e., ${\overline{u}}_{d-1}$ to the binary sequence of each element in ${\phi }_{d-1}$. Update the correlation discrepancy of each element to the result of adding $\left|m_{d-1}\right|$ and obtain the set ${\phi }_d^1$. 2. Construct the set ${\phi }_d$.     2.1 Combine ${\phi }_d^0$ and ${\phi }_d^1$, i.e., ${\phi }_d={\phi }_d^0\cup {\phi }_d^1$.     2.2 Compare the number of elements in ${\phi }_d$ with required number C, if $\left|{\phi }_d\right|\le C$, all the elements form ${\phi }_d$, otherwise, goto step 2.3.     2.3 Compare the elements of the two sets, ${\phi }_d^0$ and ${\phi }_d^1$, and output C elements with the smallest correlation discrepancy, obtaining a new set ${\phi }_d$.

4. The Architecture and Complexity Analysis of the Proposed Decoder

In this section, based on the proposed soft decision decoding algorithm, the decoder implementation for hardware evaluation is designed in a serial mode. Two key components in the decoder, the candidate sequence generator and the correlation discrepancy calculation unit, are both implemented based on the systolic arrays, which have lower complexity and reduce the length of the critical path. Furthermore, the implementation complexity of the proposed decoder is analyzed.

4.1. Proposed Decoder Architecture

The overall architecture of the proposed soft decision decoder is shown in Figure 3. The decoder includes five modules. The soft information register is used to store soft information from the demodulator and perform cyclic shifting to obtain the different information sequences, that is, the information set. The following decoding operations are repeated according to the cardinality of the information set, and finally the candidate codeword with the minimum correlation discrepancy is selected as the decoding output. As described in Section 3, the candidate sequence generator, the re-encoding unit, the correlation discrepancy calculation unit, and the decoding result update unit work in the sequential manner.

The decoding process is explained as follows. The soft information sequence $\mathit{r}$ from the demodulator is first buffered in the soft information register. Then, the first k components, i.e., the soft information corresponding to the information bits, are output to the candidate sequence generator to construct a series of candidate information sequences. Next, the re-encoding unit encodes the candidate information sequences to obtain the candidate codewords. The residual $(n-k)$ components of $\mathit{r}$ are output to the correlation discrepancy calculation unit for calculating the correlation discrepancy of each candidate codeword. The candidate codeword and its correlation discrepancy are computed serially. After the candidate codewords and the corresponding correlation discrepancies are input into the decoding result update unit, the register is used to circularly shift the buffered candidate codeword. When all the operations for a single information sequence are completed, the soft information register performs a cyclic shift on the buffered data to generate another new information sequence. In this way, the operations for each information sequence are repeated. After all the I information sequences are processed, the final decoding output is obtained in the decoding result update unit.

Among all the modules of the decoder, the candidate sequence generator and the correlation discrepancy calculation unit need to be carefully designed. For the candidate sequence generator, the iterative algorithm can significantly reduce the number of comparison operations and thus reduce the overall implementation complexity. For the correlation discrepancy computation unit, the complexity of the direct summation computation is high. In our design, we consider the systolic array architecture for the two modules. The systolic array architecture is composed of several modules working in pipeline mode, and each module is called a Processing Element (PE).

4.2. Architecture of the Candidate Sequence Generator

The candidate sequence generator can generate the candidate information sequences and corresponding k-dimensional correlation discrepancy for subsequent modules, according to the channel observation values ${\mathit{r}}^{\mathit{i}}$. As shown in Figure 4, the systolic array architecture consists of k cascaded PEs working in a sequential manner based on Algorithm 2. For the candidate sequence generator architecture, the j-th components of the received soft information sequence are connected to the j-th PE and the overall generation starts with the first PE corresponding to $m_0$. The input of the first PE is the preset initial value, and the output is connected to the next PE. For the d-th iteration $(2\le d\le k)$, the d-th PE has two inputs, the first $(d-1)$ components of the soft information sequence $m_{d-1}$ with its hard decision result $u_{d-1}$, and the list ${\phi }_{d-1}$ including the intermediate d-dimensional candidate sequence with its correlation discrepancy from the $(d-1)$-th PE. For the output, the d-th PE generates the list ${\phi }_d$ and transfers it to the $(d+1)$-th PE of the next stage, until the output of the k-th PE constitutes the generator output, where k is the information sequence length.

The PE is the core of the candidate sequence generator. It consists of two expansion modules, two First-In-First-Out (FIFO) memories, and one comparator, which selects the minimum of the two FIFO outputs. The d-th PE is shown in Figure 4, where the input and output represent the intermediate candidate sequence generation. The d-th PE serially receives the ordered list ${\phi }_{d-1}$ from $(d-1)$-th stage one by one. The first step is the expansion of ${\phi }_{d-1}$ into ${\phi }_d^0$ and ${\phi }_d^1$, as described in the previous section. Once the first elements ${\phi }_d^0$ and ${\phi }_d^1$ are stored in the FIFOs, the merging process starts. In each clock cycle, the outputs of the two FIFOs are compared, and the one with the smaller correlation discrepancy value is selected to be fed into the list ${\phi }_d$. Simultaneously, the pull signal is set to 1 to allow a new couple at the output of the FIFOs.

The setting of the depth of two FIFOs per stage considers the worst case, that is, all couples of ${\phi }_d$ are retrieved from one FIFO. Therefore, the depth of the FIFO in the d-th PE is equal to the number of couples in the output ${\phi }_d$ of the stage. According to the previous section, if the stage label d satisfies $2^{d-1}>C$, the depth of the FIFO is set to C, otherwise, the depth of the FIFO is $2^{d-1}$. After the last PE outputs C candidate information sequences, all of the FIFOs will be cleared and the candidate sequence generation is completed.

4.3. Architecture of the Correlation Discrepancy Calculation Unit

The correlation discrepancy calculation unit computes the correlation discrepancy between candidate codeword ${\mathit{v}}_l=(v_{l,0},v_{l,1},\cdots ,v_{l,n-1}),(1\le l\le C)$ and the received soft information sequence ${\mathit{r}}^{\left(i\right)}=(r_0^{\left(i\right)},r_1^{\left(i\right)},\cdots ,r_{n-1}^{\left(i\right)})$. To simplify the hardware implementation, we consider the calculation of the correlation discrepancy corresponding to the part of the first k bits and the part of the last $(n-k)$ bits. The formula for calculating the correlation discrepancy can be expressed as

$$\lambda ({\mathit{r}}^{\left(i\right)},{\mathit{v}}_l) =\sum _{j:u_j^{\left(i\right)}\oplus v_{j,l}=1}^{}|r_j^{\left(i\right)}|=\sum _{j=0}^{k-1}|r_j^{\left(i\right)}|\times \left(u_j^{\left(i\right)}\oplus v_{l,j}\right)+\sum _{j=k}^{n-1}|r_j^{\left(i\right)}|\times \left(u_j^{\left(i\right)}\oplus v_{l,j}\right),$$

(11)

or concisely denoted as

$$\lambda \left({\mathit{r}}^{\left(i\right)},{\mathit{v}}_l\right)=\lambda \left({\mathit{m}}^{\left(i\right)},{\mathit{s}}_l\right)+\lambda \left({\mathit{p}}^{\left(i\right)},{\mathit{q}}_l\right).$$

(12)

Here, ${\mathit{r}}^{\left(i\right)}=({\mathit{m}}^{\left(i\right)},{\mathit{p}}^{\left(i\right)})$. ${\mathit{u}}^{\left(i\right)}=(u_0^{\left(i\right)},u_1^{\left(i\right)},\cdots ,u_{n-1}^{\left(i\right)})$ is the hard decision result of ${\mathit{r}}^{\left(i\right)}$. The soft information sequence associated to the information bits is denoted as ${\mathit{m}}^{\left(i\right)}$, i.e., ${\mathit{m}}^{\left(i\right)}=(r_0^{\left(i\right)},r_1^{\left(i\right)},\cdots ,r_{k-1}^{\left(i\right)})$, while ${\mathit{p}}^{\left(i\right)}=(r_k^{\left(i\right)},r_{k+1}^{\left(i\right)},\cdots ,r_{n-1}^{\left(i\right)})$ is the part of the soft information sequence associated to the parity-check bits. Similarly, the candidate codeword ${\mathit{v}}_l$ is denoted as ${\mathit{v}}_l=({\mathit{s}}_l,{\mathit{q}}_l)$. ${\mathit{s}}_l$ denotes the candidate information sequence associated with the information bits and ${\mathit{s}}_l=(v_{l,0},v_{l,1},\cdots ,v_{l,k-1})$, while ${\mathit{q}}_l=(v_{l,k},v_{l,k+1},\cdots ,v_{l,n-1})$.

It can be observed that the first term in Equation (12) is the correlation discrepancy between the information sequence and the corresponding candidate sequence. The correlation discrepancy calculation unit only needs to calculate the second term $\lambda ({\mathit{p}}^{\left(i\right)},{\mathit{q}}_l)$.

Considering the high computation complexity, our proposed correlation discrepancy calculation unit uses a systolic array architecture for sequential calculation. The architecture is shown in Figure 5, which consists of $(n-k)$ identical PEs. Taking the d-th PE as an example, the inputs are the soft information $r_{k+d-1}^{\left(i\right)}$ with its corresponding hard decision result $u_{k+d-1}^{\left(i\right)}$ and the list ${\xi }_{d-1}$ from the previous PE. The d-th PE generates the list ${\xi }_d$ as an output that is serially sent to the $(d+1)$-th PE of the next stage. ${\xi }_d$ ($0\le d\le n-k$) is a set containing C two-dimensional variables. The l-th two-dimensional variable of the set can be expressed as

$${\xi }_d\left(l\right)=\left\{\begin{array}{c}\left({\mathit{v}}_l,\lambda \left({\mathit{m}}^{\left(\mathit{i}\right)},{\mathit{s}}_l\right)\right), d=0.\hfill \\ \left({\mathit{v}}_l,\lambda \left({\mathit{m}}^{\left(\mathit{i}\right)},{\mathit{s}}_l\right)+{\displaystyle \sum _{j=k}^{k+d-1}}|r_j^{\left(i\right)}|\times \left(u_j^{\left(i\right)}\oplus v_{l,j}\right)\right),\hfill & 1\le d\le n-k.\hfill \end{array}\right.$$

(13)

In the Formula (13), the first dimension variable of ${\xi }_d\left(l\right)$ is the candidate codeword $v_l$, and the second dimension variable is the correlation discrepancy between the first $(k+d)$ components of ${\mathit{r}}^{\left(i\right)}$ and the first $(k+d)$ bits of ${\mathit{v}}_l$.

As shown in Figure 5, the architecture of the d-th PE is composed of an expansion unit, an XOR gate, and a data selector. The XOR operation generates the selection signal for the data selector. If $u_{k+d-1}^{\left(i\right)}\oplus v_{l,k+d-1}=0$, select $\left(0,u_{k+d-1}^{\left(i\right)}\right)$ to expand ${\xi }_{d-1}\left(l\right)$, otherwise, if $u_{k+d-1}^{\left(i\right)}\oplus v_{l,k+d-1}=1$, select $\left(|r_{k+d-1}^{\left(i\right)}|,{\overline{u}}_{k+d-1}^{\left(i\right)}\right)$ to expand ${\xi }_{d-1}\left(l\right)$ to obtain ${\xi }_d\left(l\right)$. The last PE serially outputs ${\xi }_{n-k}$, which is all candidate codewords and their correlation discrepancy with ${\mathit{r}}^{\left(i\right)}$.

4.4. Implementation Complexity of the Proposed Decoder

Considering that the OSD algorithm is the most efficient and classical algorithm nearly achieving the ML decoding performance, the complexity evaluation is based on the comparison between the proposed algorithm and the OSD algorithm. Compared with the order-t OSD algorithm of the k-dimensional sequences in [16], the proposed algorithm effectively reduces the computation complexity, as the number of all the tested candidate codewords, $I·C$, is smaller than ${\sum }_{i=0}^t\left(\begin{array}{c}k\\ i\end{array}\right)$. We utilize the (31, 21) BCH code as an example.

Table 1. The required candidate codewords for different decoding algorithms.

Decoding Algorithm	The Size of the Candidate Codeword List
The order-2 OSD [16]	232
The order-3 OSD [16]	1562
Proposed algorithm	80

shows the size of the candidate codeword list for different decoding algorithms. The (31, 21) BCH code only requires 80 candidate codewords under the appropriate parameters, and the corresponding parameter optimization will be shown in Section 5.2 below. The proposed decoding algorithm can effectively reduce the number of the candidate codewords, compared with the OSD algorithm.

For the re-encoding, the OSD algorithm needs to obtain the generator matrix for each candidate codeword through complex matrix operations. The proposed decoding algorithm employs the cyclic property of cyclic block codes, enabling the utilization of the uniform systematic generator matrix in re-encoding. The cyclic codes can be encoded using the very simple encoding circuits with shift-registers.

All our implementations are on the Vertex-5 LX 110T Field Programmable Gate Array (FPGA) (xc5vlx110t-1ff1136), and the synthesis software is the XST program of ISE 13.2, all by Xilinx Inc. This FPGA chip is mainly used for high-performance general logic applications, containing 17,280 configurable slices and 128 block RAM blocks (BRAMs), where each slice has 4 LUTs and 4 flips-flops. The proposed hardware architecture is implemented on the FPGA platform using different parameters. The proposed soft decision decoding algorithm contains two very important parameters, that is, the number of information sequences, I, and the number of candidate codewords, C. As I increases, the number of computation operations, required to generate a list of candidate codewords, increases linearly. Another advantage is that the systolic arrays operate in parallel, and the operations are only limited by the number of candidate codewords, C.

To illustrate the required hardware resources of the decoder,

Table 2. The required hardware resources for the proposed decoder.

Module	Candidate Sequence Generator	Re-Encoding Unit	Correlation Discrepancy Calculation Unit
Adder	$2k$	0	$(n-k)$
Comparators	k	0	$(n-k)$
XOR gates	0	$weight\left(g\right)$	$(n-k)$

presents the main units for the key modules. Here, $weight\left(g\right)$ is the weight of the generator polynomial for cyclic codes. The adder and comparators have the width of $(w+d)$ bits in the d-th PE. Furthermore, each processing element of the candidate sequence generator requires two FIFOs with the same size. In the d-th processing element ($d\le \lfloor {log}_{2}C\rfloor$), each FIFO has a width of $(w+d)$ bits and a depth of $\left\{2^{d-1},C\right\}$, where w is the quantization bit width of correlation discrepancy. The total storage space of the FIFOs (in bits) can be expressed as

$$M_F=2·(\sum _{i=1}^{\lfloor {log}_{2}C\rfloor }(2^{i-1}·(w+i))+\sum _{i=\lfloor {log}_{2}C\rfloor +1}^k(C·(w+i\left)\right)).$$

(14)

5. BER Performance Verification Based on Hardware Platform

For the proposed soft decision decoding algorithm and the decoder implementation architecture, we perform the performance verification and selection of the number of candidate codewords, C, and the number of information sequences, I, on the FPGAs. The FPGA emulation platform can effectively accelerate the evaluation of the error correction performance [56], and according to the BER performance, the two key parameters of decoders can be optimized. Several cyclic block codes are taken as examples, which are the (15, 5) BCH code, the (23, 12) Golay code, the (31, 21) BCH code, and the (63, 30) BCH code. All the decoders for these codes have been implemented on the FPGA (xc5vlx110t).

5.1. BER Performance of the Proposed Decoding Algorithm

We evaluate the bit error rate (BER) performances of the four cyclic codes with the proposed decoding algorithm using this platform, as shown in Figure 6. The BER performances of the four cyclic codes using the ML decoding are also presented [57]. It can be observed that at a BER of $10^{-5}$, only a little SNR degradation (<0.2 dB) occurred for the decoding algorithm using the cyclic information set. In addition,

Table 3. The SNR comparison for different cyclic codes.

Cyclic Code	$\mathbf{BER}={10}^{-4}$	$\mathbf{BER}={10}^{-5}$
(15, 5) BCH code	5.7 dB	6.6 dB
(31, 21) BCH code	4.9 dB	5.7 dB
(63, 30) BCH code	3.4 dB	4.2 dB
(23, 12) Golay code	4.8 dB	5.5 dB

provides the SNR required at different BERs. For the (63, 30) BCH code, it can achieve a BER of $10^{-5}$ when the SNR is only 4.2 dB. The simulation results show that the proposed soft decision decoders can obtain the performance close to that of ML decoding.

5.2. BER Performance of the Decoders with Different I and C

Figure 7, Figure 8 and Figure 9 present the bit error rates of (23, 12) Golay decoder, the (31, 21) BCH decoder, and the (63, 30) BCH decoder with different parameters, I and C. The hardware implementation results show that increasing the number of candidate codewords or information sets can significantly improve the decoding performance. As the number of information sequences I increases, the performance of the decoding algorithm improves. Similarly, when I is fixed, the performance of the decoding algorithm also improves with C. After reaching the target decoding performance, it tends to be flat. Furthermore, we presented the BER performance with $I·C$. It can be observed in Figure 7, Figure 8 and Figure 9 that the proposed algorithms can achieve targat performance using different combinations of I and C if the overall candidate codewords are enough to find the optimal. Some typical results are listed in

Table 4. Appropriate parameters selection for I and C when BER is about ${10}^{-4}$.

Cyclic Code	BER	I	C
(23, 12) Golay code	$9\times {10}^{-5}$	3	16
(31, 21) BCH code	$1.1\times {10}^{-4}$	2	64
(63, 30) BCH code	$7.3\times {10}^{-5}$	12	512

for convenience. The appropriate values of the parameters I and C can be obtained according to the simulation results. When the target decoding performance is satisfied, the parameters corresponding to the minimum $I·C$ are selected as the appropriate values to reduce the computational complexity. Table 4 presents the optimization results. With the BER performance of ${10}^{-4}$ as criterion, for the (23, 12) Golay code, the target performance can be achieved with only 48 candidate codewords ($I=3,C=16$).

6. Conclusions

A soft decision decoding algorithm based on a cyclic information set is proposed, and its efficient hardware implementation architecture is also presented. The algorithm employs the correlation discrepancy as the decoding metric and adopts an iterative computation method. Firstly, the cyclically generated equivalent information sequences, which have the minimum correlation discrepancy with the received sequence of channel observation values, are selected as the candidate information sequences. Then, the list of candidate codewords is encoded using the very concise encoder. Finally, the optimal decoding result is obtained by selecting the optimal candidate codeword using the correlation discrepancy metric. The method reduces the search range of the decoding results by establishing the list of candidate codewords in the cyclic and iterative manner, and the complexity is lower than the ML algorithm. Furthermore, in order to verify the performance of the decoding algorithm, the implementation architecture of the algorithm is completed on the FPGA platform. The BER performances of the (15, 5) BCH code, (31, 21) BCH code, (63, 30) BCH code, and (23, 12) Golay code are evaluated on this platform. The experimental results show that the performance of the proposed decoding algorithm is close to the ML algorithm, and the decoder achieves a good trade-off between decoding complexity and error correction performance. The effect of the number of information sequences and the candidate codewords on the decoding performance is also evaluated on the FPGA platform. The complexity of the decoder can be reduced by optimizing the number of information sequences and candidate codewords.

In this paper, we only evaluated the BER performance of the cyclic codes over the AWGN channel. In the future, considering short cyclic codes have been widely employed in 5G communications, it is valuable to evaluate the proposed decoding algorithm under the wireless fading channel, combined with advanced modulations or waveforms. In addition, the serial hardware implementation architecture has been utilized to verify the BER performance of the proposed algorithm. In the future, efficient parallel architectures will be developed to meet the higher throughput requirements of 5G, enabling practical applications.