Computing Algorithms for LDPC Coded Internet-of-Things

,


I. INTRODUCTION
Internet-of-things (IoT) has recently emerged as a promising enabling technique for a wide class of applications [1]- [7]. For IoT-aided sensing networks, the sink node may not be interested in the original messages. For example, the sink node may be interested in the modulo-sum of the original messages. This requires improved design of the IoT transmission schemes. Particularly, cross-layer design may be required. The classical example of computing channel is the two-way relay channel with physical-layer network coding [8].
As a class of capacity-approaching codes, low-density parity-check (LDPC) codes have been widely adopted in emerging wireless communication systems to achieve reliable information transmission [9]- [11]. Since the power and the computing capability of the nodes in IoT are limited, new codes and modulations should be developed [1], [6], [12]. Furthermore, IoT may be used to support various applications The associate editor coordinating the review of this manuscript and approving it for publication was Jiankang Zhang . with differing latency and reliability requirements. These requirements pose further challenges on the implementation of IoT.
Superposition is a common phenomenon in communication systems. Superposition is introduced artificially in modulation to achieve the channel capacity [13]. In power domain non-orthogonal multiple access, superimposed signals are generated deliberately to improve the spectral efficiency [14]. In IoT, signals of different sensing nodes are superimposed at the sink node. The classical channel model which characterizes this phenomenon is the Gaussian interference channels (GIFC). In GIFC, the sink node is only interested in the messages of its intended transmitter. In modulo-sum computing [15]- [18], the sink node is interested in the modulo-sum of the messages. It can be seen that, instead of decoding all the messages, the receiver is interested in decoding a linear transformation of the messages. In [18], the authors analyzed the distance spectrum of coded Gaussian two-way relay channels with binary input. In [16], the authors developed a framework to optimize finite-length LDPC codes for twoway relay channels. In [19], the authors presented a class of invertible-subset LDPC codes with improved error correction capacity for orthogonal frequency division multiplexing systems. In [20], decoding algorithms for LDPC coded GIFC were presented. The optimization of LDPC codes for GIFC was considered in [21]. To the best knowledge of the authors, very few works in the literature focused on the design of computing algorithms for LDPC coded IoT networks.
This paper focuses on the design of computing algorithms for IoT which employs LDPC codes for transmission. We assume that all IoT devices are the same, which means that they employ the same binary LDPC code in the physical layer. We first present three representations of the considered systems, based on which three multistage computing algorithms are proposed, which are decodingcomputing (DC) algorithm, computing-decoding (CD) algorithm, and computing-decoding-computing (CDC) algorithm. Secondly, we show that the considered system admits a compact normal graph representation, based on which a joint computing algorithm is proposed. Thirdly, we consider the applications of the proposed algorithms to Gaussian interference channels (GIFC) and modulo-sum computing. Numerical results show that the optimality of the proposed algorithms depends on the channel conditions and the computing functions. Numerical results also show that the joint computing algorithm reveals the best performances for a variety of scenarios. Finally, we present a simulation-based optimization procedure to design finite-length LDPC codes for the joint computing algorithm. Numerical results show that for the considered system performance improvements are obtained by optimizing the LDPC codes.
The rest of this paper is organized as follows. In Section II, the system model is presented. In Section III, we present the normal graphs and the corresponding iterative multistage computing algorithms. Section IV presents the joint computing algorithm. Applications of the proposed algorithms are presented in Section V and the finite-length design of LDPC codes is given in Section VI. Section VII concludes this paper.

II. SYSTEM DESCRIPTION AND PROBLEM STATEMENT A. BINARY LDPC CODES
A binary LDPC code C[n, k] is defined by a sparse binary parity-check matrix H. The length of the code is n and the dimension of the code is k. There are two different ways to specify an LDPC code ensemble, the edge degree distribution perspective and the node degree distribution perspective. For simplicity, the node degree distribution is used in this paper. We use i to denote the fraction of degree-i variable nodes and j to denote the fraction of degree-j check nodes. To write these in a compact form, we have In this paper, (x) is referred to as the variable-node degree distribution and (x) is referred to as the check-node degree

distribution. Obviously, we have
The variable-node degree distribution can be viewed as an element of an (N − 1)-dimension manifold in the N -dimension space and hence can be represented by an (N − 1)-dimensional vector = ( 1 , 2 , · · · , N −1 ).

B. THE LDPC CODED LINEAR SUPERPOSITION SYSTEM
Assume that there are l IoT devices who want to communicate with the sink node, see Fig. 1 for reference. The l IoT devices are assumed to be identical. Particularly, these l IoT devices employ the same LDPC codes for error correction and the same modulation for transmission. The i-th device wants to transmit the sequence u (i) of length k to the IoT sink node. To achieve reliable transmission, the sequence u (i) is encoded by the LDPC code before transmission. The encoding output is denoted as n−1 ). For modulation, the binary phase shift keying (BPSK) is used. For the i-th codeword, we use x (i) to denote the i-th modulated sequence for transmission. At the sink node, the received signal is y = (y 0 , y 1 , · · · , y n−1 ), where The channel coefficients are h 0 , h 1 , · · · , h l−1 . The z t is the mean zero Gaussian noise with variance σ 2 = N 0 /2. For simplicity, we assume that the channel coefficients h i 's are time-invariant. However, we allow the the amplitudes α (i) t 's to be time-varying. We impose the following power constraint on P (i) , which represents the power constraint of the i-th IoT device.
) T , which is composed of the coded bits VOLUME 8, 2020 at time t. Based on c t 's, we can define the following matrix.
It can be easily checked that , · · · , τ (c n−1 )). In this paper, we consider the following general problem.
How to compute v = τ (c) at the IoT sink node from the received sequence y?
Note that we may not interested in recovering all the message sequences. However, if this is the case, we have τ = I. It can be seen that the above problem is very general. We present in the following several approaches to achieve this goal.
• The straightforward solution is to decode c first and then compute τ (c). Algorithms follow this procedure will be referred to as decoding-computing algorithms.
To decode c, we require the likelihoods of its components, which are computed as for c t ∈ F l 2 and 0 ≤ t ≤ n − 1. The problem of the decoding-computing algorithm is that when the channel is bad we cannot achieve the reliably recovery of c.
• The second solution first computes the likelihoods and then decodes. Particularly, we first compute the likeli- for 0 ≤ t ≤ n − 1. Then, these likelihoods are used to initialize the computing algorithms for an l -level LDPC coded system. For simplicity, we will refer this algorithm as computing-decoding algorithm.
• The last solution is called the computing-decodingcomputing solution. In this solution, we first recover a linear transform of c by the linear mappingτ , then compute τ (c) from the decoding results. To ensure correct computing, we require that the linear mappingτ is invertible. Different from the decoding-computing algorithm, the computing-decoding-computing algorithms are initialized with the following likelihoods for 0 ≤ t ≤ n − 1. Interestingly, our simulation results indicate that the computing-decoding-computing algorithm has the best performances in certain scenarios.
To make it more clear, we have illustrated the relationships of all the involved variables in Fig. 2. The decodingcomputing algorithms follow the route y → x → c → v, the computing-decoding algorithms follow the route y → x → v, whereas the computing-decoding-computing algorithms follow the route y → x → w → c → v.

III. ITERATIVE MULTISTAGE COMPUTING ALGORITHMS
In this section, several iterative multistage computing algorithms are presented to recover τ (c). The LDPC code C[n, k] specified by the parity-check matrix H is used. A high-level normal graph for the considered system is shown in Fig. 3 (a). In a normal graph, edges are used to indicates the random variable and nodes are used to indicate local constraints on the random variables. For example, the = nodes in Fig. 3 represent the equality constraint. Following the convention, we use probability mass function (pmf) to denote the message of a random variable. For example, for a random variable Z , its associated message is represented by the real vector P Z . If a vector of messages is needed, we use the notation P Z (z), where Z is a random vector. To simplify the description of the algorithm, we use P A→B Z (z) to denote the message from node A to node B, where Z represents the random vector on the edge from A to B.
In the following, we present three multistage computing algorithms, which are decoding-computing (DC) algorithm, computing-decoding (CD) algorithm, and the computingdecoding-computing (CDC) algorithm. These algorithms depends on different normal graphical representations of the considered system, which are presented in Fig. 3. Fig. 3 (a) corresponds to the most straightforward representation. The DC algorithm works over the normal graph shown in Fig. 3 (a). Here, we omit the details of the DC algorithm since it is highly similar to the CD algorithm in Algorithm 1. We point out the the DC algorithm closely follows the well-known iterative multistage decoding algorithm. Note that the DC algorithm attempts to recover τ (c) by first recovering c and then applying the linear mapping τ . This algorithm has been shown in the literature to be ineffective for coded two-way relay channels.

A. THE CD ALGORITHM
We derive the basic principle underlying the CD algorithm in this subsection. Note that τ is a linear mapping, hence, With this result, we know that the binary vector v (i) is a codeword of the LDPC code. As a result, we may first compute the likelihood associated with v t , then use the iterative decoder to decode the message v t . We present in Fig. 3 (b) another normal graphs of the considered system. The CD algorithm works by exchanging messages over this normal graph. The procedure of CD algorithm closely follows the procedure of DC algorithm, except the initialization. For completeness, we present in the following the detailed procedure of the CD algorithm. During the decoding, the global iteration is executed with maximum I max iterations and the LDPC decoder is executed with maximum K max iterations.

Algorithm 1 The CD Algorithm
Compute the likelihoods f τ (y t |v t ) according to (5).
• Decoding: 2) Execute the LDPC decoder to compute P H→ V (i) (v (i) ). The maximum iteration of the LDPC decoder is I max , which is pre-specified.
3) The messages P V (i) (v (i) ) for decision is computed as 4) Ifv is a codeword, decoding stops and a success is delivered; otherwise set K = K + 1.
• Output: Output the decoding results.
Note that if the linear mapping τ is determined by the l × l identity matrix, the CD algorithm and the DC algorithm are the same. For the CD algorithm, we first map the l lengthn message sequences into l length-n message sequences. Note that the decoding complexity of CD algorithm is lower than that of the DC algorithm, since l is smaller than l. Furthermore, since DC algorithm may not work in low SNR region, we expect the CD algorithm to perform better than the DC algorithm.

B. THE CDC ALGORITHM
In the subsection, we present the computing method based on computing-decoding-computing. Letτ denote an invertible linear transform. In the CDC algorithm, the linear transformτ (c) is recovered first and then the intended function τ (τ −1τ (c)) is recovered. We require that after applying the linear transformτ we are able to find the intended message fromτ (c). The invertible functions satisfying this requirements depend on the properties of τ . It is difficult to give a general description of whichτ satisfies the requirement. The first candidate ofτ is the identity mapping, with which the CDC algorithm degenerates to the DC algorithm. Based on VOLUME 8, 2020 τ , we can define the following matrix (1) . . .
It can be easily checked that each row of the above matrix is a codeword of the LDPC code. This motivates us to present the CDC algorithm. We present in Fig. 3 (c) the normal graph by viewing w (t) as a codeword of the LDPC code. The CDC algorithm is implemented over this normal graph by exchanging messages. The decoding procedure of the CDC algorithm is similar to that of the CD algorithm. For space limitation, we omitted the details of the decoding procedure of the CDC algorithm. Note that the decoding complexity of the CDC algorithm depends on the invertible linear transformτ . To achieve lowcomplexity, we should design theτ appropriately. Other than complexity, other important aspects should also be considered. For example, for a given channel condition, how to determine the optimal linear mapτ to achieve the best performance. This problem is more involved and is not considered here. Furthermore, we should jointly design the local iteration number and the global iteration number to achieve the tradeoffs between performance and complexity. We point out that we may treat the CD algorithm and the CDC algorithm as message pre-processing techniques. Hence, they can be used in the joint computing algorithm in Section IV.

IV. JOINT COMPUTING ALGORITHM
Recall that c = (c 0 , c 1 , · · · , c n−1 ). As the c t is a lengthl binary vector, it can be viewed as a finite filed element of F q , where q = 2 l . Hence, we have cH T = (c 0 , c 1 , · · · , c n−1 )H T = 0, which means that c is a codeword the code specified by the parity-check matrix H. This observation motivates us to represent the considered system with the normal graph given in Fig. 4. It can be seen that this normal graph is completely different from those given in Section III. To decode, we operate the iterative message processing algorithm over this normal graph. For completeness, we present in the following the details of the joint algorithm.
The most important problem of the joint algorithm is that its decoding complexity grows exponentially with the number

Algorithm 2 The Joint Algorithm
• Initialization: The original likelihoods are used to initialize the decoder as P ). The maximum number of iteration is selected as K max .
• Output: Output the decoding results.
of IoT devices. Hence, the joint algorithm is applicable only for IoT systems with small l. On the other hand, the complexities of the iterative multistage algorithms in Section III grow linearly with l. Hence, they can be used for IoT systems with large l. Note that the computing-decoding-computing technique can also be incorporated into the joint algorithm to reduce the decoding complexity.

V. NUMERICAL RESULTS
Obviously, the linear transformation τ , the code, and the channel shall influence the performances of the proposed algorithms. In this section, we present numerical results to show the performances of different algorithms in computing different functions. Particularly, we consider the GIFC and modulo-sum computing. In our simulations, the additive Gaussian noise channel is assumed. The modulation is assumed to be the BPSK. The LDPC codes is decoded with the sum-product algorithm.

A. GAUSSIAN INTERFERENCE CHANNELS
In this subsection, we investigate the applications of the proposed algorithms in Gaussian interference channels. Consider the two-user symmetric Gaussian interference channels. We assume that a (3,6)-regular LDPC code constructed by the PEG algorithm [22] is employed. The girth of this code is 6. Due to the symmetry of the two users, we only consider the first pair of users. The first receiver serves as the sink node and the two transmitters serve as the sensing nodes. For fairness, we impose the constraint that P (0) = P (1) = P/2. The linear transformation computed by the sink node is τ = [1 0]. The DC algorithm, CD algorithm, CDC algorithm, and the joint computing algorithm are employed for decoding. For CDC algorithm, the invertible mappingτ is specified by the matrix 1 0 1 1 .
It can be seen that we can obtain τ (c) onceτ (c) is correctly recovered. Moderate interference and strong interference are considered in our simulations, which are (h 2 0 = 1, h 2 1 = 0.5) and (h 2 0 = 1, h 2 1 = 0.75). We present in Fig. 5 and Fig. 6 the simulation results. It can be seen from these curves that 1) For h 2 1 = 0.5, at BER = 10 −4 , the CDC algorithm has the best error performance, as in CDC algorithm the influence of the interference is mitigated in the computing procedure. In other algorithms, the influence of interference is not reduced. 2) For h 2 1 = 0.75, the best performance is achieved by the joint algorithm. Particularly, at BER = 10 −4 , at least 0.4 dB performance gain is obtained.

B. MODULO-SUM COMPUTING
Consider an IoT network with two sensing nodes and a sink node. The messages of the sensing nodes are coded with a rate 1/3 LDPC code C Kite [12288, 4096] [23]. The sink node is interested in computing the modulo-2 sum of the messages. That is, the sink node wants to compute c (0) ⊕ c (1) and the corresponding linear transform is defined by τ = [1 1]. This case appears when the sink node serves as the point for  information exchanging among the IoT devices. Following existing works, we assume that h 0 0 = h 2 1 = 1.0. Similarly, to achieve fairness, we impose that P (0) = P (1) = P/2. The joint computing algorithm and the CD algorithm are implemented for computing. We present in Fig. 7 the bit error rates of these two algorithms. In our simulations, both the CD algorithm and the joint computing algorithm are implemented with K max = 200. It can be seen that the joint algorithm performs about 0.2 dB better than the CD algorithm at BER = 10 −4 .
We further consider an IoT network with three sensing nodes and a sink node. Similarly, the messages of the sensing nodes are coded with the rate 1/3 LDPC code C Kite [12288,4096] and the sink node is interested in computing the modulo-2 sum c (0) ⊕ c (1) ⊕ c (2) . Similarly, we assume that h 0 0 = h 2 1 = h 2 2 = 1.0. For fairness, we assume that P (0) = P (1) = P (2) = P/3. The joint computing algorithm and the CD algorithm are implemented for computing. The simulation results are given in Fig. 8. In our simulations, both the CD algorithm and the joint computing algorithm are implemented with K max = 200. It can be seen that the joint computing algorithm performs about 0.1 dB better than  the CD algorithm at BER = 10 −4 . Note that the decoding complexity of the joint computing algorithm is higher than that of the CD algorithm.

VI. OPTIMIZATION OF FINITE-LENGTH LDPC CODES FOR THE JOINT ALGORITHM
It can be seen from the simulation results in Section V that for a variety of scenarios the best performance is achieved by the joint algorithm. This implies the wide applicability of the joint algorithm. In IoT with mission-critical applications, the latency is of great importance. For these applications, we should employ short-length LDPC codes. On one hand, it can be seen that when computing is considered, the channel model and the target of the considered system are different from the point-to-point links. A natural question is how about the performances of the codes optimized for point-to-point links in the proposed system. On the other hand, LDPC codes are typically optimized for long block length. When the length is short the optimization results may be misleading. Motivated by the above observations, we dedicated to the design of finite-length LDPC codes for the joint algorithm in this section. Obviously, the density evolution algorithm cannot be used since finite-length is our focus. Instead, a hybrid optimization algorithm based on simulation and the downhillsimplex algorithm is used. We noticed a similar optimization algorithm in [24]. The difference lies in the fact that we have different target. The basic idea of the proposed optimization algorithm is presented in the following.
In the proposed optimization procedure, d valid node degree distributions are generated at first. For each node degree distribution, we construct an LDPC code with the progressive edge-growth (PEG) algorithm [24] and then evaluate its frame error rate (FER) with the joint algorithm. During the iterations, we generate a new node degree distribution t in each iteration. The new generated t is then taken as the input of the PEG algorithm to generate a new LDPC code. If this new code performs better than the second worst code, the new generated distribution t is taken for consideration and the worst one is discarded. When the difference between the d codes is small, we terminate the iteration and output the code with the best FER as the optimization result. We omit the details for its simplicity.

1) OPTIMIZATION FOR GAUSSIAN INTERFERENCE CHANNELS
In this example, we execute the proposed optimization procedure to optimize finite-length LDPC codes for GIFC. Particularly, we consider the case with strong interference, that is we have h 2 1 = 0.75. We select the following initial parameters for our optimization.
• The code length is n = 4000. • The code rate is r = 0.5. • The maximum node degree is N = 6. • The number of candidate codes is d = 8. • The target SNR is 10.25 dB. After executing the optimization procedure, the optimized result is (1) Based on (1) (x), we construct two LDPC codes with the PEG algorithm [22]. The first code is a length-4000 code C (1) [4000, 2000] and the second code is a length-10000 code C (1) [10000, 5000]. Both codes have rate 0.5 and girth six. We present in Fig. 9 the performances of these two codes in GIFC with strong interference. For comparison, the bit error rates of two binary LDPC codes C (0) [4000,2000] and C (0) [10000, 5000] are also presented. These two codes are constructed with the degree distribution (0) (x) = 0.5072x 2 + 0.2506x 3 + 0.0840x 4 + 0.1582x 6 [25], which is optimized for AWGN channels. It can be observed that about 0.4 dB performance improvement is obtained with our optimization. The bit error rates of a (3,6)-regular LDPC code C reg [10000, 5000] is also included in Fig. 9 for comparison. The comparison shows that we can obtain about 2.1 dB performance improvement with the proposed optimization. We optimize the LDPC node degree distribution for modulosum computing. We select the following initial parameters for our optimization.
• The code length is n = 4500. • The code rate is r = 1/3. • The maximum node degree is N = 6. • The number of code is d = 8. • The target SNR is 6.05 dB. After executing the optimization procedure, the best code obtained is (2) Based on (2) (x), we use the PEG algorithm to construct an LDPC code C (2) [12288, 4096] with girth six. The error performances of this code are shown in Fig. 8. It can be seen that, at BER = 10 −5 , the optimized code C (2)

VII. CONCLUSION
In this paper, the design of computing algorithms at the sink node of LDPC coded IoT was considered. We focused on the case that all IoT devices are identical. We first presented three multistage computing algorithms based on three normal graphical representations. We then present a compact representation of the considered system and based on which we propose a joint algorithm. Applications of these algorithms in computing different linear functions are considered. The numerical results suggested that the optimality of the computing algorithms depends on channel conditions and the computing functions. We also considered the optimization of finite-length LDPC codes for the joint algorithm.