# Low-Complexity Concatenated

LDPC-Staircase Codes

###### Abstract

A low-complexity soft-decision concatenated FEC scheme, consisting of an inner LDPC code and an outer staircase code is proposed. The inner code is tasked with reducing the bit error probability below the outer-code threshold. The concatenated code is obtained by optimizing the degree distribution of the inner-code ensemble to minimize estimated data-flow, for various choices of outer staircase codes. A key feature that emerges from this optimization is that it pays to leave some inner codeword bits completely uncoded, thereby greatly reducing a significant portion of the decoding complexity. The trade-off between required SNR and decoding complexity of the designed codes is characterized by a Pareto frontier. Computer simulations of the resulting codes reveals that the net coding-gains of existing designs can be achieved with up to 71% reduction in complexity. A hardware-friendly quasi-cyclic construction is given for the inner codes, which can realize an energy-efficient decoder implementation, and even further complexity reductions via a layered message-passing decoder schedule.

## 1 Introduction

Recent optical transport network (OTN) system proposals increasingly specify the use of soft-decision codes, i.e., codes that can make use of probabilistic symbol reliabilities, in the forward error correction (FEC) scheme. At a similar overhead (OH) and signal-to-noise ratio (SNR), soft-decision codes can achieve coding gains of 1 dB, or more, relative to the hard-decision codes used in earlier OTN proposals [1]. The excellent performance of soft-decision codes comes, however, at the expense of a significantly increased decoding complexity. A comparison of the implementations of soft- and hard-decision decoders shows that soft-decision decoders typically consume an order of magnitude more power than hard-decision decoders [2, 3, 4, 5] operating at the same OH and throughput.

This paper continues the work of Zhang and Kschischang [6] on designing low-complexity concatenated FEC schemes for applications with high throughput. Their design consists of an inner soft-decision low-density generator-matrix (LDGM) code concatenated with an outer hard-decision staircase code. The degree distribution of the inner LDGM code ensemble is obtained by solving an optimization problem, minimizing the estimated data-flow of the inner-code decoder, while searching a table of staircase codes to find the optimal inner and outer code pair. At 20% OH, the codes proposed in [6] can achieve up to 46% reduction in complexity, when compared with other low-complexity designs.

In this paper, we adopt the concatenated FEC structure of [6], but we consider a different ensemble of inner codes. The task of the inner code, similar to that of [6], is to reduce the bit error rate (BER) of the bits transferred to the outer staircase code to below the threshold, which enables the outer code to take the BER further down, below , as required by OTNs. We re-design the inner code to further reduce its data-flow, thereby achieving an FEC solution with even lower complexity than the codes reported in [6].

A key characteristic that emerges from the re-designed inner-code optimization is that some inner codeword bits remain uncoded! These bits bypass the inner code, and are protected only by the outer-code. We propose a method to analyze and optimize the inner-code ensemble, and show that the resulting codes can reduce the inner-code data-flow by up to 71%, when compared to [6]. We show that, when block length is sufficiently large, codes generated according to the obtained inner-code ensembles perform as expected, verifying the design approach.

To realize a pragmatic decoder implementation, we construct quasi-cyclic (QC) codes of practical length, generated according to the obtained inner-code ensembles. We show that the performance of randomly-generated inner codes of large block-length can be achieved by QC codes of practical length on the order of 6000 to 15000. A QC-structured inner code allows for decoder hardware implementations that are very energy efficient [7, Ch. 3]. The QC structure also enables a layered message-passing decoding schedule. We show that, compared with the flooding schedule, layered decoding of the QC-structured codes reduces the complexity by up to 50%.

The rest of this paper is organized as follows. In Sec. 2 we describe the inner-code structure, code parameters, and complexity measure. In Sec. 3 we describe how extrinsic information transfer (EXIT) functions can be used to predict the inner-code performance, and we describe the inner-code optimization procedure. In Sec. 4 we present simulation results and give a characterization of the trade-off between the required SNR and decoding complexity for the concatenated code designs. Designs with QC-structured codes are also discussed in Sec. 4, and a comparison with existing soft-decision FEC solutions is presented. In Sec. 5 we provide concluding remarks.

Throughout this paper, we consider signaling using a Gray-labeled quadrature phase-shift keying constellation, with unit energy per symbol. We assume a memoryless, additive white Gaussian noise (AWGN) channel, with covariance matrix , where is the identity matrix. In this setting, SNR, in decibels, is denoted by .

## 2 The Inner-Code Structure

### 2.1 Code Description

We use low-density parity-check (LDPC) codes as inner codes. A significant feature of the inner-code ensemble is that we allow for both degree-zero and degree-one variable nodes. Degree-zero variable nodes are uncoded, and thus incur zero inner decoding complexity. Also, as will be discussed in Sec. 2.3, degree-one variable nodes do not add to the data-flow throughout the decoding procedure, thus they also incur no inner decoding complexity.

We denote the inner code by and its rate by . The coded component (excluding the uncoded bits) form an LDPC code of length and rate . A Tanner graph for a member of the inner-code ensemble is sketched in Fig. 1.

Note that the LDGM inner code of [6] is an instance of the ensemble defined above. However, in an LDGM code, check nodes are associated randomly with variable nodes, inducing a Poisson distribution on variable-node degrees. In this work, the variable-node degree distribution is carefully optimized to achieve small decoding complexity.

### 2.2 Ensemble Parameterization

The inner code ensemble is described by its variable-node and check-node degree distributions. We denote the maximum degree of a variable node or a check node by and , respectively. We define the normalized, node-perspective, degree distributions as , where is the fraction of variable nodes that have degree , and is the fraction of check nodes that have degree .

We define the normalized, edge-perspective, degree distributions as and , corresponding to the variable and check nodes, respectively, where and .

The portion of uncoded bits is given by , thus the coded component rate, , satisfies

(1) |

For computational simplicity, we only consider check degree distributions concentrated on one or two consecutive degrees. For a check-node degree distribution that is concentrated on a single degree, , is related to the edge-perspective variable degree distribution by

(2) |

Therefore, for a given inner-code rate , the inner-code ensemble is completely described by the pair , where . We refer to the pair as the design parameters.

For reasons described in Sec. 2.3 and Sec. 3.1, degree-one variable nodes receive special treatment in our design. We define to be the average number of degree-one variable nodes connected to each check node. In terms of the code parameters, can be expressed as

(3) |

For a check-degree distribution that is concentrated on two consecutive degrees, and , the edge-perspective check-degree distribution is specified by fixing the average check-node degree , and is obtained as

where . In this case, equation (2) and all other following equations still hold, when is replaced with .

### 2.3 Complexity Measure

We use the same complexity measure described in [6, Eq. 4], to quantify, and eventually minimize, the required data-flow at the decoder. The concatenated code decoder complexity is defined as

(4) |

where is the inner code complexity score, is the outer staircase code rate, and is the number of post-processing operations per information bit at the outer-code decoder. In this paper we have set , since the decoding complexity, per bit, of the staircase code is typically two to three orders of magnitude smaller than that of the inner code. This can be estimated as follows for the rate 15/16 staircase code with a (1408,1364) component code. Typically, each component code is “visited” by the iterative decoder about four times during the decoding (where the decoding, i.e., processing of a syndrome, is performed using a small table-lookup-based circuit). Since each information bit is protected by two component codes, the average number of bits recovered per decoding attempt is 170.5, giving a complexity of decoding attempts per decoded bit.

The complexity score of the inner-code, , can be computed as

(5) |

where is the maximum number of decoding iterations allowed for the inner-code decoder. Note that, similar to [6], the complexity score in (5) does not account for messages of degree-one variable nodes, as they remain constant throughout the decoding procedure.

## 3 Complexity-optimized Design

### 3.1 EXIT chart analysis

We analyze the coded component of the inner code using a version of EXIT functions [8, 9]. Under the assumption that the all-zero codeword is transmitted, we define the error-probability EXIT function , that takes , the probability of error in messages coming from the variable nodes, as input, and outputs , the probability of error in messages coming from the variable nodes, after one round of sum-product message-passing, i.e.,

(6) |

Using the law of total probability, we can write as

(7) |

where is the probability of error in messages coming from a degree- variable node. From (6) and (7) we get

(8) |

where functions are called elementary EXIT functions. Function takes as an argument, and produces , the probability of error in messages coming from the degree- variable nodes, after one round of sum-product message-passing. As shown in [8], in practice the elementary EXIT charts’ dependence on can be neglected. Therefore, (8) can be written as

(9) |

In [8] a method is proposed, that, for an LDPC code ensemble without degree-zero and degree-one variable nodes, approximates the elementary EXIT charts using Monte-Carlo simulation. Assuming that the messages coming from the variable nodes have a symmetric Gaussian distribution with mean and variance , an empirical distribution for check-node messages is generated by performing the check-node computation on samples of variable-node messages. A degree variable node then adds its channel message and independent samples of check-node messages, to generate a sample of . It is shown that the elementary EXIT charts generated by interpolating the average of a large number of samples closely replicate the actual elementary EXIT charts.

In our design, however, we must take into account the presence of degree-one variable nodes in obtaining the elementary EXIT charts with the method of [8], as the messages from such nodes significantly affect the check-node operation. To this end, we generate the elementary EXIT charts for a pre-set value of , the average number of degree-one variable nodes connected to each check node, as defined in (3). In the Monte-Carlo simulation described above, we modify the check-node operation to account for the fact that each check node is connected to, on average, degree-one variable nodes, and therefore receives only their channel observation. In particular, given a value of , let satisfy . We then assume that a fraction of the check nodes are connected to degree-one variable nodes and the remainder are connected to degree-one variable nodes.

Note that the SNR, , and are the only parameters needed to compute the elementary EXIT charts. Since they do not depend on inner-code design parameters, elementary EXIT charts can be pre-computed. Therefore, when SNR, , and are given, the problem of inner-code design reduces to the problem of appropriately shaping an EXIT chart out of its constituent elementary EXIT charts.

### 3.2 Code Optimization

Similar to [6], we view the problem of designing the concatenated FEC scheme as a multi-objective optimization with the objectives . In both parameters, smaller is better, i.e., we wish to minimize the SNR needed to achieve the target error rate and we wish to minimize the estimated complexity needed to do so. Given a concatenated code rate, , we characterize the trade-off between the objectives by finding their Pareto frontier. For any SNR, we find a pair (if it exists), consisting of an outer staircase code and an inner-code ensemble, with minimum complexity, that together, bring the BER below .

Concatenated code optimization procedure is as follows. When an is specified, we loop over a table of staircase codes such as [6, Table 1]. Recall that each staircase code specifies and , the rate and threshold of the outer code, respectively. For each staircase code, we perform the inner-code ensemble complexity optimization.

It is shown in [9], that, given the EXIT function, the number of iterations, , required by the inner-code coded component, to take the variable nodes message error probability from , the channel BER, down to , a target message error probability, can be closely approximated as

(10) |

The target information bit error probability for the coded component, , can be computed from and as described in [9], and should satisfy

(11) |

Note that the maximum feasible , which we denote by , can be obtained from (11), by setting , as

(12) |

From (5) and (10), the complexity-optimized inner-code ensemble is obtained by solving the following optimization problem:

(13) | ||||

subject to | (14) | |||

(15) | ||||

(16) | ||||

(17) | ||||

(18) | ||||

(19) | ||||

(20) |

In this optimization problem formulation, constraint (14) ensures that the obtained complexity-optimized code has the desired rate (see (1) and (2)). Constraints (15)–(18) ensure the validity of the obtained ensemble. Constraint (19) ensures that the obtained EXIT-curve remains open throughout the decoding procedure, i.e., for all . Finally, (20) ensures that the inner-code output BER is at or below the outer-code threshold.

Note that, in terms of the optimization parameters, constraints (14)–(19) are linear. Also, as shown in [9], under mild conditions, , as approximated in (10), is a convex function of .

Given an SNR, the inner-code optimization is performed over three loops, iterating over discrete sets of values for each of , , and (see Sec. 3.3.1). Once the values of , , and are fixed, the problem of designing complexity-optimized inner-code becomes convex, and can be solved by the method described in Sec. 3.3.2.

Once all three loops are executed, the ensemble with lowest complexity, according to (5), is chosen as the inner-code ensemble. The loop over the outer-code table then outputs the staircase-code inner-code-ensemble pair that achieves the minimum overall complexity, according to (4), as the optimized concatenated code.

### 3.3 Practical Considerations

#### 3.3.1 Discretization

In practice, the integral in (10) is estimated by a sum over a quantized version of the interval. Let be the number of quantization points. Define and let

We define a discrete approximation of the integral in (10) as

which we use in the objective function in (13), instead of the integral. The constraint then ensures the openness of the EXIT-curve throughout the decoding procedure.

Similarly, intervals and , are quantized with and points when searching over values of and at the inner-code ensemble optimization. Here, was defined in (12) and is the maximum value for that we consider in our search for the optimal inner-code ensemble. The values of , and allow the designer to trade-off between accuracy and computational complexity of the design process.

#### 3.3.2 Optimization Algorithm

Even when , , and are fixed, the objective function is non-linear and is not easily differentiable. To solve the optimization problem, we used the sequential quadratic programming (SQP) method [10]. This method is an iterative procedure, at each iteration of which a quadratic model of the objective function is optimized (subject to the constraints), and the solution is used to construct a new quadratic model of the objective function. During this procedure, we update whenever undergoes a large change (see (10)–(11) and [9, Sec. II.B]).

An issue with using the SQP algorithm is that it needs to be initialized with a feasible point. In our design procedure, we initialize the algorithm with the parameters of the rate-optimized ensemble [9].

#### 3.3.3 Interleaving Between Inner and Outer Code

The outer staircase code threshold is computed assuming that the outer code sees a binary symmetric channel, i.e., a channel with independent and identically distributed bit errors occurring with probability . The inner decoder, however, produces correlated errors. To mitigate the error correlation, we use a diagonal interleaver as in [6]. We suppose that each staircase block is of size , and we choose the inner code dimension to divide . We define the packing ratio, , as the number of inner codewords associated with a staircase block, i.e., .

Packing Ratio | 1 | 2 | 4 | |
---|---|---|---|---|

Performance Loss (dB) | 0.02 | 0.01 | 0.007 |

Table 1 shows the performance loss, relative to ideal interleaving, obtained for different packing ratios, assuming an outer staircase code of rate 15/16 with and using an inner code sampled from an optimized ensemble. The ideal interleaving threshold was estimated by interleaving inner codewords over multiple staircase blocks. At packing ratios exceeding 4, the performance degradation becomes negligible, justifying the use of the simple binary symmetric channel BER analysis of staircase codes.

## 4 Results

### 4.1 Pareto Frontier

We searched staircase codes of [6, Table 1] for the optimal outer code. We refer the reader to [11] to see how these codes are obtained. The reader should note that there is a slight difference between two of the entries in the earlier table [11, Table 1] (which included -error-correcting component codes) and the later table [6, Table 1] (which includes only results corresponding to the more practical component codes).

We used the following parameters in designing inner-code ensembles: , , , . We chose such that step-sizes of the quantized version of are no greater than 0.01. We used the sum-product algorithm in generating the elementary EXIT charts, and samples were produced at each pass of the Monte-Carlo simulation.

Fig. 2 shows the Pareto frontier for the designed inner-codes, at 15%, 20%, and 25% OHs. The Pareto frontiers are also compared with those of [6]. Similar to [6], all our concatenated code designs picked the highest-rate staircase code available, with and . As can be seen from Fig. 2, the proposed design outperforms the design in [6]. The inner codes of this paper achieve the performance of the inner codes of [6], with up to 71%, 52%, and 32% reduction in complexity, at 15%, 20%, and 25% OHs, respectively. Also, compared to [6], the designed concatenated codes operate at up to 0.21 dB, 0.18 dB, and 0.11 dB closer to the constrained Shannon limit, at 15%, 20%, and 25% OHs, respectively.

To study the performance of the designed inner codes at overall 20% OH, we sampled codes of length up to 100,000 from each of the complexity-optimized inner-code ensembles. We simulated the transmission of codewords over an AWGN channel. Codewords were decoded using the sum-product algorithm with floating-point message-passing, and the code performance was obtained by averaging the codeword BERs. Note that we only care about the BER of the information set of a codeword.

In Fig. 3, obtained BERs are plotted versus SNR. The line shows the outer staircase code threshold. The mid-point SNR on each curve (highlighted by on ‘o’) is the code operational point, i.e., the SNR for which the code is designed. Note that all BERs of the sampled codes hit at, or below, the outer-code threshold, at their operational point, verifying our design approach.

### 4.2 Two Design Examples

Here we present two interesting examples of the complexity-optimized concatenated code designs at 20% OH. In both of these examples, the outer code picked was the and staircase code.

Example 1: An FEC scheme operating at 1.27 dB from the constrained Shannon limit. The optimization procedure yields the following ensemble for the inner code:

This code requires a maximum of 8 iterations to bring the BER below the outer-code threshold, which gives an inner-code complexity score of 22.4.

Example 2: An FEC scheme operating at 1 dB from the constrained Shannon limit. The optimization procedure yields the following ensemble for the inner code:

This code requires a maximum of 16 iterations to bring the BER below the outer-code threshold, which gives an inner-code complexity score of 53.6.

### 4.3 Comparison to Other Works

To compare our work with the existing designs, in Fig. 4, we have plotted the NCG versus complexity, at 20% OH, for our designed codes, and also for several other existing FEC solutions. Since the referenced code designs are based on min-sum (MS) or offset-MS decoding, we also simulated the obtained inner codes using the offset-MS algorithm with unconditional correction [12].

Compared to code designs decoded under a flooding schedule, the obtained MS-based codes achieve, at similar complexities, a 0.79 dB gain over the code in [13], a 0.49 dB gain over the code in [14], and a 0.44 dB gain over the code in [15]. The designed codes achieve NCGs of codes in [15] and [16] with more than a 70% reduction in complexity, and the excellent NCG of code in [17] with 48% reduction in complexity.

Compared to code designs where the inner code is decoded under a layered schedule, the obtained MS-based codes achieve NCGs of codes in [18] with more than 60% reduction in complexity, and achieves NCGs of codes in [15] with 21% to 43% reduction in complexity.

While some designs in [15], decoded under a layered schedule, come close to the proposed MS-based codes, the proposed BP-based codes, decoded under flooding schedule, strictly dominate the existing designs. The BP-based codes achieve the NCGs of the existing designs with at least 65% and 28% reduction in complexity compared to code designs decoded under a flooding schedule and layered schedule, respectively. The BP-based codes achieve at least 0.45 dB and 0.1 dB greater NCG over the existing designs, at nearly the same , compared to code designs decoded under flooding schedule and layered schedule, respectively.

The latency of the proposed concatenated code can be obtained by adding the latencies of the inner and the outer codes. The latency is dominated by the staircase decoder. For example, at Gb/s, for a staircase block containing information bits and a staircase decoding window size , the decoding latency of the proposed concatenated code (including the inner code) is bit periods, or 14 s, which is an acceptable latency in many OTN applications.

### 4.4 Quasi-Cyclic-Structured Inner Codes

The inner codes considered so far have been randomly structured and have large block lengths. Decoder architectures for such codes are often plagued with routing and message-permutation complexities. In order to obtain a more pragmatic implementation of the proposed FEC scheme, we adopt a quasi-cyclic (QC) structure for the inner codes. The QC structure is well known to be hardware-friendly and leading to energy-efficient implementations; see [7, Ch. 3] and references therein.

We constructed girth-8 inner-codes of coded component length 1%, based on the obtained inner-code ensembles, for the concatenated code at 20% OH. As can be seen from Fig. 4, the concatenated FEC performs as well, with QC-structured inner-codes, as with randomly structured inner-codes, with only a small loss in performance when operating at a high NCG. Note that, however, we do not make any claim of optimality for the code constructions with QC-structured inner-codes, as the optimization procedure used assumes a random structure for the inner-code coded component.

The structure of the QC codes also allows for layered decoding of the constructed inner codes. As can be seen from Fig. 4, the concatenated scheme with inner-code coded component length 1%, decoded under layering schedule, performs at up to 50% lower complexity compared to the scheme with the inner-code coded component, decoded under flooding schedule. Compared to the existing code designs decoded under a layered schedule, the designed codes, with QC inner-codes decoded under layering schedule, achieve a similar NCG with at least 55% reduction in complexity.

While a length LDPC code can be considered practical for OTN applications [15], we have also constructed QC-structured inner-codes of shorter lengths (, , and ) and possibly lower girths, based on the obtained inner-code ensembles, at 20% OH. Note that, according to (4) and (5), using a short inner code does not change the complexity score of the overall code; however, having a short inner code leads to a more practical implementation, as it greatly reduces wiring and routing complexities. A comparison between the concatenated FEC scheme with inner-code coded component of various lengths is provided in Fig. 5.

As can be seen from Fig. 5, when shorter inner codes are used, the loss in NCG is not significant, although the loss becomes bigger, as the NCG increases or as the inner-code length becomes shorter. Nevertheless, schemes with inner-code coded component of length , decoded under a layered schedule, operate at up to 50% less complexity, compared to schemes with an inner-code coded component of length , decoded under a flooding schedule.

## 5 Conclusion

In this paper we have proposed a concatenated code design that improves significantly upon the results of [6]. The complexity-optimized error-reducing inner code, concatenated with an outer staircase code, forms a low-complexity FEC scheme suitable for high bit-rate optical communication. An interesting feature that emerges from the inner-code optimization is that a fraction symbols are better left uncoded, and only protected by the outer code. We showed that, compared to [6], with this modified design, the inner-code complexity can be reduced by up to 70%. We showed that the concatenated code designs have lower complexity than, to the best of our knowledge, any other existing soft-decision FEC scheme.

To realize a pragmatic and energy-efficient implementation for the proposed FEC scheme, we constructed QC inner codes, based on the obtained ensembles. We showed that, QC-structured inner codes with practical lengths can achieve the performance of the randomly constructed inner codes. We simulated layered decoding of the QC inner codes and showed that with layered decoding, the complexity score of the FEC scheme can be reduced by up to 50%.

There are two worthwhile directions for further research. First, using an outer staircase code with higher rate is likely to yield concatenated code designs with even lower complexity. To test this hypothesis, we extrapolated the table of staircase codes in [6, Table 1], and observed that at 20% overall OH, continues to decrease as the outer staircase code OH decreases down to 2%. Unfortunately, it is not trivial to design and implement staircase codes with a very high rate, because the staircase block size becomes very large as the code rate increases.

Second, as shown in this work, using a layered schedule in decoding significantly reduces the decoding complexity. However, we cannot make any claim of optimality for the proposed codes when decoded under a layered schedule. A topic of future work is to modify the inner-code design procedure to obtain complexity-optimized inner codes that are decoded under a layered schedule.

## References

- [1] G. Tzimpragos, C. Kachris, I. Djordjevic, M. Cvijetic, D. Soudris, and I. Tomkos, “A survey on FEC codes for 100G and beyond optical networks,” IEEE Commun. Surveys Tuts., vol. 18, no. 1, pp. 209–221, First Quarter 2016.
- [2] M. Weiner, M. Blagojevic, S. Skotnikov, A. Burg, P. Flatresse, and B. Nikolic, “A scalable 1.5-to-6Gb/s 6.2-to-38.1mW LDPC decoder for 60 GHz wireless networks in 28nm UTBB FDSOI,” in IEEE Int. Solid-State Circuits Conf., Feb. 2014, pp. 464–465.
- [3] T.-C. Ou, Z. Zhang, and M. Papaefthymiou, “An 821MHz 7.9Gb/s 7.3pJ/b/iteration charge-recovery LDPC decoder,” in IEEE Int. Solid-State Circuits Conf., Feb. 2014, pp. 462–463.
- [4] Y. Lee, H. Yoo, J. Jung, J. Jo, and I.-C. Park, “A 2.74-pJ/bit, 17.7-Gb/s iterative concatenated-BCH decoder in 65-nm CMOS for NAND flash memory,” IEEE Trans. Syst. Sci. Cybern., vol. 48, no. 10, pp. 2531–2540, Oct. 2013.
- [5] H. Yoo, Y. Lee, and I.-C. Park, “7.3 Gb/s universal BCH encoder and decoder for SSD controllers,” in Proc. Asia South Pacific Design Autom. Conf., Jan. 2014, pp. 37–38.
- [6] L. M. Zhang and F. R. Kschischang, “Low-complexity soft-decision concatenated LDGM-staircase FEC for high bit-rate fiber-optic communication,” J. Lightw. Technol., vol. 35, no. 18, pp. 3991–3999, Sep. 2017.
- [7] M. Milicevic, “Low-density parity-check decoder architectures for integrated circuits and quantum cryptography,” Ph.D. dissertation, Dept. of Electrical & Computer Engineering, University of Toronto, 2017.
- [8] M. Ardakani and F. R. Kschischang, “A more accurate one-dimensional analysis and design of irregular LDPC codes,” IEEE Trans. Commun., vol. 52, no. 12, pp. 2106–2114, Dec. 2004.
- [9] B. P. Smith, M. Ardakani, W. Yu, and F. R. Kschischang, “Design of irregular LDPC codes with optimized performance-complexity tradeoff,” IEEE Trans. Commun., vol. 58, no. 2, pp. 489–499, Feb. 2010.
- [10] M. J. D. Powell, “A fast algorithm for nonlinearly constrained optimization calculations,” in Numerical Analysis. Springer, 1978, pp. 144–157.
- [11] L. M. Zhang and F. R. Kschischang, “Staircase codes with 6% to 33% overhead,” J. Lightw. Technol., vol. 32, no. 10, pp. 1999–2002, May 2014.
- [12] J. Zhao, F. Zarkeshvari, and A. H. Banihashemi, “On implementation of min-sum algorithm and its modifications for decoding low-density parity-check (LDPC) codes,” IEEE Trans. Commun., vol. 53, no. 4, pp. 549–554, Apr. 2005.
- [13] K. Onohara, T. Sugihara, Y. Konishi, Y. Miyata, T. Inoue, S. Kametani, K. Sugihara, K. Kubo, H. Yoshida, and T. Mizuochi, “Soft-decision-based forward error correction for 100 Gb/s transport systems,” IEEE J. Sel. Topics Quantum Electron., vol. 16, no. 5, pp. 1258–1267, Sep. 2010.
- [14] Y. Miyata, K. Kubo, K. Sugihara, T. Ichikawa, W. Matsumoto, H. Yoshida, and T. Mizuochi, “Performance improvement of a triple-concatenated FEC by a UEP-BCH product code for 100 Gb/s optical transport networks,” in OptoElectronics and Comm. Conf., Jun. 2013, pp. (ThR2–2)1–3.
- [15] D. Chang, F. Yu, Z. Xiao, N. Stojanovic, F. N. Hauske, Y. Cai, C. Xie, L. Li, X. Xu, and Q. Xiong, “LDPC convolutional codes using layered decoding algorithm for high speed coherent optical transmission,” in Proc. IEEE/OSA Optical Fiber Commun. Conf., 2012, pp. (OW1H.4)1–3.
- [16] D. Morero, M. Castrillon, F. Ramos, T. Goette, O. Agazzi, and M. Hueda, “Non-concatenated FEC codes for ultra-high speed optical transport networks,” in Proc. IEEE Global Telecommun. Conf., Dec. 2011, pp. 1–5.
- [17] K. Sugihara, K. Ishii, K. Dohi, K. Kubo, T. Sugihara, and W. Matsumoto, “Scalable SD-FEC for efficient next-generation optical networks,” in Proc. Eur. Conf. Exhibit. Opt. Commun., 2016, pp. 568–570.
- [18] D. Chang, F. Yu, Z. Xiao, Y. Li, N. Stojanovic, C. Xie, X. Shi, X. Xu, and Q. Xiong, “FPGA verification of a single QC-LDPC code for 100 Gb/s optical systems without error floor down to BER of ,” in Proc. IEEE/OSA Optical Fiber Commun. Conf., 2011, pp. (OTuN2)1–3.