Improved Design of Unequal Error Protection LDPC Codes

. We propose an improved method for designing unequal error protection (UEP) low-density parity-check (LDPC) codes. The method is based on density evolution. The degree distribution with the best UEP properties is found, under the constraint that the threshold should not exceed the threshold of a non-UEP code plus some threshold o ﬀ set. For di ﬀ erent codeword lengths and di ﬀ erent construction algorithms, we search for good threshold o ﬀ sets for the UEP code design. The choice of the threshold o ﬀ set is based on the average a posteriori variable node mutual information. Simulations reveal the counter intuitive result that the short-to-medium length codes designed with a suitable threshold o ﬀ set all outperform the corresponding non-UEP codes in terms of average bit-error rate. The proposed codes are also compared to other UEP-LDPC codes found in the literature.


Introduction
In many communication scenarios, such as wireless networks and transport of multimedia data, sufficient error protection is often a luxury.In these systems, it may be wasteful or even infeasible to provide uniform protection for all information bits.Instead, it is more efficient to protect the most important information more than the rest, by using a channel code with unequal error protection (UEP).This implies improving the performance of the more important bits by sacrificing some performance of the less important bits.This paper focuses on the design of UEP low-density parity-check (LDPC) codes with improved average bit-error rate (BER).
In this work, we consider the flexible UEP-LDPC code design proposed in [3], which is based on a hierarchical optimization of the variable node degree distribution for each protection class.The algorithm maximizes the average variable node degree within one class at a time while guaranteeing a minimum variable node degree as high as possible.The optimization can be stated as a linear programming problem and can, thus, be easily solved.To keep the average performance of the UEP-LDPC code reasonably good, the search for UEP codes is limited to degree distributions whose convergence thresholds lie within a certain range of the minimum threshold of a code with the same parameters.In the following, we call the threshold offset.
In the latest years, much effort has been spent on construction algorithms for short-to-medium-length LDPC codes, [12][13][14].However, these algorithms rely on degree distributions optimized for infinitely long codes and focus on constructing LDPC code graphs with a small number of short cycles, thereby improving the performance in the error-floor region for short LDPC codes.In the design proposed here, we optimize the threshold offset given the construction algorithm used to specify the parity-check matrix of the code.The improved UEP codes have an average performance that is better than the corresponding non-UEP codes (with = 0 dB), which may seem counter-intuitive.Typically, the reduced error rate of the most protected class is compensated for by an increased error rate of the other classes.Nonetheless, we show that with a good choice of the threshold offset and for several common code construction algorithms, the performance of the UEP code is significantly better than the performance of the corresponding non-UEP code.However, for long codes and a high number of decoder iterations, the UEP code design reduces the performance since the UEP codes have worse thresholds than the non-UEP codes.The performance for different values of the threshold offset is found in [3], which shows that a threshold offset of 0.1 dB is a good choice.This is true for the random construction used in [3], but it is not noted that the best choice of the threshold offset varies for different construction algorithms.
Some intuition as to why UEP code design may increase the average performance can be gained by considering irregular LDPC codes, not designed for UEP, and their advantages compared to regular LDPC codes, [15].In irregular codes, variable nodes with high degree typically correct their value quickly and these nodes can then help to correct lower degree variable nodes.Therefore, irregular graphs may lead to a wave effect, where the highest degree nodes are corrected first, then the nodes with slightly lower degree, and so on.The more irregular a code is, that is, the higher the maximum variable node degree, the faster the correction of the high degree variable nodes.There are reasons to believe that the code with the best threshold under an appropriate constraint on the allowed number of iterations, that is, a code with fast convergence, yields the best performance for finite-length codes also when the number of iterations is high, [16].UEP code design is another way to achieve the differentiation between nodes that may lead to a wave effect and fast convergence.By allowing the code to have a worse threshold (as is the case in the UEP code design we consider), more differentiation between nodes in different classes can be achieved.It should also be noted that there is a trade-off between the maximum variable node degree and the codeword length.The maximum variable node degree should be lower for a short code to reduce the number of harmful cycles involving variable nodes of low degree.The wave effect achieved by the UEP design is accomplished without increasing the maximum variable node degree.
Let us recall some basic notation of LDPC codes.The sparse parity-check matrix H has dimension where k and n are the lengths of the information word and the codeword, respectively.We consider irregular LDPC codes with edge-based variable node and check node degree distributions defined by the polynomials [16] , where d v max and d c max are the maximum variable and check node degree of the code, respectively.For UEP codes, we divide the variable nodes into several protection classes (C 1 , C 2 , . . ., C Nc ) with degrading level of protection.The resulting variable node degree distribution is defined by the coefficients λ , which denote the fractions of edges incident to degree-i variable nodes of protection class C j .The overall degree distribution is given by λ In the following, we distinguish between code design, by which we mean the design of degree distributions that describe a code ensemble, and code construction, by which we mean the construction of a specific code realization (described by a parity-check matrix).

Design of Finite-Length UEP Codes
In [16], Richardson et al. state that for short LDPC codes, it is not always best to pick the degree distribution pair with the best threshold.Instead, it can be advantageous to look for the best possible threshold under an appropriate constraint on the allowed number of iterations.In this paper, we show that by searching among degree distributions designed for UEP with worse threshold than the corresponding non-UEP degree distributions, we may find degree distributions with significantly lower error rates for a finite length than the degree distributions with the best possible threshold.Well-designed UEP codes have faster convergence for all protection classes and thereby better performance for finitelength LDPC codes.

Detailed Mutual Information
Evolution.An appropriate method for analyzing UEP codes is needed to choose a good value for the threshold offset , without relying on time-consuming error rate simulations.We consider the theoretical mutual information (MI) functions, which are typically calculated from the degree distributions λ(x) and ρ(x) of a code.However, different LDPC codes with the same degree distributions can have very different UEP properties, [17].The differences depend on how different protection classes are connected, which in turn depends on the code construction algorithm used to place the edges in the graph according to the given degree distributions.
To observe the differences also between codes with equal degree distributions, a detailed computation of MI may be performed by considering the edge-based MI messages traversing the graph instead of node-based averages.This has been done for protographs in [18].We follow the same approach, but use the parity-check matrix instead of the protograph base matrix.See [19,20] for more details on MI analysis.The detailed MI evolution is described in detail in the appendix.In the following, we use the average a posteriori variable node MI denoted by I APPv (calculated for each variable node in step (5) of the MI analysis in the appendix) to compare the convergence rates of different LDPC codes.

Design Procedure.
For simplicity, a good value of is found through an exhaustive search in a region of typical values.In the following section, we show that there is only a small difference in MI and BER for similar values of .It is therefore reasonable to consider only a few values of in the search and the best value among these is likely to give a BER result very close to what could be achieved by a more thorough search.For each value of in the range of the search, three steps must be performed.
(1) Design a UEP code following [3] for the under consideration, keeping ρ(x), d v max , and the proportions between the protection classes fixed.This step results in subdegree distributions for each protection class.
(2) Construct a parity-check matrix using an appropriate code construction algorithm.
(3) Calculate the detailed MI evolution for a given E b /N 0 and a maximum number of decoder iterations.The code with the highest average I APPv has the best overall performance within this family of codes.
The value of the threshold offset is optimized for a specific E b /N 0 , which means that a code that is optimized for low E b /N 0 may perform worse for high E b /N 0 , and vice versa.
For UEP codes, the proportions between the protection classes also affect the UEP properties of a code and thereby are also the best choice of .In our simulations we have seen that with 20% of the information bits in the most protected class C 1 and 80% in a less protected class C 2 , good performance is achieved for rate 1/2 codes of different lengths.We therefore omit further investigations of the effect of different proportions between the protection classes.

Design Examples
We design UEP codes of lengths n = 2048 and n = 8192.All codes are designed using the check node degree distributions given in [16, Table II].The performance of any UEP code is compared to the performance of a non-UEP code with the variable node degree distribution that gives the best threshold, also tabulated in [16,Table II].A maximum of 100 decoder iterations is allowed.Except for the variable node degree distribution, the UEP codes and the corresponding non-UEP code have the same parameters.We consider only rate-1/2 LDPC codes.All UEP codes presented in this section have 20% of the information bits in C 1 and the remaining 80% in C 2 .A third protection class contains all parity bits.We first focus on design of generalized ACE constrained progressive edge-growth (PEG) codes [14] (in the following denoted by PEG-ACE codes) in Section 3.1.The random construction and the PEG construction algorithm [12] are considered in Section 3.2.
The progressive edge-growth (PEG) construction algorithm is an efficient algorithm for the construction of parity-check matrices with large girth (the length of the shortest cycle in the Tanner graph) by progressively connecting variable nodes and check nodes [12].The approximate cycle extrinsic message degree (ACE) construction algorithm lowers the error floor by emphasizing both the number of edges from variable nodes in a cycle to nodes in the graph that are not part of the cycle as well as the length of cycles [13].The PEG-ACE construction algorithm is a generalization of the popular PEG algorithm, that is shown to generate good LDPC codes with short and moderate block lengths having large girth [14].If the creation of cycles cannot be avoided while adding an edge, the PEG-ACE construction algorithm chooses an edge that creates the longest possible cycle with the best possible ACE constraint.

Optimization of the Threshold Offset for PEG-ACE Codes.
Six different PEG-ACE codes with varying are designed and constructed according to the design procedure in Section 2.2 Non-UEP codes correspond to = 0 dB.These codes have length n = 2048 and allowed maximum variable node degree d v max = 20.Figure 1 shows the average a posteriori variable node MI as a function of decoder iterations at two different E b /N 0 .For a low number of iterations, a large gives fast convergence for both E b /N 0 shown.This implies that for applications where only a small number of decoder iterations are allowed, a large yields the best performance.The average I APPv at E b /N 0 = 1 dB is maximized by = 0.5 dB.After 100 iterations, = 0.4 dB gives the highest average I APPv , but simulations show that the code with = 0.5 dB outperforms the code with = 0.4 dB at low E b /N 0 .At E b /N 0 = 1.5 dB, = 0.3 dB maximizes the average I APPv .The variable node degree distributions for the PEG-ACE codes with = 0.3 dB and = 0.5 dB are tabulated in Table 1.The random code with = 0.1 dB will be considered in Section 3.2.
Figure 2 shows the BER performance of the two protection classes containing information bits for = 0.3 dB and = 0.5 dB.The BER of the non-UEP code is shown for comparison.The figure shows that the code with = 0.5 dB performs well for low E b /N 0 as expected, while the code with lower has less UEP capability but better average performance at high E b /N 0 .The average BER is just slightly lower than the BER of C 2 , since the average BER is calculated from the BERs of the two protection classes containing information bits, scaled with the proportions of the classes.
Table 1: Variable node degree distributions for two PEG-ACE codes ( = 0.3 dB and = 0.5 dB) and the random = 0.1 dB code.Note that both classes of these UEP codes perform better than the comparable non-UEP code.In addition, the UEP codes offer a small difference in BER between the classes.Figure 3 shows the performance of three PEG-ACE codes of length n = 8192 and allowed maximum variable node degree d v max = 30.The non-UEP code is compared to a code optimized for low E b /N 0 (which gives = 1.1 dB) and a code optimized for high E b /N 0 (which gives = 0.4 dB).Both classes of the two UEP codes perform better than the non-UEP code.At E b /N 0 = 1.2 dB, the UEP code with = 0.4 dB has an average BER which is around one magnitude less than the non-UEP code.

Code Design for Other Construction Algorithms.
For given degree distributions, it has been shown that the choice of the construction algorithm strongly affects the UEP properties of the LDPC code, [17].For codes with little inherent UEP (e.g., PEG and PEG-ACE codes), the threshold offset needs to be large to yield a code with good UEP capability.On the other hand, for codes with significant inherent UEP (e.g., randomly constructed codes), a high may make the less protected classes so badly protected that a wave effect does not occur.Figure 4 shows the performance of codes of length n = 2048 constructed by three different algorithms: the random construction, only avoiding cycles of length 4, the PEG construction algorithm, and the PEG-ACE construction algorithm.The figure shows the BER of the non-UEP codes as well as the BER of classes C 1 and C 2 of the UEP codes.The variable node degree distributions of the UEP codes are given in Table 1.Note that the PEG = 0.5 dB  code has the same variable node degree distribution as the PEG-ACE = 0.5 dB code.
For the random code, MI calculations at E b /N 0 = 1 dB show that the non-UEP code gives the highest MI, except at very few decoder iterations.At E b /N 0 = 1.5 dB, the code with = 0.1 dB is slightly better than other choices of after around 50 iterations.Thereby it can be assumed that the non-UEP random code will perform better at low E b /N 0 , and the UEP random code with = 0.1 dB will perform better at high E b /N 0 .This is confirmed by the results shown in Figure 4.For the PEG and PEG-ACE code, the threshold offset = 0.5 dB used to design the codes gives the maximum MI at E b /N 0 = 1 dB.For both codes, = 0.3 dB gives higher MI at E b /N 0 = 1.5 dB, but for the PEG code there is only a slight difference in MI between these two values of .
The figure shows that both the PEG and the PEG-ACE UEP codes have significantly better performance than the corresponding non-UEP codes at low E b /N 0 .Remember that the PEG-ACE code with = 0.3 dB performs better for high E b /N 0 .The PEG and PEG-ACE construction algorithms result in codes with little inherent UEP and the UEP capabilities gained by the relatively high give faster convergence of the codes.However, the random UEP code has only a slightly lower average BER than the non-UEP code at high E b /N 0 .Note that the average performance of random codes with > 0.1 dB is worse than for the non-UEP code.
That is, for the random code with much inherent UEP there is not as much to gain by the UEP code design as for the PEG and the PEG-ACE codes, which have little inherent UEP.
These results show as expected that a PEG or PEG-ACE code should typically be chosen instead of a random code, even if the application benefits from UEP.For a large range of E b /N 0 , the most protected class of the PEG and PEG-ACE code has only slightly worse performance than the random code, while the average BER is much higher for the random code.This paper shows that we can improve both the average BER performance and the UEP capability by optimizing the threshold offset.

Comparison to
Other UEP-LDPC Codes.UEP-LDPC codes of similar length and rate as the codes presented here can be found in [6,7].Ma and Kwak [6] propose a partially regular code design, where all variable nodes in one protection class have the same degree.Good variable node degrees for each class are found through density evolution using the Gaussian approximation.Figures 5 and 6 show the performance of the code designed by Ma and Kwak together with the performance of two PEG-ACE codes (also shown in Figure 2).All these codes have n = 2048 and d v max = 20.The code designed by Ma and Kwak has 12.5% of the information bits in C 1 and 87.5% in C 2 , compared to the codes proposed in this paper where 20% of the information bits belong to C 1 .Note that Ma and Kwak [6] present the performance after only 10 decoder iterations, so in Figure 5 we compare their code to the PEG-ACE codes after 10 iterations.Figure 6 demonstrates the performance of the same codes after 100 iterations.The performance of the Ma and Kwak code for 10 iterations is taken directly from [6].To find the performance after 100 iterations, we have run simulations with a code constructed according to the specifications given in [6].It has been verified that our simulations give the same result as shown in [6] after 10 iterations.
Figure 5 shows that after only 10 decoder iterations, the PEG-ACE = 0.5 dB code performs best at low E b /N 0 .This is in accordance with Figure 1, which demonstrates that the code with the highest has the best average MI when the number of decoder iterations is low.However, at high E b /N 0 , the code proposed by Ma and Kwak has a lower average BER (C 2 performs better).The PEG-ACE = 0.3 dB code performs almost the same as the Ma and Kwak code, except at high E b /N 0 , where C 2 of the PEG-ACE code has worse performance.
After 100 decoder iterations, see Figure 6, the PEG-ACE = 0.5 dB code performs well at low E b /N 0 compared to the code designed by Ma and Kwak.Up to E b /N 0 = 1.5 dB, there is a gain of around 0.13 dB for C 1 and around 0.1 dB for C 2 for the different BERs.At E b /N 0 = 1.8 dB, the Ma and Kwak code performs slightly better than the PEG-ACE = 0.5 dB code.The PEG-ACE = 0.3 dB code has a little bit lower BERs than the Ma and Kwak code at all E b /N 0 .
Note that there is a significant difference in BER between C 1 and C 2 after 10 iterations, while the difference is much smaller after 100 iterations.This is typical for codes constructed using the PEG or PEG-ACE algorithm [17].However, if 100 iterations are allowed, both classes have a lower BER than the most protected class have after only 10 iterations.Thus, if a reasonably high number of iterations can be allowed in terms of time and complexity, it is better to run many iterations even if the difference in error protection between the classes is reduced.Yang et al. [7] present simulation results for an irregular UEP-LDPC code of length n = 10000 and d v max = 11, which may be compared to the PEG-ACE codes proposed here with n = 8192 and d v max = 30.Figure 7

Conclusions
We have proposed an improved design algorithm for UEP-LDPC codes, resulting in codes with reduced average BER.The algorithm searches for good threshold offsets for the UEP design, given different codeword lengths and different construction algorithms.The choice of the threshold offset

Figure 1 :
Figure 1: Average a posteriori variable node MI as a function of decoder iterations for six different PEG-ACE codes with n = 2048 and d v max = 20.For a low number of iterations, a large gives fast convergence for both E b /N 0 shown.For a larger number of iterations (around 60), = 0.5 dB gives the highest MI at E b /N 0 = 1 dB, and = 0.3 dB gives the highest MI at E b /N 0 = 1.5 dB.

Figure 2 :
Figure 2: BER performance of three PEG-ACE codes with length n = 2048 and allowed d v max = 20.The average BER is shown for the non-UEP code, while the BERs of both C 1 and C 2 are shown for the UEP codes.Both classes of the UEP codes perform better than the non-UEP code.

Figure 3 :
Figure 3: BER performance of non-UEP and UEP codes of length n = 8192 and d v max = 30.Both classes of the two UEP codes have lower BER than the non-UEP code.The code optimized for a low E b /N 0 (0.5 dB) with = 1.1 dB performs best at low E b /N 0 , while the code optimized for high E b /N 0 (1 dB) with = 0.4 dB has a lower average BER at E b /N 0 above 0.8 dB.

Figure 4 :
Figure 4: BER performance of non-UEP and UEP codes, constructed by three different construction algorithms.All codes have n = 2048 and allowed d v max = 20.The random code has good UEP capability already for = 0.1 dB, while the PEG code and the PEG-ACE code have less UEP capability for = 0.5 dB.All UEP codes have better average performance than the corresponding non-UEP codes, except for the random code at low E b /N 0 .

1 EFigure 5 :
Figure 5: BER performance of the PEG-ACE = 0.5 dB code and the code designed by Ma and Kwak [6] after 10 decoder iterations.Both codes have n = 2048 and d v max = 20.
shows the performance of these codes.Note that Yang et al. divide the information bits into three different protection classes, 1485 bits in C 1 , 307 bits in C 2 , and 3208 bits in C 3 .The PEG-ACE = 0.4 dB code performs best for high E b /N 0 .At E b /N 0 = 1.2 dB, C 2 of the PEG-ACE = 0.4 dB code has a lower BER than C 1 of the code designed by Yang et al.At low E b /N 0 , the PEG-ACE = 0.4 dB code has similar performance as the code designed by Yang et al.The PEG-ACE = 1.1 dB code has very good performance at low E b /N 0 , and at E b /N 0 up to 0.7 dB the average BER is lower than the BER of the most protected class in the code designed by Yang et al.

1 EFigure 6 :Figure 7 :
Figure 6: BER performance of two PEG-ACE codes and the code designed by Ma and Kwak [6] after 100 decoder iterations.Both codes have n = 2048 and d v max = 20.The PEG-ACE = 0.3 dB code performs slightly better than the code designed by Ma and Kwak for both classes.The PEG-ACE = 0.5 dB code performs much better than the Ma and Kwak code for low E b /N 0 , but C 2 has slightly higher BER at high E b /N 0 .