Restart Mechanisms for the Successive-Cancellation List-Flip Decoding of Polar Codes

Abstract

Polar codes concatenated with a cyclic redundancy check (CRC) code have been selected in the 5G standard with the successive-cancellation list (SCL) of list size L = 8 as the baseline algorithm. Despite providing great error-correction performance, a large list size increases the hardware complexity of the SCL decoder. Alternatively, flip decoding algorithms were proposed to improve the error-correction performance with a low-complexity hardware implementation. The combination of list and flip algorithms, the successive-cancellation list flip (SCLF) and dynamic SCLF (DSCLF) algorithms, provides error-correction performance close to SCL-32 with a list size L = 2 and $T_{\max }$ = 300 maximum additional trials. However, these decoders have a variable execution time, a characteristic that poses a challenge to some practical applications. In this work, we propose a restart mechanism for list–flip algorithms that allows us to skip parts of the decoding computations without affecting the error-correction performance. We show that the restart location cannot realistically be allowed to occur at any location in a codeword as it would lead to an unreasonable memory overhead under DSCLF. Hence, we propose a mechanism where the possible restart locations are limited to a set and propose various construction methods for that set. The construction methods are compared, and the tradeoffs are discussed. For a polar code of length N = 1024 and rate ¼, under DSCLF decoding with a list size L = 2 and a maximum number of trials $T_{\max }$ = 300, our proposed approach is shown to reduce the average execution time by 41.7% with four restart locations at the cost of approximately 1.5% in memory overhead.

1. Introduction

Polar codes [1] are a class of linear block codes that were shown to asymptotically achieve the channel capacity under low-complexity successive-cancellation (SC) decoding as the code length tends to infinity [1]. However, the SC decoding algorithm does not provide sufficient error-correction performance at short-to-moderate code lengths. The concatenation of a cyclic redundancy check (CRC) code to the polar code results in the CRC-aided (CA)–polar code scheme; this scheme was selected to protect the control channel of the enhanced mobile broadband (eMBB) service in 5G [2]. SC does not take advantage of the CRC code.

Successive-cancellation list (SCL) decoding [3] was proposed to improve the error-correction performance of SC decoding. SCL decoding retains L decoding paths, providing L different candidates of a codeword. To achieve this, the number of paths is doubled, and when it reaches $2L$, the best L paths according to path metrics (PMs) are selected to continue the decoding. The true potential of the SCL decoding algorithm is highlighted with the CA–polar code scheme. The candidate with the smallest PM that verifies the CRC code is elected as the codeword estimate.

Another decoding algorithm for the CA–polar codes is the flip algorithm [4,5]. Unlike SCL decoding, successive-cancellation flip (SCF) and dynamic SCF (DSCF) sequentially attempt the decoding with a single SC instance, providing up to $T_{\max }$ candidates of a codeword. At each additional trial, one of the decision bits, based on a metric, is flipped during the course of SC decoding before normal decoding is resumed. DSCF better approximates the reliability of a decision, providing a more accurate list of bit-flipping candidates and improving the error-correction performance. Moreover, DSCF may also handle multiple bit flips per decoding trial. The latter requires a list of candidates that is dynamically updated along the decoding trials.

Successive-cancellation list flip (SCLF) decoding [6] combines the list and flip algorithms. Additional trials of SCLF correspond to the SCL algorithm having a reverse path selection on the path-flipping locations [7]. These locations are based on a flip metric computed during the initial SCL trial [8]. In [9], dynamic SCLF (DSCLF) decoding is proposed, which adapts the DSCF methodology to SCLF. That is, the metric that selects path-flipping locations is further improved, and the multi-path-flipping methodology of DSCF is adapted.

Since it combines list and flip algorithms, the algorithm is computationally complex and works according to the methodology outlined by [10,11,12,13,14,15], who investigated ways to reduce the complexity of the list–flip algorithm. In [10,11], a simplified metric and an adaptive list size L are proposed, allowing us to reduce the complexity of $L\ne 2$. A low-complexity flip metric allowing fast decoding of some special nodes is proposed in [12]. The fast implementation of the SCLF decoder is provided in [13], reducing up to $73.4$% of the average decoding latency for $N=512$ and $K=256$ codes. In [14], the number of additional trials is restricted to one, but this specific case can be improved with a more accurate method for locating the first error position. In [15], the authors created a scheme with early termination, average execution time reduction, and enhanced performance by protecting the codeword with multiple CRC codes. However, the total number of CRC bits is high and specific patterns are required.

Previously, we proposed restart mechanisms for SCF-based decoders [16,17]. The simplified restart mechanism (SRM) conditionally restarts SC decoding from the second half of the codeword if that is where the current bit-flipping candidate is located. The generalized restart mechanism (GRM) restarts SC decoding from any location of the bit-flipping candidate, which is achieved by storing the decoded codeword in its memory at the end of the initial unsuccessful decoding trial. It was shown that GRM is applicable to various types of SCF-based decoders. This work represents the continuation of [16,17] but for the list–flip algorithm. The restart mechanism for the list–flip decoder shown in this paper reduces the complexity less in comparison to the GRM, and we will show that embedding the GRM is impracticable for this decoder. Nevertheless, the complexity reduction is better with respect to the SRM, and the error-correction performance is not reduced.

Contributions

This work proposes the limited-locations restart mechanism (LLRM) for SCLF-based decoders for polar codes with the central idea to partially skip decoding computations that are identical between the initial trial and any additional trial. For any additional trial, the decoding restart is performed from one of the restart locations that is the closest to the path-flipping location from its right-hand side (RHS) in a codeword. The restart locations are determined offline, i.e., by conducting simulations at the target frame-error rate (FER). An LLRM does not alter the error-correction performance of the original decoder. During a restart, the decoding tree is calculated from its root and partial-sum (PS) bits are recalculated. Relevant path information required to retrieve the decoding tree is stored to memory. When applying the LLRM with four restart locations to the DSCLF decoder that can flip up to three paths per decoding trial, the average flip time reduction is 51% for $N=512$ and $K=128$ while requiring approximately $1.7\%$ of additional memory compared to the standard DSCLF decoder.

Outline

The remainder of this paper is organized as follows: Section 2 begins by introducing polar codes with SC decoding. Then, SCL, SCF, and SCLF decoders are described. Section 4 begins with a simulation-based statistical analysis that provides bit-flip location distributions. In Section 5, simulation results for SCLF and DSCLF decoders with LLRM, and previously proposed GRMs, for the standard scheme are provided. Comparisons are made in terms of error-correction performance, memory estimates, and average execution time.

2. Background

2.1. Construction of Polar Codes

An $(N,K)$ polar code [1] is a linear block code of length $N=2^n$ and code dimension K, defining the code rate $R_{code}=K/N$. Polar codes encode an input vector $\mathit{u}=[u_0,\dots ,u_{N-1}]$ to the codeword $\mathit{x}=[x_0,\dots ,x_{N-1}]$ as $\mathit{x}=\mathit{u}{{\mathit{T}}_{\mathbf{2}}}^{\otimes n}$ where ${{\mathit{T}}_{\mathbf{2}}}^{\otimes n}$ denotes the Kronecker power of the binary kernel ${\mathit{T}}_2=\left[\begin{array}{cc}1& 0\\ 1& 1\end{array}\right]$. The matrix ${\mathit{T}}_N={\mathit{T}}_2^{\otimes n}$ induces channel polarization [1], i.e., each of the N bits $\mathit{u}$ has its own bit channel defined by its own reliability. Classifying the N bit channels according to their reliabilities is not an easy task; several methods exist to achieve this in this paper, which can also be found in [18]. The polar code construction consists of splitting the N positions in $\mathit{u}$ into two sets, $\mathcal{A}$ and ${\mathcal{A}}^{\mathit{c}}$ (with $\left|\mathcal{A}\right|=K)$, being the information set and the frozen set. The information set corresponds to the indices of the K most reliable positions, while the remaining $\left(N-K\right)$ bits, called frozen bits, are set to predefined values that are known by the decoder, which are typically zeros. The vector $\mathit{u}$ contains the message $\mathit{m}$ of K bits in the positions stated in $\mathcal{A}$, i.e., ${\widehat{\mathit{u}}}_{\mathcal{A}}=\mathit{m}$ and contains $N-K$ frozen bits, i.e., ${\widehat{\mathit{u}}}_{{\mathcal{A}}^{\mathit{c}}}=\mathbf{0}$. In this work, the binary phase-shift keying (BPSK) modulation over an additive white Gaussian noise (AWGN) channel is used, as well as the polar code construction of [18].

CA–polar codes include the concatenation of a CRC code during the polar encoding. The r CRC bits are generated on the basis of the message $\mathit{m}$ and are placed in the set of information bits $\mathcal{A}$, increasing the number of information bits to $K_{\mathrm{tot}}=K+r$. Next, information-bit indices of CA–polar codes are noted $a_1<\cdots <a_{K+r}$. The $(N,K+r)$ notation is used throughout this work to indicate the code parameters of CA–polar codes.

2.2. SC Decoding

Polar codes have been proposed with the low-complexity SC algorithm in [1] to retrieve an estimate $\widehat{\mathit{u}}$ of the input vector $\mathit{u}$. The description of SC decoding as a binary tree traversal was proposed in [19], where the tree is traversed depth-first, starting with the left branch. The decoding tree of an $\left(8,4\right)$ polar code is shown in Figure 1, where the stages are $s\in \{n,\dots ,0\}$ with the root node at $s=n$. The received vector of channel log-likelihood ratios (LLRs), denoted by ${\mathit{\alpha }}_{\mathrm{ch}}=\left[{\alpha }_{\mathrm{ch}}\left(0\right),\dots ,{\alpha }_{\mathrm{ch}}(N-1)\right]$, is at the tree root. For any node, denoted by v and located at stage s, the input LLR vector is ${\mathit{\alpha }}_v=\left[{\alpha }_v\left(0\right),\dots ,{\alpha }_v\left(2^s-1\right)\right]$ from the parent node, and the two input partial-sum (PS) vectors are ${\mathit{\beta }}^l=\left[{\beta }^l\left(0\right),\dots ,{\beta }^l\left(2^{s-1}-1\right)\right]$ and ${\mathit{\beta }}^r=\left[{\beta }^r\left(0\right),\dots ,{\beta }^r\left(2^{s-1}-1\right)\right]$, from its left and right child nodes, respectively. The left and right child nodes of the node v have the vectors ${\mathit{\alpha }}_v^l=\left[{\alpha }_v^l\left(0\right),\dots ,{\alpha }_v^l\left(2^{s-1}-1\right)\right]$ and ${\mathit{\alpha }}_v^r=\left[{\alpha }_v^r\left(0\right),\dots ,{\alpha }_v^r\left(2^{s-1}-1\right)\right]$, respectively, where each LLR element is calculated as follows:

$$\begin{array}{}\mathrm{(1)}& {\alpha }_v^l\left(j\right)=f\left({\alpha }_v\left(j\right),{\alpha }_v\left(j+2^{s-1}\right)\right),\hfill \mathrm{(2)}& {\alpha }_v^r\left(j\right)=g\left({\alpha }_v\left(j\right),{\alpha }_v\left(j+2^{s-1}\right),{\beta }^l\left(j\right)\right),\hfill \end{array}$$

where $j\in \{0,\dots ,2^{s-1}-1\}$. Going left, the f function is calculated as [20]

$$\begin{array}{c}\hfill f({\alpha }_1,{\alpha }_2)=\mathrm{sgn}\left({\alpha }_1\right)\mathrm{sgn}\left({\alpha }_2\right)\min \left(\left|{\alpha }_1\right|,\left|{\alpha }_2\right|\right).\end{array}$$

(3)

Going right, the g function is calculated as

$$\begin{array}{c}\hfill g({\alpha }_1,{\alpha }_2,{\beta }_1)=\left(1-2{\beta }_1\right){\alpha }_1+{\alpha }_2.\end{array}$$

(4)

Bit estimates, $\widehat{\mathit{u}}=\left[{\widehat{u}}_0,\dots ,{\widehat{u}}_{N-1}\right]$, are obtained either by taking a hard decision on the decision LLRs, ${\mathit{\alpha }}_{\mathrm{dec}}=\left[{\alpha }_{\mathrm{dec}}\left(0\right),\dots ,{\alpha }_{\mathrm{dec}}(N-1)\right]$, that reach the leaf nodes or using the frozen bit values. Namely, we have

$${\widehat{u}}_i=\left\{\begin{array}{cc}\mathrm{HD}\left({\alpha }_{\mathrm{dec}}\left(i\right)\right),\hfill & \mathrm{if}i\in \mathcal{A}\hfill \\ 0,\hfill & \mathrm{if}i\in {\mathcal{A}}^{\mathit{c}}.\hfill \end{array}\right.$$

(5)

where $\mathrm{HD}(·)$ represents the hard decision function. In Figure 1, the nodes represented in black and white correspond to information and frozen bits. The partial-sum vector, denoted by $\mathit{\beta }$, is calculated from the bit estimates and is propagated up from children to parent nodes. At any node v, each bit of $\mathit{\beta }$ is calculated as follows:

$${\beta }_v\left(j\right)=\left\{\begin{array}{c}{\beta }^l\left(j\right)\oplus {\beta }^r\left(j\right),\mathrm{if}j<2^{s-1},\hfill \\ {\beta }^r\left(j\right),\mathrm{otherwise},\hfill \end{array}\right.$$

(6)

where $j\in \{0,\dots ,2^s-1\}$ and ⊕ is a bitwise XOR.

Figure 1. SC decoding tree of an $\left(8,4\right)$ polar code.

Figure 1. SC decoding tree of an $\left(8,4\right)$ polar code.

2.3. SCL Decoding

SCL decoding was proposed in [3] and uses L parallel instances of the SC decoder, where L is a power of 2. During the decoding, the L best decoding paths are kept through the computation of PMs. At the end of the decoding, a set of L bit-estimate candidates, denoted as ${\widehat{\mathcal{U}}}_{N-1}=\{\widehat{\mathit{u}}\left(1\right),\dots ,\widehat{\mathit{u}}\left(L\right)\}$, is provided. Next, the SCL decoding is described in more detail.

First, for all paths, the bit-estimate vectors are initialized to 0, i.e., $\forall l\in [1,L],\widehat{\mathit{u}}\left(l\right)=\mathbf{0}$, with l denoting the path index. Moreover, all PMs are also initialized to 0, i.e., $\forall l\in [1,L],\mathrm{PM}\left(l\right)=0$. The decoding starts with a single path, and intermediate LLRs are computed according to the SC schedule and the update rules (1) and (2). When the decoder reaches the first information bit $a_1$, the single path is duplicated, i.e., all intermediate partial sums and all intermediate LLRs including the decision LLR ${\alpha }_{\mathrm{dec}}\left(a_1\right)$ are duplicated to another path structure. Contrary to SC decoding where the bit-estimate ${\widehat{u}}_{a_1}$ is taken according to the hard decision $\mathrm{HD}\left({\alpha }_{\mathrm{dec}}\left(a_1\right)\right)$ (5), the path duplication in SCL decoding allows us to consider both options $\{0,1\}$ regardless of the sign of the LLR ${\alpha }_{\mathrm{dec}}\left(a_1\right)$. However, the PMs are updated based on the chosen bit decision and the sign of the decision LLR ${\alpha }_{\mathrm{dec}}$ on their path. Namely, the PM is penalized if the bit decision does not follow the sign of the decision LLR, i.e., for the l-th path, the path metric $\mathrm{PM}\left(l\right)$ is updated as [21]

$$\begin{array}{c}\hfill \mathrm{PM}\left(l\right)=\left\{\begin{array}{cc}\mathrm{PM}\left(l\right)+\left|{\alpha }_{\mathrm{dec}}\left(l,a\right)\right|,\hfill & \mathrm{if}\mathrm{HD}\left({\alpha }_{\mathrm{dec}}(l,a)\right)\ne {\widehat{u}}_a\left(l\right)\hfill \\ \mathrm{PM}\left(l\right),\hfill & \mathrm{otherwise},\hfill \end{array}\right.\end{array}$$

(7)

where ${\alpha }_{\mathrm{dec}}(l,a)$ is the decision LLR for the l-th path at index $a\in \mathcal{A}$, while ${\widehat{u}}_a\left(l\right)$ is the bit decision.

For the first information indices ${\mathcal{A}}_{\mathrm{dup}}\triangleq \{a_1,\dots ,a_{lo{g}_2\left(L\right)}\}$, the duplication of the paths does not result in more than L paths; hence, no sorting and selection of the best L paths are required. However, for all information bits $a\in {\mathcal{A}}_{\mathrm{sort}}\triangleq \{a_{lo{g}_2\left(L\right)+1},\dots ,a_{K+r}\}$, $2L$ paths are obtained after duplication. Hence, a selection of the best L paths is required and is performed through the sorting operation of the $2L$ PMs. The L paths having the smallest PM remain.

After duplication, the set of $2L$ PMs is noted ${\mathbf{PM}}_{{\mathrm{dup}}_a}=\{\mathrm{PM}\left(1\right),\dots ,\mathrm{PM}\left(2L\right)\}$ with $a\in {\mathcal{A}}_{\mathrm{sort}}$, $\forall \mathrm{PM}\left(l\right)\in {\mathbf{PM}}_{{\mathrm{dup}}_a}$, and $\mathrm{PM}\left(l\right)$ is updated as (7). For $\forall a\in {\mathcal{A}}_{\mathrm{sort}}$, the set ${\widehat{\mathcal{U}}}_{{\mathrm{dup}}_a}=\{{\widehat{\mathit{u}}}_0^a\left(1\right),\dots ,{\widehat{\mathit{u}}}_0^a\left(2L\right)\}$ gathers the $2L$ partial candidates after duplication at index a. After the sorting of ${\mathbf{PM}}_{{\mathrm{dup}}_a}$, the following notations are used: ${\mathbf{PM}}_{{\mathrm{sort}}_a}=\{{\mathbf{PM}}_a,{\mathbf{PM}}_{{\mathrm{worst}}_a}\}$ and ${\widehat{\mathcal{U}}}_{{\mathrm{sort}}_a}=\{{\widehat{\mathcal{U}}}_a,{\widehat{\mathcal{U}}}_{{\mathrm{worst}}_a}\}$. Each subset contains the information of L paths. The SCL decoding continues with the best L paths composed of the partial bit estimates ${\widehat{\mathcal{U}}}_a=\{{\widehat{\mathit{u}}}_0^a\left(1\right),\dots ,{\widehat{\mathit{u}}}_0^a\left(L\right)\}$ and the corresponding L PMs ${\mathbf{PM}}_a=\{\mathrm{PM}\left(1\right),\dots ,\mathrm{PM}\left(L\right)\}$. For $i\in {\mathcal{A}}^{\mathit{c}}$, the L paths takes the frozen decision (5) and the update of the L PMs is performed according to (7).

SCL decoding shows its true potential for CA–polar codes. At the end of the decoding, a CRC check is performed on the L candidates stored in ${\widehat{\mathcal{U}}}_{N-1}$. The final decoded codeword is the candidate that satisfies the CRC while minimizing the path metric. If none of the bit estimates satisfy the CRC, a decoding failure is declared.

2.4. SCF Decoding

The SCF algorithm was proposed in [4] for CA–polar codes. This algorithm reuses a single SC instance to perform the decoding. If the CRC check fails at the end of the initial SC decoding trial, up to $T_{\max }$ additional trials are performed, each of them involving a bit flip in the bit-estimate $\widehat{\mathit{u}}$. The decoding stops when one additional trial returns a candidate $\widehat{\mathit{u}}$ checking the CRC code or after $T_{\max }$ additional trials resulting in a CRC check failure. The DSCF decoding was proposed to enhance the performance of SCF [5]; DSCF is defined by the decoding order $\omega$, stating the maximum number of bit flips that can be performed in the additional trial. If $\omega =1$, the list of bit-flip candidates is known at the end of the initial trial; if $\omega =\{2,3\}$, the list of bit-flip candidates is adjusted in all additional trials, i.e., the list is dynamic. A greater decoding order $\omega$ results in greater error-correction gain but also requires more $T_{\max }$ trials as well as more memory because of the storage of the flip metrics and of the bit-flip locations. For the t-th additional trial, $1\le t\le T_{\max }$, the set ${\epsilon }_t$ stores the bit-flip locations with $|{\epsilon }_t|\le \omega$. The list of all bit-flipping candidates is denoted as ${\mathcal{B}}_{\mathrm{flip}}=\{{\epsilon }_1,\dots ,{\epsilon }_t,\dots {\epsilon }_{T_{\max }}\}$.

For $\omega \ge 2$, the latency of DSCF is its main drawback due to the sequential trials and the greater $T_{\max }$ to approach the full potential of the decoding algorithm. Options exist to improve the decoding latency of DSCF. The baseline algorithm can be the fast-SSC algorithm [22], having special nodes in order to not traverse the full decoding tree. However, for $\omega \ge 2$, the special nodes need to be adapted and reduced in size, leading to a more complex implementation [23] with respect to $\omega =1$. Another option is the restart mechanism [16,17].

An optimal restart mechanism for flip decoders: the generalized restart mechanism (GRM):

Authors in [17] proposed the GRM to restart the decoding elsewhere other than the first leaf for the additional trials. At additional trial $1\le t\le T_{\max }$, the restart location ${\psi }_t$ depends on the information set $\mathcal{A}$ and the first bit-flip location $\min \left({\epsilon }_t\right)$. This mechanism requires only the storage of $\widehat{\mathit{u}}$, leading to a small memory overhead that allows the retrieval of the intermediate partial sum ${\mathit{\beta }}_{\mathrm{int}}$. A module to perform the correct f and g sequence is required to retrieve the intermediate LLRs ${\mathit{\alpha }}_{\mathrm{int}}$. This sequence is retrieved with the binary representation of ${\psi }_t$ [17]. Figure 2 depicts the additional trial for a flip decoder embedding the GRM. The first bit-flip location is $min\left({\epsilon }_t\right)=9$, leading to the restart location ${\psi }_t=11$. The skipped nodes are shown in blue, while the restart path is depicted in red. The GRM can be embedded into any baseline algorithm, i.e., standard SC [1] or the fast-SSC [22] decoding algorithm. The average reduction brought by the GRM depends on the code rate and the baseline algorithm. For $N=1024$ and code rate $R_{code}=$ ⅛, the reduction is up to $56.9$% with SC as the baseline algorithm and $20.9$% with fast-SSC as the baseline algorithm.

2.5. SCLF Decoding

SCLF decoding is a combination of list decoding [3] and flip decoding [4,5]. It was first proposed in [6], but the baseline algorithm described in [8] is used in this paper. The least reliable bit positions, called path-flipping locations, are identified thanks to the flip metrics computed during the initial SCL trial and are stored in ${\mathcal{B}}_{\mathrm{flip}}$. For $a\in {\mathcal{A}}_{\mathrm{sort}}$, the flip metric ${\mathrm{FM}}_a$ in [8] is computed using the $2L$ PMs after the sorting operation ${\mathbf{PM}}_{{\mathrm{sort}}_a}$ as

$${\mathrm{FM}}_a=\ln \left({\displaystyle \frac{{\sum }_{l=0}^{L-1}\exp \left(-\mathrm{PM}\left(l\right)\right)}{{\left({\sum }_{ł=0}^{L-1}\exp \left(-\mathrm{PM}\left(l+L\right)\right)\right)}^p}}\right),$$

(8)

where $\ln (·)$ indicates the natural logarithm. The constant value $p\approx 1.0$ is found via simulations. A simplified metric of (8) has been proposed in [12] and is computed as follows:

$${\mathrm{FM}}_a=-\mathrm{PM}\left(1\right)+p·\mathrm{PM}\left(L+1\right),$$

(9)

where $\mathrm{PM}\left(1\right)$ represents the best metric while $\mathrm{PM}(L+1)$ is the best metric among the paths that will be discarded at index $a\in {\mathcal{A}}_{\mathrm{sort}}$. The use of (9), which has also been applied to partitioned SCLF (PSCLF) decoding [15], leads to a negligible error-correction performance degradation. Thus, the metric (9) is used in this work for SCLF decoding. During the initial trial, $|{\mathcal{A}}_{\mathrm{sort}}|$ flip metrics were computed. The metrics are sorted when computed while keeping track of the corresponding index $a\in {\mathcal{A}}_{\mathrm{sort}}$. The $T_{\max }$ smallest flip metrics are stored in the set ${\mathcal{M}}_{\mathrm{flip}}$. The $T_{\max }$ corresponding indices are stored in ${\mathcal{B}}_{\mathrm{flip}}=\{{\epsilon }_1,\dots ,{\epsilon }_{T_{\max }}\}$ where ${\epsilon }_t$ corresponds to the path-flipping location in the t-th additional trial of SCLF.

In SCLF, $|{\epsilon }_t|=1$, i.e., the path-flipping only occurs once per additional trial. During the additional trial t, the standard SCL trial is performed until the path-flipping location ${\epsilon }_t$ is reached. At this position, the L worst paths are selected instead of the L best ones, i.e., path flipping is performed [7]. Following the path flipping, the standard SCL decoding is resumed for the remaining part of the codeword.

2.6. Dynamic SCLF Decoding

In [9], the DSCF decoding strategy is adapted to SCLF decoding, and DSCLF-$\omega$ decoding is proposed where several path-flipping locations potentially occur in an additional trial. The metric computations of the DSCLF and DSCF decoders are very similar. ${\mathcal{B}}_{\mathrm{flip}}$ is dynamically updated for each unsuccessful additional trial and is then composed of a set of path-flipping candidates. For the t-th additional trial, the path-flipping candidate ${\epsilon }_t$ then becomes a set with $\left|{\epsilon }_t\right|\le \omega$. During the t-th additional trial, if $\left|{\epsilon }_t\right|<\omega$, for all information indices $a>max\left({\epsilon }_t\right)$, a flip metric is computed for the extended set ${\epsilon }_t\cup a$ and the metric is calculated as follows [9]:

$${\mathrm{FM}}_{{\mathit{\epsilon }}_t\cup a}=\sum _{ϵ\in {\mathit{\epsilon }}_t\cup a}{\mathrm{FM}}_{ϵ}+\sum _{\begin{array}{c}j\le a\\ j\in \mathcal{A}\end{array}}\mathcal{J}\left({\mathrm{FM}}_j\right),$$

(10)

where ${\mathrm{FM}}_j$ corresponds to the simplified metric (9) and $\mathcal{J}\left(x\right)$ is calculated as follows [5,9]:

$$\mathcal{J}\left(x\right)={\displaystyle \frac{1}{z}}\ln \left(1+\exp \left(-z·x\right)\right),$$

(11)

where z is a constant value, at $0.0<z\le 1.0$, and is found via simulations. In [10], the piece-wise linear approximation function of (10) is proposed. In [5], a step-approximation function of (10) is derived for the DSCF decoder, and it is calculated as follows:

$${\mathcal{J}}_{\mathrm{step}}\left(x\right)=\left\{\begin{array}{c}1.5,\mathrm{if}0\le x\le 5.0,\hfill \\ 0,\mathrm{otherwise}.\hfill \end{array}\right.$$

(12)

For DSCLF-$\omega$, $\omega \ge 2$, during an additional trial, several flip metrics (10) are potentially computed; as soon as one flip metric is computed, sorting is performed to update ${\mathcal{B}}_{\mathrm{flip}}$ and ${\mathcal{M}}_{\mathrm{flip}}$ of size $T_{\max }$. If the metric ${\mathrm{FM}}_{{\epsilon }_t\cup a}$ exceeds the largest metric in ${\mathcal{M}}_{\mathrm{flip}}$, no sorting is required, and the set ${\epsilon }_t\cup a$ is discarded. If not, the set ${\epsilon }_t\cup a$ is inserted to ${\mathcal{B}}_{\mathrm{flip}}$ and ${\mathrm{FM}}_{{\epsilon }_t\cup a}$ is inserted in ${\mathcal{M}}_{\mathrm{flip}}$ while maintaining the ascending order.

To the best of our knowledge, the use of (9) in the dynamic metric of DSCLF (10) using the approximation (12) has never been investigated in previous works. This combination makes a low complexity flip metric for the DSCLF decoding algorithm. However, the main focus of this paper is on a restart mechanism to reduce the average execution time; hence, no more comments on this reduced complexity flip metric will be made later on.

3. Restart Mechanism for the List-Flip Decoder

In [17], the GRM showed great potential in reducing the complexity and the average execution time of flip-based decoders, i.e., SCF and DSCF-$\omega$, regardless of the baseline algorithm (with or without fast decoding of special nodes). The GRM only requires the storage of the candidate $\widehat{\mathit{u}}$ of the initial SC trial to enable the restart of an additional trial in any location $a\in \mathcal{A}$. Next, the feasibility of embedding the GRM to the SCLF algorithm is discussed based on the memory overhead required. Then, a restart mechanism tailored for the list–flip algorithm is proposed and described.

3.1. Memory Requirements of List-Flip Algorithm

First, the memory requirements of SCLF are studied. The SCL decoder uses a structure of N bits to store $\mathcal{A}$. The SCLF (DSCLF-$\omega$) decoder corresponds to an SCL decoder, used up to $T_{\max }$ times, an additional module to compute the flip metric (9) and (10), and a module to construct ${\mathcal{B}}_{\mathrm{flip}}$. The SCL decoder is considered to be parallel and is viewed as L SC instances in terms of memory. The memory requirements, expressed in bits, for the LLRs and the partial sums of an SC instance is described in [17] and is

$$\begin{array}{c}\hfill {\mathrm{\Lambda }}_{\mathrm{SC}}=\underset{{\mathit{\alpha }}_{\mathrm{ch}}}{\underbrace{Q_{\mathrm{ch}}·N}}+\underset{{\mathit{\alpha }}_{\mathrm{int}}}{\underbrace{Q_{\mathrm{int}}·(N-1)}}+\underset{\widehat{\mathit{u}}+{\mathit{\beta }}_{\mathrm{int}}}{\underbrace{2N-1}},\end{array}$$

(13)

where $Q_{\mathrm{ch}}$ and $Q_{\mathrm{int}}$ represent the quantization in bits for the channel LLRs ${\mathit{\alpha }}_{\mathrm{ch}}$ and the intermediate LLRs ${\mathit{\alpha }}_{\mathrm{int}}$. N bits are used to store the current candidate $\widehat{\mathit{u}}$ and $N-1$ bits are needed for the intermediate partial sums ${\mathit{\beta }}_{\mathrm{int}}$. The SCL algorithm requires the storage of the structure ${\mathbf{PM}}_{\mathrm{dup}}$, i.e.,

$$\begin{array}{c}\hfill {\mathrm{\Lambda }}_{\mathrm{SCL}}=L·{\mathrm{\Lambda }}_{\mathrm{SC}}+\underset{\mathcal{A}}{\underbrace{N}}+\underset{{\mathbf{PM}}_{\mathrm{dup}}}{\underbrace{2L·Q_{\mathrm{PM}}}},\end{array}$$

(14)

where $Q_{\mathrm{PM}}$ is the quantization in bits used for the PMs.

Regarding the flip algorithm, DSCLF-$\omega$ requires the storage of ${\mathcal{B}}_{\mathrm{flip}}$ and ${\mathcal{M}}_{\mathrm{flip}}$ leading to

$$\begin{array}{c}\hfill {\mathrm{\Lambda }}_{\mathrm{flip}}=\underset{{\mathcal{M}}_{\mathrm{flip}}}{\underbrace{T_{\max }·Q_{\mathrm{flip}}}}+\underset{{\mathcal{B}}_{\mathrm{flip}}}{\underbrace{\omega ·T_{\max }}},\end{array}$$

(15)

where $Q_{\mathrm{flip}}$ is the quantization in bits used for the flip metric in (9) and (10). In bits, the memory of the list–flip decoder is

$$\begin{array}{c}\hfill {\mathrm{\Lambda }}_{\mathrm{list}\text{-}\mathrm{flip}}={\mathrm{\Lambda }}_{\mathrm{SCL}}+{\mathrm{\Lambda }}_{\mathrm{flip}}.\end{array}$$

(16)

3.2. Generalized Restart Mechanism

The GRM is a restart mechanism that reduces the complexity of flip-based decoders while not affecting the error-correction performance [17]. The small memory overhead used to embed the GRM is one of the main advantages of this mechanism, allowing a reduction of $56.9\%$ for the average execution time at the cost of $3.4\%$ memory overhead for DSCF-$3$ decoding of a $(1024,128+11)$ polar code. Another key advantage is that the restart location for an additional trial is always optimal, as the set of restart locations in the GRM is defined as ${\mathcal{R}}_{\mathrm{GRM}}={\mathcal{A}}_{\mathrm{sort}}$. Next, the estimation of the memory overhead is performed to embed the GRM to SCLF.

At the additional trial $1\le t\le T_{\max }$, the GRM embedded into the flip decoder allows us to restart the decoding at the restart location ${\psi }_t\in {\mathcal{A}}_{\mathrm{sort}}$, which is the next information-bit location after $min\left({\epsilon }_t\right)\in {\mathcal{A}}_{\mathrm{sort}}$. The restart path retrieves the intermediate partial sum ${\mathit{\beta }}_{\mathrm{int}}$ based on the $\widehat{\mathit{u}}$ of the initial SC trial. The intermediate LLRs, ${\mathit{\alpha }}_{\mathrm{int}}$, are retrieved with the channel LLRs, ${\mathit{\alpha }}_{\mathrm{ch}}$, and the intermediate partial sum ${\mathit{\beta }}_{\mathrm{int}}$. The sequence of f and g functions to perform during the restart path depends on the binary representation of ${\psi }_t$ as described in [17]. Hence, the restart path allows us to restore the status of the tree at position ${\psi }_t$ without performing the usual SC schedule. Next, we describe why the SCL cannot be restarted with only the storage of the final candidate ${\widehat{\mathcal{U}}}_{N-1}$.

At a path-flipping location, the L worst paths instead of the L best continue the decoding. The L worst path information, i.e., the sets ${\mathbf{PM}}_{{\mathrm{worst}}_a}$ and ${\widehat{\mathcal{U}}}_{{\mathrm{worst}}_a}$, changes at each information bit $a\in {\mathcal{A}}_{\mathrm{sort}}$ and becomes overwritten during the initial SCL trial. At a certain position, if the best L paths out of the $2L$ are generated through less than L parents, the information carried of some discarded paths is lost and cannot be retrieved with ${\widehat{\mathcal{U}}}_{N-1}$.

As an example, SCLF with $L=2$ decoding an $(8,3+1)$ code with $\mathcal{A}=\{3,5,6,7\}$ (${\mathcal{A}}_{\mathrm{sort}}=\{5,6,7\}$) is shown. In this example, only the bit values at position $\mathcal{A}$ are shown. At position 3, SCL considers $L=2$ paths, i.e., ${\widehat{\mathcal{U}}}_3=\{\left[0\right],\left[1\right]\}$. After duplication at position 5, we have ${\widehat{\mathcal{U}}}_{{\mathrm{dup}}_5}=\{[0,0],[0,1],[1,0],[1,1]\}$, which, after sorting, will be divided as ${\widehat{\mathcal{U}}}_5=\{[0,0],[0,1]\}$ and

$$\begin{array}{c}\hfill {\widehat{\mathcal{U}}}_{{\mathrm{worst}}_5}=\{[1,0],[1,1]\}.\end{array}$$

(17)

If we forward to the end with ${\widehat{\mathcal{U}}}_7=\{[0,0,1,0],[0,0,0,1]\}$, this is not able to pass the CRC. Only storing ${\widehat{\mathcal{U}}}_7$ will not be enough to retrieve the worst paths at position 5 for example. Indeed, from ${\widehat{\mathcal{U}}}_7$, we can state that $\left\{[0,0]\right\}\subset {\widehat{\mathcal{U}}}_5$, meaning that ${\widehat{\mathcal{U}}}_{{\mathrm{worst}}_5}\subset \{[0,1],[1,0],[1,1]\}$, without knowing ${\widehat{\mathcal{U}}}_{{\mathrm{worst}}_5}$ (17), which is not enough information to perform the path flipping through the GRM.

Hence, in order to resume the decoding in any path-flipping location $min\left({\epsilon }_t\right)$, the L worst path information, i.e., ${\widehat{\mathcal{U}}}_{{\mathrm{worst}}_a}$ and ${\mathbf{PM}}_{{\mathrm{worst}}_a}$, need to be stored for all $a\in {\mathcal{A}}_{\mathrm{sort}}$. In order to store the path metric information, $L\times Q_{\mathrm{PM}}\times \left|{\mathcal{A}}_{\mathrm{sort}}\right|$ additional bits are required. In order to save memory for the storage of the L worst partial candidate ${\widehat{\mathcal{U}}}_{{\mathrm{worst}}_a}$, only the message bits can be stored, i.e., for $a_i\in {\mathcal{A}}_{\mathrm{sort}}$, $L·i$ bits are stored instead of $L·a_i$. Hence, the total memory requirement ${\mathrm{\Lambda }}_{\mathrm{GRM}}$ for embedding the GRM to the list–flip algorithms is

$$\begin{array}{}\mathrm{(18)}& {\mathrm{\Lambda }}_{\mathrm{GRM}}=\sum _{i={log}_2\left(L\right)+1}^{K+r}\left(\left|{\mathbf{PM}}_{\mathrm{worst}}\right|+L·i\right),\hfill \mathrm{(19)}& {\mathrm{\Lambda }}_{\mathrm{GRM}}=L\times \left(Q_{\mathrm{PM}}·\left|{\mathcal{A}}_{\mathrm{sort}}\right|+\sum _{i={log}_2\left(L\right)+1}^{K+r}i\right).\hfill \end{array}$$

The memory requirement (19) grows with the code rate since $|{\mathcal{A}}_{\mathrm{sort}}|=K+r-log2\left(L\right)$ will grow as well. Moreover, the memory will grow if the list size grows (19). Figure 3 depicts the memory sketch of the DSCLF-$\omega$ algorithm embedding the GRM.

The storage of the L worst partial candidates leads to impractically large memory requirements. As an example, for the list–flip decoder of the $(1024,512+16)$ polar code with $L=2,\omega =2,$ and $T_{\max }=50$ and the quantization scheme $Q_{\mathrm{ch}}=6$, $Q_{\mathrm{int}}=7$, $Q_{\mathrm{PM}}=8$, and $Q_{\mathrm{flip}}=9$, derived from [16,23], the memory requirement of the decoder ${\mathrm{\Lambda }}_{\mathrm{list}\text{-}\mathrm{flip}}$ and embedding the GRM ${\mathrm{\Lambda }}_{\mathrm{GRM}}$ are estimated to be

$$\begin{array}{}\mathrm{(20)}& \hfill {\mathrm{\Lambda }}_{\mathrm{list}\text{-}\mathrm{flip}}& =31760\mathrm{bits},\hfill \mathrm{(21)}& \hfill {\mathrm{\Lambda }}_{\mathrm{GRM}}& =287758\mathrm{bits}.\hfill \end{array}$$

Hence, the GRM induces a memory overhead of ${\mathrm{\Delta }}_{\mathbf{mem}}^{\mathbf{GRM}}=906\%$, while it was $6.1$% for DSCF-2 with the same $T_{\max }$ [17].

The memory requirements to embed the GRM to list–flip algorithms, i.e., having ${\mathcal{R}}_{\mathrm{GRM}}={\mathcal{A}}_{\mathrm{sort}}$, has been estimated with the conclusion that the GRM is unfeasible for the list–flip decoder. Next, the LLRM is proposed to tackle this issue.

3.3. Limited Location Restart Mechanism

The LLRM is derived from the GRM and proposed as a way to skip part of the tree traversal of the SCL decoding. However, the set of restart locations $\mathcal{R}$ is predefined and its size $\left|\mathcal{R}\right|$ is very limited compared to $|{\mathcal{R}}_{\mathrm{GRM}}|$. The effectiveness of the proposed approach is discussed in Section 5. First, the proposed LLRM is defined.

For an additional trial t, the list–flip decoder embedding the proposed LLRM skips non-negligible parts of the decoding tree by recovering the path information at the location ${\psi }_t\in \mathcal{R}$, where $\mathcal{R}=\{\mathcal{R}\left(1\right),\dots ,\mathcal{R}\left(R\right)\}\subset {\mathcal{A}}_{\mathrm{sort}}$ represents the set of restart locations and $R=\left|\mathcal{R}\right|$ is the number of restart locations. It should be noted that $a_{{log}_2\left(L\right)+1}\in {\mathcal{A}}_{\mathrm{sort}}$ will always be included in $\mathcal{R}$. A notation variant of $\mathcal{R}$ is the subset ${\mathcal{R}}_{\mathcal{A}}=\left\{{\mathcal{R}}_{\mathcal{A}}\left(1\right),\dots ,{\mathcal{R}}_{\mathcal{A}}\left(R\right)\right\}\subset [{log}_2\left(L\right)+1,K+r]$, storing the index of each restart location in the information set $\mathcal{A}$, i.e., $\mathcal{R}=\left\{a_{{\mathcal{R}}_{\mathcal{A}}\left(1\right)},\dots ,a_{{\mathcal{R}}_{\mathcal{A}}\left(R\right)}\right\}$.

By embedding the proposed LLRM, the SCL additional trial is modified by not restarting at position 0. The corresponding modified SCL trial is denoted by $\mathrm{SCL}\left({\psi }_t,{\mathit{\epsilon }}_t\right)$, indicating the restart location ${\psi }_t\in \mathcal{R}$ and the bit-flipping set ${\mathit{\epsilon }}_t$. The savings in terms of computations and decoding time come at the cost of storing all path information in the positions stated in $\mathcal{R}$ during the initial SCL trial. As described next, restart mechanisms exist [16,24] for SCF (DSCF-$\omega$) but on positions permitting an easy restart procedure.

In [16], the simplified restart mechanism (SRM) was proposed and can be seen as an instance of LLRM with one of the most simple sets of restart locations $\mathcal{R}$. In the SRM, $R=2$ restart locations are possible and include ${\mathcal{R}}_{\mathrm{SRM}}=\left\{0,{\displaystyle \frac{N}{2}}\right\}$ which allows a very simple restart path, where the restart always begins from the upper stage involving the channel LLRs ${\mathit{\alpha }}_{\mathrm{ch}}$. Only ${\displaystyle \frac{N}{2}}$ bits are required to apply this mechanism. However, the restart location $R_{\mathrm{SRM}}\left(1\right)=0$ does not allow a reduction in the complexity. Hence, only the restart location $R_{\mathrm{SRM}}\left(2\right)={\displaystyle \frac{N}{2}}$ reduces the decoding complexity. The authors in [24] derive the SRM to propose the set of restart locations ${\mathcal{R}}_{\mathrm{FRM}}=\left\{0,{\displaystyle \frac{N}{2}},{\displaystyle \frac{3N}{4}},\dots ,{\displaystyle \frac{(N-1)N}{N}}=N-1\right\}$. Despite being a more advanced set of restart locations, it comes at the cost of storing LLRs. As for the SRM, the restart locations are only on the right-hand side of the tree, limiting the application of the mechanism as discussed in [16].

The optimal restart mechanism is the GRM [17] as it combines the ability of restarting at any location in $\mathcal{A}$, i.e., ${\mathcal{R}}_{\mathrm{GRM}}=\mathcal{A}$, while not having to store the intermediate LLRs. This is possible thanks to the generalized restart path, which describes the algorithm that restores all intermediate LLRs and all partial sums on the basis of the binary representation of the restart location ${\psi }_t\in \mathcal{A}$ and on the SC candidate $\widehat{\mathit{u}}$ of the initial trial.

By reusing the generalized restart path, the restart locations in the proposed LLRM will not be selected according to the ease of performing the restart path as in [16,24] but on picking the restart locations to improve, as much as possible, the average execution time reduction. The first consequence is that the first restart location for the proposed LLRM is not 0 but will be $\mathcal{R}\left(1\right)=a_{{log}_2\left(L\right)+1}\in {\mathcal{A}}_{\mathrm{sort}}$ (${\mathcal{R}}_{\mathcal{A}}\left(1\right)={log}_2\left(L\right)+1$), representing the first information-bit location involving duplication in SCL. This will allow the avoidance of computations on the left-hand side of the decoding tree mostly composed of frozen bits. However, before finding the other restart locations, the proposed LLRM is described in more detail.

The memory overhead of the LLRM is first discussed. It is decomposed into two sets: the set $\mathcal{P}=\left\{\mathcal{P}\right(1),\dots ,\mathcal{P}(R\left)\right\}$ that will store the relevant PMs and the set $\widehat{\mathcal{M}}=\{\widehat{\mathcal{M}}\left(1\right),\dots ,\widehat{\mathcal{M}}\left(R\right)\}$ that will store the relevant messages. During the initial SCL trial, when the decoding reaches the first restart location $\mathcal{R}\left(1\right)\in \mathcal{R}$, the $2L$-sorted PMs are stored in $\mathcal{P}\left(1\right)$, while the partial message candidates are stored in $\widehat{\mathcal{M}}\left(1\right)$. For the other restart locations, path information is also stored in the corresponding index of $\mathcal{P}$ and $\widehat{\mathcal{M}}$. At the end of the initial SCL trial, the R elements of $\mathcal{P}$ and $\widehat{\mathcal{M}}$ gather the full path information at the restart locations stored in the $\mathcal{R}$ of the L best and L worst paths.

The LLRM is activated whenever an additional trial is performed, i.e., if the CRC check fails for all L candidates in ${\widehat{\mathcal{U}}}_{N-1}$. For $1\le t\le T_{\max }$, the t-th additional trial is defined by the path-flipping locations stored in ${\mathcal{B}}_{\mathrm{flip}}\left(t\right)={\epsilon }_t$. The first path-flipping location is defined by $min\left({\epsilon }_t\right)$. The restart location ${\psi }_t\in \mathcal{R}$ for the t-th additional trial corresponds to the closest element in $\mathcal{R}$, verifying that

$$\begin{array}{c}\hfill {\psi }_t\le min\left({\epsilon }_t\right).\end{array}$$

(22)

The additional SCL trial restarting at ${\psi }_t$ and flipping at locations stored in ${\epsilon }_t$ is noted for $\mathrm{SCL}\left({\psi }_t,{\mathit{\epsilon }}_t\right)$. Next, $\rho$ denotes the index in $\mathcal{R}$, defining ${\psi }_t$, i.e., ${\psi }_t=\mathcal{R}\left(\rho \right)$.

If ${\psi }_t=min\left({\epsilon }_t\right)$, the restart location is also a path-flipping location; hence, the worst L paths are chosen to continue the decoding. Thus, the path metric structure ${\mathbf{PM}}_{{\psi }_t}$ of $\mathrm{SCL}\left({\psi }_t,{\mathit{\epsilon }}_t\right)$ is restored with the L worst PMs stored in $\mathcal{P}\left(\rho \right)$. Similarly, the partial candidate ${\widehat{\mathcal{U}}}_{{\psi }_t}$ is restored on the basis of the L worst partial candidates stored in $\mathcal{P}\left(\rho \right)$. If $min\left({\epsilon }_t\right)>{\psi }_t$, the restart location precedes the path-flipping location; hence, the best L paths are chosen to continue the decoding. Thus, the path metric structure ${\mathbf{PM}}_{{\psi }_t}$ of $\mathrm{SCL}\left({\psi }_t,{\mathit{\epsilon }}_t\right)$ is restored with the best path metric stored in $\mathcal{P}\left(\rho \right)$. Similarly, the partial candidate ${\widehat{\mathcal{U}}}_{{\psi }_t}$ is restored on the basis of the L best partial candidates stored in $\mathcal{P}\left(\rho \right)$.

Once the structures ${\mathbf{PM}}_{{\psi }_t}$ and ${\widehat{\mathcal{U}}}_{{\psi }_t}$ are correctly restored, for all L paths, the intermediate values in the decoding tree, i.e., the restart path, are used to attain the next leaf in the decoding trees of the L paths, i.e., ${\psi }_t+1$, as shown in Figure 2. The binary representation of ${\psi }_t+1$ describes the series of functions to be performed in the restart path. If g-functions are required, the partial sum ${\mathit{\beta }}_{\mathrm{int}}$ is restored through the L-independent restart paths. These functions allow us to accurately retrieve the intermediate LLRs ${\mathit{\alpha }}_{\mathrm{int}}$ for all L paths. When the L restart paths attain the leaf, if ${\psi }_t+1\in {\mathcal{A}}^c$, for all L paths, ${\widehat{u}}_{{\psi }_t+1}=0$ and the L path metrics are updated using (7). If ${\psi }_t+1\in \mathcal{A}$, $2L$ paths are generated, as well as $2L$ path metrics, and the decision on the $2L$ paths are taken based on the path metrics and the nature of position ${\psi }_t+1$.

3.4. Example of the LLRM

The modified SCL trial in SCLF embedding the LLRM, $\mathrm{SCL}\left({\psi }_t,{\mathit{\epsilon }}_t\right)$, is explained with an example for the $\left(16,10+1\right)$ code defined by $\mathcal{A}=\{2,3,5,6,7,9,11,12,13,14,15\}$ with $T_{\max }=1$ and $L=2$. The set of restart locations is set prior to decoding to $\mathcal{R}=\{3,6,9\}$. This example is shown in Figure 4. The initial trial starts with $\mathcal{P}=\{\varnothing ,\varnothing ,\varnothing \}$ and $\widehat{\mathcal{M}}=\{\varnothing ,\varnothing ,\varnothing \}$. When reaching the first information bit $a_1=2$, the decoding considers both ${\widehat{u}}_{a_1}=\{0,1\}$, leading to the structure ${\widehat{\mathcal{U}}}_{a_1}=\{[0,0,0],[0,0,1]\}$. The SCL does not need sorting since $L=2$. The path metric structure is also updated as ${\mathbf{PM}}_{a_1}=\{\mathrm{PM}\left(1\right),\mathrm{PM}\left(2\right)\}$. The next bit $a_2=3\in \mathcal{A}$ is also $\mathcal{R}\left(1\right)$. As explained in Section 3.3, $\widehat{\mathcal{M}}\left(1\right)$ will store the $2L$ partial candidates, i.e., $\widehat{\mathcal{M}}\left(1\right)=\{[0,0],[0,1],[1,0],[1,1]\}$, before the selection. Similarly, the $2L$ PMs in ${\mathbf{PM}}_{{\mathrm{sort}}_{a1}}$ are stored in $\mathcal{P}\left(1\right)$. The same storage process happens when the decoding reaches $\mathcal{R}\left(2\right)=6$ and $\mathcal{R}\left(3\right)=9$.

After the failure of the initial trial, the path-flipping location is considered to be ${\epsilon }_1=\left\{11\right\}$ in this example. The restart location ${\psi }_1$ is selected from $\mathcal{R}$ as being the closest to ${\epsilon }_1$, verifying ${\psi }_1\le {\epsilon }_1$. Hence, the restart location is ${\psi }_1=\mathcal{R}\left(3\right)=9$. The $\mathrm{SCL}\left({\psi }_1,{\mathit{\epsilon }}_1\right)$ begins by restoring ${\widehat{\mathcal{U}}}_9$ and ${\mathbf{PM}}_9$ with the L best partial candidates in $\widehat{\mathcal{M}}\left(3\right)$ and the L best PMs in $\mathcal{P}\left(3\right)$ since ${\psi }_1\ne {\epsilon }_1$. For all L paths, the restart path connecting the root of the tree at stage $s=n=4$ with the leaf ${\widehat{u}}_{10}$ at stage $s=0$ is traversed, which allows us to retrieve the intermediate partial sum ${\mathit{\beta }}_{\mathrm{int}}$ and the intermediate LLR ${\mathit{\alpha }}_{\mathrm{int}}$. After traversing the restart path, all intermediate information is retrieved, allowing us to resume the standard course of SCL; since $10\in {\mathcal{A}}^c$, only the L path metrics are updated based on the decision LLR computed at the end of the restart path for the L paths. When ${\epsilon }_1=11$ is reached, path flipping is performed, i.e., the L worst paths are picked. When the last index is reached, the CRC is verified on all decoding paths. It either returns a decoding candidate verifying the CRC or returns a decoding failure since the decoding has reached its maximum number of additional trials $T_{\max }=1$.

3.5. Memory Model

In order to resume the decoding in one of the R restart locations, the LLRM requires the storage of

• the set of restart locations $\mathcal{R}$;
• the $2L$ path metric information $\mathcal{P}$ on each restart location $\mathcal{R}\left(\rho \right)\in \mathcal{R}$;
• the $2L$ partial message candidate $\widehat{\mathcal{M}}$ on each restart location $\mathcal{R}\left(\rho \right)\in \mathcal{R}$.

As a consequence, the memory overhead depends on R but also on the positions of the restart locations, since the partial message is stored. For the $\rho$-th restart location, $2\times L\times {\mathcal{R}}_{\mathcal{A}}\left(\rho \right)$ bits are required to store the partial messages. Moreover, the information on the $2L$ path is stored, as discussed in Section 3.3. The total memory overhead of the LLRM is denoted as ${\mathrm{\Lambda }}_{\mathrm{LLRM}}$ and is

$${\mathrm{\Lambda }}_{\mathrm{LLRM}}=\underset{\mathcal{R}}{\underbrace{n·R}}+\underset{\mathcal{P}}{\underbrace{R·2L·Q_{\mathrm{PM}}}}+\underset{\widehat{\mathcal{M}}}{\underbrace{\sum _{\rho =1}^{R}2L{\mathcal{R}}_{\mathcal{A}}\left(\rho \right)}}.$$

(23)

The memory sketch of the SCLF decoder with the LLRM is provided in Figure 5. The green blocks correspond to the memory overhead (23) when embedding the proposed LLRM.

4. Obtaining the Restart Locations

In this section, three designs for the set of restart locations are proposed. The choice of restart locations aims at improving the execution time reduction provided by the LLRM. Two are based on the structure of the polar code, while one is proposed based on offline simulations. For the latter, similarly to [17], offline simulations are used to retrieve the probability-mass function (PMF) of the first path-flipping candidate $min\left({\epsilon }_t\right)$ for list–flip decoders. These statistics are then used to design the set $\mathcal{R}$.

4.1. Structural Design

Before describing the simulation-based design, two simple sets of restart locations are described. Both sets use the structure of the polar code. The first design of restart locations, noted as ${\mathcal{R}}_{\mathrm{divN}}$, equally divides the codeword into R segments. Since the codeword is of length N, each segment is of size ${\displaystyle \frac{N}{R}}$. This particular design does not take into account the information set and is constructed as ${\mathcal{R}}_{\mathrm{divN}}=\left\{0,N/R,\dots ,{\displaystyle \frac{N(R-1)}{R}}\right\}$. For $R=2$, the restart locations ${\mathcal{R}}_{\mathrm{divN}}=\left\{0,{\displaystyle \frac{N}{2}}\right\}$ correspond to the restart locations of the SRM [16]. Restarting at 0 does not allow us to save any computations, which limits the effect of this mechanism for high-rate codes, as discussed in [16].

The second design, generating ${\mathcal{R}}_{\mathrm{divK}}$, defines the restart locations on the basis of the information set $\mathcal{A}$. With the exception of the first restart location, any two successive restart locations are separated by $⌈{\displaystyle \frac{K+r}{R}}⌉$ information bits. The first restart location is ${\mathcal{R}}_{\mathrm{divK}}\left(1\right)={\mathcal{A}}_{{log}_2\left(L\right)+1}$, since no restart is possible if $a\notin {\mathcal{A}}_{\mathrm{sort}}$. All restart locations correspond to ${\mathcal{R}}_{\mathrm{divK}}=\left\{a_{{log}_2\left(L\right)+1},a_{⌈(K+r)/R⌉},\dots ,a_{⌈{\displaystyle \frac{(K+r)(R-1)}{R}}⌉}\right\}$ or ${\mathcal{R}}_{\mathcal{A}}=\left\{{log}_2\left(L\right)+1,⌈{\displaystyle \frac{K+r}{R}}⌉,\dots ,⌈{\displaystyle \frac{(K+r)(R-1)}{R}}⌉\right\}$. For any additional trials, part of the computations will be avoided since ${\mathcal{R}}_{\mathrm{divK}}\left(1\right)\ne 0$. This design pushes the restart locations towards the end of the codeword, allowing us to avoid many computations. However, these restart locations may not often used since $min\left({\epsilon }_t\right)$ is expected to be close to the first information-bit indices.

4.2. Design Based on the First Path-Flipping Location

In the following, the value of the first path-flipping location is denoted as $i_1=min\left({\epsilon }_t\right)$. The simulation-based design requires us to know the probability that $i_1$ is the first path-flipping location. Next, the probability that $a\in {\mathcal{A}}_{\mathrm{sort}}$ is the first path-flipping location occurring during an additional trial of list–flip decoders is denoted by $\mathbb{P}(i_1=a)$. The algorithm to obtain the PMF by simulation is described in Algorithm 1. A design signal-to-noise ratio (SNR) is chosen to match a desired FER. Moreover, the list size L and the number of additional trials $T_{\max }$ are chosen to define the list–flip decoder. If the decoder performs an additional trial, the value of $i_1=min\left({\epsilon }_t\right)\in {\mathcal{A}}_{\mathrm{sort}}$ is stored in a structure denoted as Occ. After transmitting C codewords, with C being large enough, a reliable probability distribution describing $\mathbb{P}(i_1=a)$ for all $a\in {\mathcal{A}}_{\mathrm{sort}}$ calculations is returned. This distribution is then used to choose the restart location $\mathcal{R}$.

Algorithm 1 Obtaining the distribution of the first path-flipping candidates occurring in SCLF by simulation
1: procedure Distr_Bit_Flip_SCLF($C,\mathcal{A},T_{\max },L,\mathrm{SNR}$)
2:     for $j={log}_2\left(L\right)+1:\left|\mathcal{A}\right|$ do
3:         $\mathbb{P}\left(i_1=a_j\right)\leftarrow 0$	▹ Initialize $\mathbb{P},\forall a\in {\mathcal{A}}_{\mathrm{sort}}$
4:         $\mathrm{Occ}\left(j\right)\leftarrow 0$	▹ Initialize counter $\forall a\in {\mathcal{A}}_{\mathrm{sort}}$
5:     end for
6:     ${\mathcal{T}}_{\mathrm{sim}}\leftarrow 0$	▹ Total number of additional trials performed
7:     for $c=0:C-1$ do
8:         $\mathit{x}\leftarrow$ Polar_Encoding$\left(\mathit{u}\right)$
9:         ${\mathit{\alpha }}_{\mathrm{ch}}\leftarrow \mathrm{AWGN}(\mathrm{SNR},\mathit{x})$	▹ Channel LLRs for the decoding
10:         $\left({\mathcal{B}}_{\mathrm{flip}},t\right)\leftarrow \mathrm{SCLF}\left({\mathit{\alpha }}_{\mathrm{ch}},\mathcal{A},T_{\max }\right)$	▹ ${\mathcal{B}}_{\mathrm{flip}}$: Set of flipping locations in SCLF, t: Number of additional trials performed
11:         if $t>0$ then	▹ Initial trial has failed
12:            ${\mathcal{T}}_{\mathrm{sim}}\leftarrow {\mathcal{T}}_{\mathrm{sim}}+t$	▹ Update the total number of additional trials
13:            for $\tau =1:t$ do
14:                ${\mathit{\epsilon }}_{\tau }\leftarrow {\mathcal{B}}_{\mathrm{flip}}\left(\tau \right)$
15:                $a_k\leftarrow min\left({\epsilon }_{\tau }\right)$	▹ Extract first bit-flipping $a_k\in {\mathcal{A}}_{\mathrm{sort}}$
16:                $\mathrm{Occ}\left(k\right)\leftarrow \mathrm{Occ}\left(k\right)+1$	▹ Increase by 1 the occurence $i_1=a_k$
17:            end for
18:         end if
19:     end for
20:     for $j={log}_2\left(L\right)+1:\left|\mathcal{A}\right|$ do
21:         $\mathbb{P}\left(i_1=a_j\right)\leftarrow \mathrm{Occ}\left(j\right)/{\mathcal{T}}_{\mathrm{sim}}$	▹ Estimate the probability-mass function $\mathbb{P}(i_1=a_j)$
22:     end for
23:     return the distribution $\mathbb{P}(i_1=a),\forall a\in {\mathcal{A}}_{\mathrm{sort}}$
24: end procedure

Ultimately, the design consists of choosing the restart locations by equally dividing the distribution in segments sharing the same probability of having $min\left({\epsilon }_t\right)$. The algorithm to obtain the set of restart locations ${\mathcal{R}}_{\mathrm{prob}}$ according to the PMF is described in Algorithm 2. The number of restart locations $R=\left|\mathcal{R}\right|$ is selected in advance. The restart location $\mathcal{R}\left(\rho \right)$, $1\le \rho \le R$, is the first location verifying $\mathbb{P}(i_1=\mathcal{R}\left(\rho \right))>{\displaystyle \frac{(\rho -1)}{R}}$. We note that $\mathcal{R}\left(1\right)$ is set to the smallest $a\in {\mathcal{A}}_{\mathrm{sort}}$, verifying $\mathbb{P}(i_1=a)>0$, and it is usually $a_{{log}_2\left(L\right)+1}$.

Algorithm 2 Design of $\mathcal{R}$ with the distribution of the first path-flipping location
1: procedure Design_Restart_with_PMF($\mathbb{P},R,\mathcal{A}$)
2:     $sum\mathbb{P}\leftarrow 0$
3:     $\rho \leftarrow 1$
4:     for $j={log}_2\left(L\right)+1:K+r$ do
5:         $sum\mathbb{P}\leftarrow sum\mathbb{P}+\mathbb{P}\left(i_1=a_j\right)$
6:         if $sum\mathbb{P}>{\displaystyle \frac{\rho -1}{R}}$ then	▹ Divide equally with resp. to $\mathbb{P}$
7:            $\mathcal{R}\left(\rho \right)\leftarrow a_j$
8:            $\rho \leftarrow \rho +1$	▹ Next restart location
9:         end if
10:         if $\rho >R$ then
11:            return $\mathcal{R}$	▹ Already R restart locations in $\mathcal{R}$
12:         end if
13:     end for
14: end procedure

4.3. Simulation Setup and Results

For this analysis, a polar code of length $N=1024$ with rate ½ and a CRC of $r=16$ bits is simulated over the AWGN channel with the BPSK modulation. Simulations are for a minimum of $C={10}^5$ codewords and are run until at least ${10}^3$ errors are observed. The target FER is ${10}^{-2}$ as in [17], which is obtained at $E_b/N_0=1.625$ dB. The DSCLF-$\omega$ decoder with $\omega =3$ and $T_{\max }=300$ is simulated. The list size is set to $L=2$. The value of $T_{\max }$ was selected to achieve the optimal error-correction performance at the target FER.

The PMF is depicted in Figure 6. In the considered example, the set of restart locations is $R=4$. Locations found by Algorithm 2 are denoted by ${\mathcal{R}}_{\mathrm{prob}}$ and equally divide the distributions according to their probabilities. For this example, the restart locations are ${\mathcal{R}}_{\mathrm{prob}}=\{191,248,370,451\}$. Regarding the structural designs, the restart locations are ${\mathcal{R}}_{\mathrm{divN}}=\{0,256,512,756\}$ and ${\mathcal{R}}_{\mathrm{divK}}=\{191,499,741,890\}$.

5. Simulation Results

Next, simulation results are provided. This section comprises error-correction performance, memory estimations, and average execution time reductions for list–flip decoders. The polar codes are constructed with a design SNR $E_b/N_0=\{1.5,2.0,3.4\}$ dB for rates $R_{code}$ = {¼, ½, ¾}, respectively. For all simulations, the number of restart locations is set to $R=4$. The list size is selected as $L=2$ to maintain a low-complexity list decoder. The maximum number of trials is selected as $T_{\max }=\{30,50,300\}$ for SCLF and DSCLF-$\omega$ decoders with $\omega =\{2,3\}$, respectively. The BPSK modulation is used over an AWGN channel.

5.1. Error-Correction Performance

The FER for SCLF and DSCLF-$\omega$ with various $\omega$ are shown in Figure 7 for polar codes of $N=1024$ with rate $R_{code}$ = ½ and in Figure 8 for polar codes with rate $R_{code}$ = ¼. For reference, standard SCL decoders with $L=8$ and $L=32$ are provided. The LLRM is derived from the GRM, a mechanism that does not affect error-correction performance [17]. Both figures show that the proposed LLRM does not affect the error-correction performance of the original SCLF and DSCLF decoders either. Moreover, higher order DSCLF decoders greatly increase the error-correction performance compared to SCLF. The performance of DSCLF-3 with $T_{\max }=300$ is close to the performance of the SCL decoder with $L=32$ for both rates and even matches for $R_{code}$ = ¼ and $\mathrm{FER}={10}^{-3}$.

5.2. Memory Estimations

Memory requirements are estimated with (14), (15), (19), and (23), where the same quantization scheme as that of [16,23] is used. Hence, the blocks based on LLR values are quantized by $Q_{\mathrm{ch}}=6$, $Q_{\mathrm{int}}=7$, $Q_{\mathrm{flip}}=7$ bits, and $Q_{\mathrm{pm}}=8$ bits, respectively. The sizes of these blocks also depend on the values of N, L, and $T_{\max }$. The number of restart locations $R=4$ is selected for all estimations, which was similarly carried out in the example in Section 4. All sets of restart locations are considered.

Table 1. Memory estimates and overhead for SCLF-based decoders with GRMs, LLRMs, and the original decoders.

N	$\mathit{\omega }$	${\mathit{T}}_{\mathbf{max}}$	${\mathbf{\Lambda }}_{\mathbf{list}\text{-}\mathbf{flip}}$	${\mathit{R}}_{\mathit{code}}$	${\mathbf{\Delta }}_{\mathbf{mem}}^{\mathbf{LLRM}}$			${\mathbf{\Delta }}_{\mathbf{mem}}^{\mathbf{GRM}}$
					${\mathcal{R}}_{\mathbf{prob}}$	${\mathcal{R}}_{\mathbf{divK}}$	${\mathcal{R}}_{\mathbf{divN}}$
			bits		%	%	%	%
1024	1	30	32,270	¼	1.8	5.5	2.1	235.0
				½	7.7	10.3	6.1	875.1
				¾	4.6	15.0	12.0	1921.5
1024	2	50	33,110	¼	2.2	5.5	2.1	$229.0$
				½	2.2	10.0	6.0	$853.0$
				¾	2.7	14.7	11.7	$1872.7$
1024	3	300	42,860	¼	1.5	4.2	1.6	$176.9$
				½	1.4	7.7	4.6	$658.9$
				¾	1.8	11.3	11.7	$1446.7$
512	3	300	21,682	¼	1.7	3.9	1.7	83.1
				½	2.4	6.8	4.2	290.7
				¾	1.8	9.8	7.6	623.8
2048	3	300	75,504	¼	1.5	4.4	1.6	374.0
				½	1.6	8.5	4.9	1442.1
				¾	1.1	12.5	13.0	3204.5

provides the memory overhead, expressed in percent, induced by embedding the restart mechanism to the polar code decoder for code lengths $N=\{512,1024,2048\}$ and rates $R_{code}$ = {¼, ½, ¾}. For $N=1024$, the memory overhead is given for SCLF, DSCLF-2, and DSCLF-3, while for $N=\{512,2048\}$, the memory overhead for DSCLF-3 is provided. By analyzing Table 1, the memory overhead to embed the LLRM depends on the set of restart locations $\mathcal{R}$, since the location affects the size of $\widehat{\mathcal{M}}$ in (23). Moreover, for ${\mathcal{R}}_{\mathrm{divK}}$, the increase in the code rate increases the memory overhead since the size of $\widehat{\mathcal{M}}$ becomes larger. For a code rate of $R_{code}=$ ¼, the memory overhead is around $1.5\%$ for ${\mathcal{R}}_{\mathrm{prob}}$ while it is $5\%$ for ${\mathcal{R}}_{\mathrm{divK}}$. Meanwhile, for the GRM with ${\mathcal{R}}_{\mathrm{GRM}}={\mathcal{A}}_{\mathrm{sort}}$ ($|{\mathcal{A}}_{\mathrm{sort}}|=K+r-{log}_2\left(L\right)$), the memory overhead depends on the code rate and the code length but not the decoder. By doubling the code length N, the overhead approximately doubles as well. For $N=512$ and rate $R_{code}=$ ¾, the overhead is $623.8\%$ and $3204.5\%$ for $N=2048$. Hence, Table 1 shows that the overhead induced by the GRM makes it unfeasible. However, the overhead induced by the LLRM remains feasible for an implementation.

5.3. Average Execution Time Reduction Induced by the LLRM

Next, with respect to the standard list–flip decoder (), the reduction brought by the LLRM is estimated for various code lengths, code rates, and various restart locations designed according to simulations ${\mathcal{R}}_{\mathrm{prob}}$ () or designed according to code properties such as ${\mathcal{R}}_{\mathrm{divN}}$ () and ${\mathcal{R}}_{\mathrm{divK}}$ (). In order to compute it, the chosen architectural execution-time model is from [17]. Moreover, the number of processing elements, having an impact on the average execution time of decoders, is $P=64$ as in [23,25]. Moreover, the latency of SCL is estimated as in [15], i.e., one clock cycle is added whenever the SCL encounters an information bit.

Two types of reduction will be discussed next, the average execution time reduction (${\mathrm{\Delta }}_{\mathbf{GRM}}$ and ${\mathrm{\Delta }}_{\mathbf{LLRM}}$) and the average flip time reduction (${\mathrm{\Delta }}_{\mathbf{GRM}}^{\mathbf{flip}}$ and ${\mathrm{\Delta }}_{\mathbf{LLRM}}^{\mathbf{flip}}$). The first consists of the reduction over all the simulated frames. The second consists of the reduction over the time spent during the flip part of the list–flip algorithm; since the flipping part is not required in all frames, this reduction is expected to be greater, i.e., ${\mathrm{\Delta }}_{\mathbf{LLRM}}^{\mathbf{flip}}>{\mathrm{\Delta }}_{\mathbf{LLRM}}$ (${\mathrm{\Delta }}_{\mathbf{GRM}}^{\mathbf{flip}}>{\mathrm{\Delta }}_{\mathbf{GRM}}$). The reduction brought by the unfeasible GRM serves as a bound, i.e., ${\mathrm{\Delta }}_{\mathbf{GRM}}>{\mathrm{\Delta }}_{\mathbf{LLRM}}$ and ${\mathrm{\Delta }}_{\mathbf{GRM}}^{\mathbf{flip}}>{\mathrm{\Delta }}_{\mathbf{LLRM}}^{\mathbf{flip}}$, and the GRM reduction is shown in the figures as ().

Figure 9 and Figure 10 depict the average execution time over all frames (a) and over the flipping part (b) for the DSCLF-2 and DSCLF-3 decoders for the $(1024,256+16)$ polar code. For both decoders, the reduction is clearly visible for all sets of restart locations. However, the set of restart locations ${\mathcal{R}}_{\mathrm{prob}}$ allows for a greater reduction and is closer to the optimal reduction retrieved with the GRM. The reduction over all frames reduces with the FER since the flipping part is required less often, and the mechanism permits a reduction only on the flipping part. In Figure 10a, the reduction with ${\mathcal{R}}_{\mathrm{prob}}$ at $\mathrm{FER}=0.1$ is ${\mathrm{\Delta }}_{\mathbf{LLRM}}=41.8$% while the reduction is ${\mathrm{\Delta }}_{\mathbf{LLRM}}=4.7$% at $\mathrm{FER}={10}^{-4}$. If the focus is made on the flipping part solely, the reduction in the average flip time increases when the FER diminishes. In Figure 10b, the reduction with ${\mathcal{R}}_{\mathrm{prob}}$ at $\mathrm{FER}=0.1$ is ${\mathrm{\Delta }}_{\mathbf{LLRM}}^{\mathbf{flip}}=43.0$%, while the reduction is ${\mathrm{\Delta }}_{\mathbf{LLRM}}^{\mathbf{flip}}=52.9$% at $\mathrm{FER}={10}^{-4}$.

Table 2. Execution time reduction by embedding the LLRM and the GRM to list–flip decoders of various polar codes at the FER of ${10}^{-2}$.

N	$\mathit{\omega }$	${\mathit{T}}_{\mathbf{max}}$	${\mathit{R}}_{\mathit{code}}$	${\mathit{E}}_{\mathit{b}}/{\mathit{N}}_0$	${\mathbf{\Delta }}_{\mathbf{GRM}}$	${\mathbf{\Delta }}_{\mathbf{LLRM}}$ (%)			${\mathbf{\Delta }}_{\mathbf{GRM}}^{\mathbf{flip}}$	${\mathbf{\Delta }}_{\mathbf{LLRM}}^{\mathbf{flip}}$ (%)
				dB	(%)	${\mathcal{R}}_{\mathbf{prob}}$	${\mathcal{R}}_{\mathbf{divN}}$	${\mathcal{R}}_{\mathbf{divK}}$	(%)	${\mathcal{R}}_{\mathbf{prob}}$	${\mathcal{R}}_{\mathbf{divN}}$	${\mathcal{R}}_{\mathbf{divK}}$
1024	1	30	¼	1.34	18.5	16.9	12.3	14.3	51.9	47.4	34.6	40.1
			½	1.87	12.8	9.9	7.9	8.1	35.8	27.7	22.1	22.7
			¾	3.03	10.4	7.8	7.1	5.9	28.3	21.0	19.1	16.1
1024	2	50	¼	1.21	25.4	23.1	18.2	18.9	56.7	51.7	40.7	42.1
			½	1.78	19.1	14.8	12.5	12.2	36.0	27.9	23.5	22.9
			¾	3.00	9.8	7.0	5.8	5.1	23.1	16.5	13.7	12.0
1024	3	300	¼	1.06	45.5	41.7	31.0	33.2	52.0	47.6	35.4	37.9
			½	1.66	27.8	22.2	16.7	17.2	32.2	25.7	19.3	19.9
			¾	2.86	15.3	11.7	7.1	7.5	18.7	14.3	8.7	9.2
512	3	300	¼	1.39	47.3	43.3	34.4	35.5	55.7	51.0	40.5	41.9
			½	1.92	30.8	28.1	20.0	20.3	35.5	32.4	23.1	23.4
			¾	3.08	14.5	11.5	6.6	6.8	18.2	14.4	8.2	8.5
2048	3	300	¼	0.84	44.1	38.0	31.8	26.7	55.2	47.6	39.8	33.4
			½	1.49	27.8	21.8	17.2	17.7	33.7	26.5	20.8	21.5
			¾	2.73	12.5	8.9	4.7	4.8	15.5	11.0	5.8	6.0

recapitulates all aforementioned reductions with respect to the standard decoding for $N=\{512,1024,2048\}$ and code rates $K/N=$ {¼, ½, ¾}. For $N=1024$, the execution time reduction by embedding one of the restart mechanisms on SCLF and DSCLF-2 is also given. The reduction is computed at $\mathrm{FER}={10}^{-2}$ as in [17]. Regardless of the decoders, code lengths, or code rates, the proposed design ${\mathcal{R}}_{\mathrm{prob}}$ provides the best reduction. The reduction induced by the LLRM with ${\mathcal{R}}_{\mathrm{prob}}$ is highlighted in boldface. As the code rate increases, the reduction reduces since the restart locations tend towards the beginning of the decoding tree, as explained in [16,17]. A reduction of $51.7$% with respect to the DSCLF-2 algorithm is estimated for the code rate ¼ and $N=1024$. For these parameters, the other designs provide a reduction of $40.7$ and $42.1$%. The smallest reduction observed is for DSCLF-2 with rate ¾ and $N=1024$. The reduction is $7.0$%, while the optimal reduction is $9.8$%. On average, 3 to 7% is lost with respect to the reduction provided by the GRM.

6. Conclusions

In this paper, a restart mechanism is proposed for list–flip decoders of polar codes. We first show that an optimal mechanism is unfeasible due to a large memory overhead, which can increase up to $3755\%$. Thus, an limited-locations restart mechanism (LLRM) is proposed, allowing us to restart in predefined locations of the tree if an additional trial is performed. This mechanism requires the storage of path information at these locations. The choice of the restart locations influences the effectiveness of the LLRM. Three designs of restart locations are proposed and compared to each other. A thorough analysis is performed for various list–flip decoders, as well as various code lengths and code rates. The design requiring simulations achieves a reduction of $41.7\%$ with respect to the DSCLF-3 decoding of the $(1024,256+16)$ code at the cost of $1.5\%$ memory overhead. This reduction is only $4\%$ smaller than the optimal mechanism which comes at the cost of $177\%$ memory overhead.