comm.gpu.TurboDecoder

Decode input signal using turbo decoding with GPU

To use this object, you must install Parallel Computing Toolbox™ and have access to a supported GPU. If the host computer has a GPU configured, processing uses the GPU. Otherwise, processing uses the CPU. For more information about GPUs, see GPU Computing (Parallel Computing Toolbox).

Description

The comm.gpu.TurboDecoder System object™ decodes the input signal by using a parallel concatenated decoding scheme on a graphics processing unit (GPU). This decoding scheme uses the a-posteriori probability (APP) decoder as the constituent decoder. The constituent decoders use the same trellis structure and algorithm.

To decode an input signal using a turbo decoding scheme:

1. Create the comm.gpu.TurboDecoder object and set its properties.

2. 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

gpuTurboDec = comm.gpu.TurboDecoder

gpuTurboDec = comm.gpu.TurboDecoder(trellis,interlvrIndices,numIter)

gpuTurboDec = comm.gpu.TurboDecoder(___,Name,Value)

Description

gpuTurboDec = comm.gpu.TurboDecoder creates a GPU-based turbo decoder System object. This object uses an APP constituent decoder to iteratively decode the parallel-concatenated convolutionally encoded input data.

gpuTurboDec = comm.gpu.TurboDecoder(trellis,interlvrIndices,numIter) sets the TrellisStructure property to trellis, the InterleaverIndices property to interlvrIndices, and the NumIterations property to numIter.

gpuTurboDec = comm.gpu.TurboDecoder(___,Name,Value) sets properties using one or more name-value arguments in addition to any of the input argument combinations in previous syntaxes. For example, 'NumIterations',10 specifies the number of decoding iterations used for each call to the System object.

Properties

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.

TrellisStructure — Trellis description of constituent convolutional code

poly2trellis(4, [13 15], 13) (default) | structure

Trellis description of the constituent convolutional code, specified as a structure that contains the trellis description for a rate K ∕ N code. K is the number of input bit streams, and N is the number of output bit streams.

Note

K must be 1 for the turbo coder. For more information, see Coding Rate.

You can either use the poly2trellis function to create the trellis structure or create it manually. For more about this structure, see Trellis Description of a Convolutional Code and the istrellis function.

The trellis structure contains these fields.

numInputSymbols — Number of symbols input to encoder

2^K

Number of symbols input to the encoder, specified as an integer equal to 2^K, where K is the number of input bit streams.

Data Types: double

numOutputSymbols — Number of symbols output from encoder

2^N

Number of symbols output from the encoder, specified as an integer equal to 2^N, where N is the number of output bit streams.

Data Types: double

numStates — Number of states in encoder

power of 2

Number of states in the encoder, specified as a power of 2.

Data Types: double

nextStates — Next states

matrix of integers

Next states for all combinations of current states and current inputs, specified as a matrix of integers. The matrix size must be numStates by 2^K.

Data Types: double

outputs — Outputs

matrix of octal numbers

Outputs for all combinations of current states and current inputs, specified as a matrix of octal numbers. The matrix size must be numStates by 2^K.

Data Types: double

Data Types: struct

InterleaverIndicesSource — Source of interleaver indices

'Property' (default)

Source of interleaver indices, specified as 'Property'. The only valid setting for this property is Property, which uses the interleaver indices that you specify in the InterleaverIndices property.

Data Types: char | string

InterleaverIndices — Interleaver indices

(64:-1:1)' (default) | column vector of integers

Interleaver indices that define the mapping used to permute the codeword bits input to the decoder, specified as a column vector of integers. The vector must be of length L. Each element of the vector must be an integer in the range [1, L] and must be unique. L is the length of the decoded output message, dec.

Data Types: double

Algorithm — Decoding algorithm

'True APP' (default)

Decoding algorithm, specified as 'True APP'. The only valid setting is 'True APP', which implements true APP decoding.

Data Types: char | string

NumIterations — Number of decoding iterations

6 (default) | positive integer

Number of decoding iterations, specified as a positive integer. This property sets the number of decoding iterations used for each call to the object.

Data Types: double

NumFrames — Number of independent frames

1 (default) | positive integer

Number of independent frames present in the input and output data vectors, specified as a positive integer.

The object segments the input vector into NumFrames segments and decodes them independently. The output contains NumFrames decoded segments.

Data Types: double

Usage

Syntax

dec = gpuTurboDec(codeword)

Description

dec = gpuTurboDec(codeword) decodes the input data by using the parallel concatenated convolutional coding scheme. If the host computer has a GPU configured, the processing utilizes the GPU. Otherwise, the processing uses the CPU. The output is the decoded data.

Input Arguments

codeword — Parallel concatenated codeword

column vector

Parallel concatenated codeword, specified as a column vector.

To decrease data transfer latency, format the input signal as a gpuArray (Parallel Computing Toolbox) object. For more information, see Array Processing with GPU-based System Objects.

Data Types: double | single

Output Arguments

dec — Decoded message

binary-valued column vector

Decoded message, returned as a binary-valued column vector. The output signal is the same data type as the input. The object iterates and provides updates to the log-likelihood ratios (LLR) of the uncoded output bits. The output of the object is the hard-decision output of the final LLR update.

When the constituent convolutional code represents a rate 1/N code, the object sets the length dec to (M-2✕N_Tails)/(2✕N-1). M is the input vector length, and N_Tails is given by log₂(TrellisStructure.numStates)✕N. The length of dec equals the length of the interleaver indices.

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)

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

GPU-Based Turbo Decode BPSK Modulated Data

Transmit turbo-encoded blocks of BPSK-modulated data over a AWGN channel. Decode individual data frames by using a GPU-based turbo decoder System object and accumulate error statistics. Display the errors statistics after processing all of the data frames.

Specify the frame length. To produce repeatable results, use the random stream property with the seed set.

framelen = 256;
s = RandStream('mt19937ar',Seed=11);

Create a turbo encoder System object and GPU-based turbo decoder System object. Define the trellis structure for the constituent convolutional code by using the poly2trellis function. Generate the interleaver indices as a random column vector of unique integers that define the mapping used to permute the input bits at the encoder and decoder by using the randperm function to generate.

intrlvrIndices = randperm(s,framelen);
trellis = poly2trellis(4,[13 15 17],13);
turboEnc = comm.TurboEncoder( ...
    TrellisStructure=trellis, ...
    InterleaverIndices=intrlvrIndices);
turboDec = comm.gpu.TurboDecoder( ...
    TrellisStructure=trellis, ...
    InterleaverIndices=intrlvrIndices, ...
    NumIterations=4);

Define the modulation order for BPSK modulation. Define the SNR level for the AWGN channel. Create an error rate System object to calculate error statics. Run the simulation and calculate error results by comparing the original data to the received data.

M = 2;                      % BPSK modulation
snr = 2;                    % dB
numframes = 100;
errorRate = comm.ErrorRate;

for ii = 1:numframes
 data = randi(s,[0 1],framelen,1);
 encodedData = turboEnc(data);
 modSignal = pskmod(encodedData,M);
 rxsig = awgn(modSignal,2);
 demodsig = pskdemod(rxsig,M);
 rxbits = turboDec(demodsig);
 errorStats = errorRate(data,rxbits);
end
fprintf('BER = %f\nNumber of errors = %d\nTotal bits = %d\n', ...
errorStats(1),errorStats(2),errorStats(3))

BER = 0.001914
Number of errors = 49
Total bits = 25600

More About

Array Processing with GPU-based System Objects

A GPU-based System object accepts typical MATLAB^® arrays or gpuArray (Parallel Computing Toolbox) objects. The output signal data type matches the input signal data type.

• When the input signal to the GPU-based System object is a gpuArray object, calculations take place entirely on the GPU, the data remains on the GPU, and the output signal is a gpuArray object. Passing gpuArray arguments minimizes data transfer latency by limiting the number of data transfers between the CPU and the GPU when your simulation runs. For more information, see Establish Arrays on a GPU (Parallel Computing Toolbox).

• When the input signal is a MATLAB array, the GPU-based System object transfers the data between the CPU and the GPU for each object call. The output signal is a MATLAB array and data transfer latency occurs.

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 Accelerate Simulation Using GPUs.

Version History

Introduced in R2012a