comm.gpu.LDPCDecoder

Decode binary low-density parity-check (LDPC) code with GPU

To use this object, you must install Parallel Computing Toolbox™ and have access to an appropriate GPU. For more about GPUs, see GPU Computing (Parallel Computing Toolbox).

Description

A GPU-based System object™ accepts typical MATLAB^® arrays or objects created using the gpuArray class. A GPU-based System object supports input signals with double- or single-precision data types. The output signal inherits its data type from the input signal.

If the input signal is a MATLAB array, the System object handles data transfer between the CPU and the GPU. The output signal is a MATLAB array.
If the input signal is a gpuArray, the data remains on the GPU. The output signal is a gpuArray. When the object is given a gpuArray, calculations take place entirely on the GPU, and no data transfer occurs. Passing gpuArray arguments provides increased performance by reducing simulation time. For more information, see Establish Arrays on a GPU (Parallel Computing Toolbox).

The comm.gpu.LDPCDecoder System object uses the belief propagation algorithm to decode a binary LDPC code, which is input to the object as the soft-decision output (log-likelihood ratio of received bits) from demodulation. The object decodes generic binary LDPC codes where no patterns in the parity-check matrix are assumed. For more information, see Belief Propagation Decoding.

To decode an LDPC-encoded signal:

Create the comm.gpu.LDPCDecoder object and set its properties.
Call the object with arguments, as if it were a function.

To learn more about how System objects work, see What Are System Objects?.

Creation

Syntax

gpu_ldpcdecoder = comm.gpu.LDPCDecoder

gpu_ldpcdecoder = comm.gpu.LDPCDecoder(parity)

gpu_ldpcdecoder = comm.gpu.LDPCDecoder(___,Name,Value)

Description

example

gpu_ldpcdecoder = comm.gpu.LDPCDecoder creates a GPU-based binary LDPC decoder System object. This object performs LDPC decoding based on the specified parity-check matrix.

gpu_ldpcdecoder = comm.gpu.LDPCDecoder(parity) sets the ParityCheckMatrix property to parity and creates a GPU-based LDPC decoder System object. The parity input must be specified as described by the ParityCheckMatrix property.

gpu_ldpcdecoder = comm.gpu.LDPCDecoder(___,Name,Value) sets properties using one or more name-value pairs, in addition to inputs from any of the prior syntaxes. For example, comm.LDPCDecoder('DecisionMethod','Soft decision') configures an LDPC decoder System object to decode data using the soft-decision method and output log-likelihood ratios of data type double. Enclose each property name in quotes.

Properties

expand all

Unless otherwise indicated, properties are nontunable, which means you cannot change their values after calling the object. Objects lock when you call them, and the release function unlocks them.

If a property is tunable, you can change its value at any time.

For more information on changing property values, see System Design in MATLAB Using System Objects.

`ParityCheckMatrix` — Parity-check matrix
`dvbs2ldpc(1/2)` (default) | sparse binary matrix | nonsparse index matrix

Parity-check matrix, specified as a sparse (N – K)-by-N binary-valued matrix. N is the length of the received signal and must be in the range (0, 2³¹). K is the length of the uncoded message and must be less than N. The last (N – K) columns in the parity-check matrix must be an invertible matrix in the Galois field of order 2, gf(2).

You can also specify the parity-check matrix as a two-column nonsparse index matrix, I, that defines the row and column indices of the 1s in the parity-check matrix such that sparse(I(:,1),I(:,2),1).

This property accepts numeric data types. When you set this property to a sparse binary matrix, this property also accepts the logical data type.

The default value uses the dvbs2ldpc function to configure a sparse parity-check matrix for half-rate LDPC coding, as specified in the DVB-S.2 standard.

Example: dvbs2ldpc(R,'indices') configures the index matrix for the DVB-S.2 standard, where R is the code rate, and 'indices' specifies the output format of dvbs2ldpc as a two-column double-precision matrix that defines the row and column indices of the 1s in the parity-check matrix.

Data Types: double | logical

`OutputValue` — Output value format
`'Information part'` (default) | `'Whole codeword'`

Output value format, specified as one of these values:

'Information part' — The object outputs a K-by-1 column vector containing only the information-part of the received log-likelihood ratio vector. K is the length of the uncoded message.
'Whole codeword' — The object outputs an N-by-1 column vector containing the whole log-likelihood ratio vector. N is the length of the received signal.
N and K must align with the dimension of the (N–K)-by-K parity-check matrix.

Data Types: char

`DecisionMethod` — Decision method
`'Hard decision'` (default) | `'Soft decision'`

Decision method used for decoding, specified as one of these values:

'Hard decision' — The object outputs decoded data of data type logical.
'Soft decision' — The object outputs log-likelihood ratios of data type double.

Data Types: char

`IterationTerminationCondition` — Condition for iteration termination
`'Maximum iteration count'` (default) | `'Parity check satisfied'`

Condition for iteration termination, specified as one of these values:

'Maximum iteration count' — Decoding terminates after the number of iterations specified by the MaximumIterationCount property.
'Parity check satisfied' — Decoding terminates after all parity checks are satisfied. If not all parity checks are satisfied, decoding terminates after the number of iterations specified by the MaximumIterationCount property.

Data Types: char

`MaximumIterationCount` — Maximum number of decoding iterations
`50` (default) | positive integer

Maximum number of decoding iterations, specified as a positive integer.

Data Types: double

`NumIterationsOutputPort` — Output number of iterations performed
`false` (default) | `true`

Output number of iterations executed, specified as false or true. To output the number of iterations executed, set this property to true.

Data Types: logical

`FinalParityChecksOutputPort` — Output final parity checks
`false` (default) | `true`

Output final parity checks, specified as false or true. To output the final calculated parity checks, set this property to true.

Data Types: logical

Usage

Syntax

y = gpu_ldpcdecoder(x)

[y,numiter] = gpu_ldpcdecoder(x)

[y,parity] = gpu_ldpcdecoder(x)

[y,numiter,parity] = gpu_ldpcdecoder(x)

Description

example

y = gpu_ldpcdecoder(x) decodes input data using an LDPC code based on the default parity-check matrix.

[y,numiter] = gpu_ldpcdecoder(x) returns the decoded data, y, and number of iterations performed, numiter. To use this syntax, set the NumIterationsOutputPort property to true.

[y,parity] = gpu_ldpcdecoder(x) returns the decoded data, y, and final parity checks, parity. To use this syntax, set the FinalParityChecksOutputPort property to true.

[y,numiter,parity] = gpu_ldpcdecoder(x) returns the decoded data, number of iterations performed, and final parity checks. To use this syntax, set the NumIterationsOutputPort and FinalParityChecksOutputPort properties to true.

Input Arguments

expand all

`x` — Log-likelihood ratios
column vector

Log-likelihood ratios, specified as an N-by-1 column vector containing the soft-decision output from demodulation. N is the number of bits in the LDPC codeword before modulation. Each element is the log-likelihood ratio for a received bit. Element values are more likely to be 0 if the log-likelihood ratio is positive. The first K elements correspond to the information-part of the input message.

Data Types: double

Output Arguments

expand all

`y` — Decoded data
column vector

Decoded data, returned as a column vector. The DecisionMethod property specifies whether the object outputs hard decisions or soft decisions (log-likelihood ratios).

If the OutputValue property is set to 'Information part', the output includes only the information-part of the received log-likelihood ratio vector.
If the OutputValue property is set to 'Whole codeword', the output includes the whole log-likelihood ratio vector.

Data Types: double | logical

`numiter` — Number of executed decoding iterations
positive integer

Number of executed decoding iterations, returned as a positive integer.

Dependencies

To enable this output, set the NumIterationsOutputPort property to true.

`parity` — Final parity checks
column vector

Final parity checks after decoding the input LDPC code, returned as an (N-K)-by-1 column vector. N is the number of bits in the LDPC codeword before modulation. K is the length of the uncoded message.

Dependencies

To enable this output, set the FinalParityChecksOutputPort property to true.

Object Functions

To use an object function, specify the System object as the first input argument. For example, to release system resources of a System object named obj, use this syntax:

release(obj)

expand all

Common to All System Objects

`step`	Run System object algorithm
`release`	Release resources and allow changes to System object property values and input characteristics
`reset`	Reset internal states of System object

Examples

collapse all

LDPC Encode and Decode QPSK-Modulated Signal Using GPU

This example uses:

Open Live Script

Using a comm.gpu.LDPCDecoder System Object™ to decode the signal, transmit an LDPC-encoded, QPSK-modulated bit stream through an AWGN channel. After adding AWGN, demodulate and decode the received signal. Compute the error statistics for the reception of uncoded and LDPC-coded signals. For more information, see Simulation Acceleration Using GPUs.

Define simulation variables. Create System objects for the LDPC encoder, LDPC decoder, QPSK modulator, and QPSK demodulators.

M = 4; % Modulation order (QPSK)
snr = [0.25,0.5,0.75,1.0,1.25];
numFrames = 10;
ldpcEncoder = comm.LDPCEncoder;
gpuldpcDecoder = comm.gpu.LDPCDecoder;
pskMod = comm.PSKModulator(M,'BitInput',true);
pskDemod = comm.PSKDemodulator(M,'BitOutput',true,...
    'DecisionMethod','Approximate log-likelihood ratio');
pskuDemod = comm.PSKDemodulator(M,'BitOutput',true,...
    'DecisionMethod','Hard decision');
errRate = zeros(1,length(snr));
uncErrRate = zeros(1,length(snr));

For each SNR setting and all frames, compute the error statistics for uncoded and LDPC-coded signals.

for ii = 1:length(snr)
    ttlErr = 0;
    ttlErrUnc = 0;
    pskDemod.Variance = 1/10^(snr(ii)/10); % Set variance using current SNR
    for counter = 1:numFrames
        data = logical(randi([0 1],32400,1));
        % Transmit and receiver uncoded signal data
        mod_uncSig = pskMod(data);
        rx_uncSig = awgn(mod_uncSig,snr(ii),'measured');
        demod_uncSig = pskuDemod(rx_uncSig);
        numErrUnc = biterr(data,demod_uncSig);
        ttlErrUnc = ttlErrUnc + numErrUnc;
        % Transmit and receive LDPC coded signal data
        encData = ldpcEncoder(data);
        modSig = pskMod(encData);
        rxSig = awgn(modSig,snr(ii),'measured');
        demodSig = pskDemod(rxSig);
        rxBits = gpuldpcDecoder(demodSig);
        numErr = biterr(data,rxBits);
        ttlErr = ttlErr + numErr;
    end
    ttlBits = numFrames*length(rxBits);
    uncErrRate(ii) = ttlErrUnc/ttlBits;
    errRate(ii) = ttlErr/ttlBits;
end

Plot the error statistics for uncoded and LDPC-coded data.

plot(snr,uncErrRate,snr,errRate)
legend('Uncoded','LDPC coded')
xlabel('SNR (dB)')
ylabel('BER')

Algorithms

expand all

This object performs LDPC decoding using the belief propagation algorithm, also known as a message-passing algorithm.

Belief Propagation Decoding

The implementation of the belief propagation algorithm is based on the decoding algorithm presented by Gallager.

For transmitted LDPC-encoded codeword c = c₀, c₁, …, c_n_-1, the input to the LDPC decoder is the log-likelihood ratio (LLR) value $L (c_{i}) = \log (\frac{\Pr (c_{i} = 0 | channel output for c_{i})}{\Pr (c_{i} = 1 | channel output for c_{i})})$ .

In each iteration, the key components of the algorithm are updated based on these equations:

$L (r_{j i}) = 2 atanh (\prod_{i^{'} \in V_{j} \ i} \tanh (\frac{1}{2} L (q_{i^{'} j})))$ ,

$L (q_{i j}) = L (c_{i}) + \sum_{j^{'} \in C_{i} \ j} L (r_{j^{'} i})$ , initialized as $L (q_{i j}) = L (c_{i})$ before the first iteration, and

$L (Q_{i}) = L (c_{i}) + \sum_{j^{'} \in C_{i}} L (r_{j^{'} i})$ .

At the end of each iteration, L(Q_i) contains the updated estimate of the LLR value for transmitted bit c_i. The value L(Q_i) is the soft-decision output for c_i. If L(Q_i) < 0, the hard-decision output for c_i is 1. Otherwise, the hard-decision output for c_i is 0.

If configured to stop when all parity checks are satisfied, the algorithm verifies the parity-check equation (H c' = 0) at the end of each iteration. When all parity checks are satisfied, or if the maximum number of iterations is reached, decoding stops.

Index sets $C_{i} \ j$ and $V_{j} \ i$ are based on the parity-check matrix (PCM). Index sets C_i and V_j correspond to all nonzero elements in column i and row j of the PCM, respectively.

This figure highlights the computation of these index sets in a given PCM for i = 5 and j = 3.

To avoid infinite numbers in the algorithm equations, atanh(1) and atanh(-1) are set to 19.07 and –19.07, respectively. Due to finite precision, MATLAB returns 1 for tanh(19.07) and –1 for tanh(-19.07).

References

[1] Gallager, Robert G. Low-Density Parity-Check Codes. Cambridge, MA: MIT Press, 1963.

Extended Capabilities

GPU Arrays
Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

This System object runs on a GPU, and also supports GPU array inputs. For more information, see Simulation Acceleration Using GPUs.

Documentation

comm.gpu.LDPCDecoder

Description

Creation

Syntax

Description

Properties

ParityCheckMatrix — Parity-check matrix dvbs2ldpc(1/2) (default) | sparse binary matrix | nonsparse index matrix

OutputValue — Output value format 'Information part' (default) | 'Whole codeword'

DecisionMethod — Decision method 'Hard decision' (default) | 'Soft decision'

IterationTerminationCondition — Condition for iteration termination 'Maximum iteration count' (default) | 'Parity check satisfied'

MaximumIterationCount — Maximum number of decoding iterations 50 (default) | positive integer

NumIterationsOutputPort — Output number of iterations performed false (default) | true

FinalParityChecksOutputPort — Output final parity checks false (default) | true

Usage

Syntax

Description

Input Arguments

x — Log-likelihood ratios column vector

Output Arguments

y — Decoded data column vector

numiter — Number of executed decoding iterations positive integer

Dependencies

parity — Final parity checks column vector

Dependencies

Object Functions

Common to All System Objects

Examples

LDPC Encode and Decode QPSK-Modulated Signal Using GPU

Algorithms

Belief Propagation Decoding

References

Extended Capabilities

GPU Arrays Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

See Also

Objects

Functions

Blocks

Topics

Communications Toolbox Documentation

Support

`ParityCheckMatrix` — Parity-check matrix
`dvbs2ldpc(1/2)` (default) | sparse binary matrix | nonsparse index matrix

`OutputValue` — Output value format
`'Information part'` (default) | `'Whole codeword'`

`DecisionMethod` — Decision method
`'Hard decision'` (default) | `'Soft decision'`

`IterationTerminationCondition` — Condition for iteration termination
`'Maximum iteration count'` (default) | `'Parity check satisfied'`

`MaximumIterationCount` — Maximum number of decoding iterations
`50` (default) | positive integer

`NumIterationsOutputPort` — Output number of iterations performed
`false` (default) | `true`

`FinalParityChecksOutputPort` — Output final parity checks
`false` (default) | `true`

`x` — Log-likelihood ratios
column vector

`y` — Decoded data
column vector

`numiter` — Number of executed decoding iterations
positive integer

`parity` — Final parity checks
column vector

GPU Arrays
Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.