- DSP log - http://www.dsplog.com -

Viterbi with finite survivor state memory

Posted By Krishna Sankar On July 27, 2009 @ 5:26 am In Coding | 10 Comments

In the post on Viterbi decoder [1] and soft input Viterbi decoder [2], we discussed a convolutional encoding scheme with rate 1/2, constraint length $K=3$ and having generator polynomial $K=3$ and having generator polynomial $\left[ 7, 5\right]_8$. If the number of uncoded bits is $N$, then the number of coded bits at the output of the convolutional encoder is $2(N+K-1)$ . Decoding the convolutionaly encoded bits by Viterbi algorithm consisted of the following steps.

1. For group of two bits, compute Hamming distance or Euclidean distance (for hard decision or soft decision respectively)

2. For each of the $2^{K-1}=4$ states, compute the path metric knowing the following.

• Each state can be reached from only two previous states (out of the 4 possible states).
• For each possible transition, compute the branch metric by adding the path metric of the previous state to the Hamming/Euclidean distance of the transition
• Select the branch metric which is minimum among the two values and store it as the path metric for the current state

3. Store the survivor predecessor state for each state.

4. Once we have processed $2(N+K-1)$ received bits, we know that the convolution encoder has reached state 00. We start traceback from state 00, and given that we know the current and previous state, the $N$ input bits can be decoded.

However, when the number of input uncoded bits $N$is large, the memory requirements for a survivor state matrix of dimension $(2^{K-1})\mbox{ x } (N+K-1)$ becomes impossible to manage.

## Traceback with finite survivor memory

To be able to decode with finite survivor memory, lets say we need to start the traceback at some time instant $D+TB$ , where

$D$ is the decoding depth and

$TB$ is the traceback depth.

The sequence of events are as follows:

• At time instant $D+TB$, we start the traceback and continue tracing back through the survivor path $TB$ times. Once we are done with the traceback, we start estimating the $D$ decoded bits knowing the current state and previous state.
• Similarly, we again start the traceback at time $2D+TB$, do traceback $TB$ times and then decode bits from $2D$ to $D$.
• Once we reach the end of the input sequence at time instance $N+K-1$, we know that trellis has converged to state00 and then we do demodulation with traceback.

Figure: Viterbi traceback with finite survivor memory

Given that traceback speed is equal to storing the speed incoming coded bits, we can implement the above algorithm with a memory of $D+2TB$.

Note: The literature of different architectures for survivor state management is vast and is not explored in this post.

### Selecting start state for traceback

At time instant $D+TB$, there are multiple ways to select the state to

• Always start from a defined state (for example state 00)
• Start from the state which has the minimum path metric

From simulations, can identify the minimum value of traceback depth ($TB$), which results in performance comparable to infinite survivor path memory case. From simulations shown in the post on hard decision Viterbi decoder [1], we know that at $\frac{E_b}{N_0}=4\mbox{dB}$, results in a bit error rate of $10^{-2}$

Figure: BER vs traceback depth at Eb/N0 = 4dB

From simulations it has been observed that doing traceback depth of around 15 ensures that the obtained BER with finite survivor state memory is close to the BER with infinite survivor state memory. Note that $TB=15$ corresponds to around 5 times the constraint length of $K=3$.

Additionally, as expected starting traceback with from the state with minimum pathmetric shows better performance than always starting at state 00.

## Simulation results

Warning: This simulation took around 10hrs to complete. Am thinking that I will move to C code for simulations involving lots of for-loops.

Figure: BER for BPSK with convolutional coding with finite survivor state memory

## Reference

URL to article: http://www.dsplog.com/2009/07/27/viterbi-with-finite-survivor-state-memory/

URLs in this post:

[1] Viterbi decoder: http://www.dsplog.com/2009/01/04/viterbi/

[2] soft input Viterbi decoder: http://www.dsplog.com/2009/01/14/soft-viterbi/

[3] Matlab/Octave script for simulating bit error rate vs traceback for Eb/N0 = 4dB.: http://www.dsplog.com/db-install/wp-content/uploads/2009/07/script_bpsk_ber_vs_traceback_viterbi_decode.m

[4] Matlab/Octave script for simulating BER for BPSK with convolotional coding with hard/soft decision Viterbi decoding and with finite survivor state memory: http://www.dsplog.com/db-install/wp-content/uploads/2009/07/script_bpsk_ber_awgn_convolutional_code_soft_viterbi_decode_with_traceback.m

[5] Digital Communication: Third Edition, by John R. Barry, Edward A. Lee, David G. Messerschmitt: http://www.amazon.com/gp/redirect.html?ie=UTF8&location=http%3A%2F%2Fwww.amazon.com%2FDigital-Communication-John-R-Barry%2Fdp%2F0792375483&tag=dl04-20&linkCode=ur2&camp=1789&creative=9325

[6] Digital Communications by John Proakis: http://www.amazon.com/gp/redirect.html?ie=UTF8&location=http%3A%2F%2Fwww.amazon.com%2FDigital-Communications-John-Proakis%2Fdp%2F0072321113&tag=dl04-20&linkCode=ur2&camp=1789&creative=9325