---
title: 'SC-PCC Decoder: Efficient Iterative Threshold Decoding'
url: https://www.emergentmind.com/topics/pccc-decoder
type: topic
---

# SC-PCC Decoder: Efficient Iterative Threshold Decoding

A Parallel-Concatenated Code (PCC) decoder, and specifically its spatially coupled variant (SC-PCC), constitutes a class of low-complexity iterative threshold decoders designed for turbo-like code constructions. When equipped with convolutional self-orthogonal component codes (CSOCs) and suboptimal a posteriori probability (APP) threshold decoding, the SC-PCC decoder approaches the maximum a posteriori (MAP) performance threshold and achieves significant coding gains with reduced power, latency, and implementation complexity relative to optimal algorithms [2109.01955].

## 1. Code Structure and Spatial Coupling

SC-PCCs are constructed using parallel concatenation of two CSOCs, each encoding a distinct permutation of the input. Each CSOC is a rate-\(R_c = \frac{k}{k+1}\) systematic convolutional code defined by constraint length \(\nu = k(m+1)\) and memory \(m\). Self-orthogonality ensures that for each information error bit \(e^{(i)}_l\), there are \(J\) parity-check equations \(A_j^{(i)}\), with no other error bit involved in more than one check. This structure guarantees a threshold decoding error-correction capability of \(\lfloor J/2 \rfloor\).

Example parameterization for a rate-\(2/3\) CSOC:
- \(k=2\), \(m=13\), \(J=4\)
- Generator sequences (octal): 
  - \(g_0 = (1\,0\,0\,1\,1\,0\,0\,0\,0\,0\,0\,0\,1)\)
  - \(g_1 = (1\,0\,1\,0\,0\,0\,0\,1\,0\,0\,0\,0\,0\,1)\)
- \(\nu = 28\), code rate \(R_c = 2/3\)

Spatial coupling is realized by dividing each information block \(\mathbf u_t\) (length \(T\)) into \(m_{sc}+1\) sub-blocks, forming a “coupled source matrix” \(\mathbf U\) such that each column is constructed from staggered sub-blocks across time and coupling depth. The matrix is zero-padded at boundaries, facilitating coupling across \(L\) blocks. Parallel interleaving and demultiplexing generate a permuted matrix \(\tilde{\mathbf U}\).

At encoder output, for each time \(t\), both \(\mathbf U_t\) and \(\tilde{\mathbf U}_t\) are encoded by their respective CSOCs (each terminated by \(\nu\) zeros), resulting in parity outputs \(\mathbf v_t^1\) and \(\mathbf v_t^2\) concatenated with the systematic output \(\mathbf v_t^0 = \mathbf u_t\):
\[
\mathbf v_t = (\mathbf v_t^0,\,\mathbf v_t^1,\,\mathbf v_t^2)
\]
The overall SC-PCC code rate is \(R \approx \frac{k}{k+2}\) for \(T \gg \nu\).

## 2. APP Threshold Decoding of CSOCs

Threshold decoding for CSOCs involves syndrome formation, LLR computation, and weighted thresholding:

1. **Syndrome Formation:** For each received symbol \(y_l^{(i)}\), a hard decision \(\hat y_l^{(i)}\) is made. The error bit \(e_l^{(i)} = \hat y_l^{(i)} \oplus x_l^{(i)}\) is computed. The syndrome is:
   \[
   s_l = \sum_{i=0}^{k-1}\sum_{b=0}^m \hat y_{l-b}^{(i)} g_{i,b} + \hat y_l^{(k)} = \sum_{i=0}^{k-1}\sum_{b=0}^m e_{l-b}^{(i)} g_{i,b} + e_l^{(k)}
   \]

2. **LLR (Reliability Factor):**
   \[
   L(e_l^{(i)}|y_l^{(i)}) = \ln \frac{\Pr\{e_l^{(i)}=0| y_l^{(i)}\}}{\Pr\{e_l^{(i)}=1| y_l^{(i)}\}} = \frac{4E_s}{N_0} |y_l^{(i)}| + L(e_l^{(i)})
   \]
   where \(L(e_l^{(i)})\) includes any a priori LLR from external decoder feedback.

3. **Self-Orthogonal Check Weighting:** For each check \(A_j^{(i)}\), the extrinsic weight is formed:
   \[
   w_j^{(i)} = \boxplus_{(\alpha, s)\in \mathcal{I}_j^{(i)}} L(e_s^{(\alpha)}| y_s^{(\alpha)})
   \]
   using the box-plus operation.

4. **Threshold Decision Rule:** The decoded estimate is:
   \[
   \hat e_l^{(i)} =
   \begin{cases}
   1, & \text{if } L(e_l^{(i)}| \{A_j^{(i)}\}, y_l^{(i)}) < 0 \\
   0, & \text{otherwise}
   \end{cases}
   \]
   where the full LLR argument includes self-orthogonal check extrinsic weight sums.

## 3. Sliding-Window Iterative Decoding Algorithm

The SC-PCC decoding algorithm employs a windowed message-passing procedure:

- A window size \(w \ge m_{sc}+1\) is selected, targeting block \(t\).
- The received data for \(w\) contiguous blocks is demultiplexed into coupled channel inputs for the two parallel streams.
- Two APP threshold decoders process their respective streams, exchanging extrinsic LLRs per block via turbo-style iterations.

The schedule is divided into vertical iterations (\(I_V\) forward sweeps per block) and horizontal iterations (\(I_H\) full forward-reverse sweeps). For each target block,
\[
I_w = 2wI_VI_H
\]
component decoder calls are made. Hard decisions are output after \(I_H\) horizontal iterations or on successful CRC.

Pseudocode (verbatim from [2109.01955]):

```python
Initialize t=0.
While t < L do
  Collect received blocks r_t,…,r_{t+w-1}.
  Demultiplex to form coupled inputs {Y_{t'}, ˜Y_{t'} for t'=t…t+w-1.
  For h = 1 to I_H do
    For t' = t to t+w-1 do    # Forward sweep
      For v = 1 to I_V do
        Decode block t' in Decoder 1 → extrinsic I^e_{t'}.
        Demux and interleave → a priori for Decoder 2.
        Decode block t' in Decoder 2 → extrinsic ˜I^e_{t'}.
        Demux and interleave → a priori for Decoder 1.
      End
    End
    For t' = t+w-1 down to t do  # Reverse sweep
      Repeat the same I_V exchanges.
    End
  End
  At completion of I_H sweeps, make hard decisions on target block t.
  Shift window: t ← t+1.
End
```

## 4. Latency, Memory, and Complexity

### Latency
- Encoding: Requires buffering \(m_{sc}+1\) input blocks, leading to latency \(\Delta_{enc} = (m_{sc} + 1)T\).
- Decoding: Windowed decoding of size \(w\) adds latency \(\Delta_d = wT\). Minimum window for \(m_{sc}=1\) is \(\Delta_d=2T\).

### Memory
- Encoder memory: \(M^{\rm e}_{SC-PCC} \approx T(m_{sc} + 1) + 2\nu\); for uncoupled PCC: \(T + 2\nu\).
- Decoder memory: Buffer for extrinsic LLRs \(Tw\), interleaver \(T\), syndrome/channel value registers per component \(4\nu\); total \(M^{\rm d}_{SC-PCC}\approx T(w+1)+8\nu\).

### Computational Complexity
- For block length \(T\), average nonzero taps per generator \(\tilde N_\varnothing \approx \gamma \nu\) with \(\gamma\approx 1/(1.5 k (k-1))\):

| Operation         | Per Component Decoder    |
|-------------------|------------------------|
| Multiplications   | \(T(k+1)\)             |
| Additions         | \(T(k+2\nu\gamma+1)\)  |
| Box-plus ops      | \(T\nu\gamma\)         |

Total for sliding window:
\[
C^d_{\rm SC-PCC} \approx 2wI_VI_H \times T(2k+3\nu\gamma+2)
\]

No BCJR trellis is employed, so the complexity scales linearly in \(\nu\). Parallelism is possible by decoding \(k\) information bits simultaneously ahead of syndrome updates.

## 5. Performance and Threshold Saturation

Performance evaluation in [2109.01955] demonstrates:

- For rate \(R=1/2\) (\(k=2, m=13, J=4\)), SC-PCC (\(m_{sc}=1, w=3, T=400, I_V=1, I_H=4\)) achieves a \(0.7\,\text{dB}\) gain over standard PCC at BER \(10^{-3}\) with similar complexity and latency.
- For rate \(R=4/5\) (\(k=8, m=136, J=4\)), SC-PCC (\(m_{sc}=1, w=4, I_V=4, I_H=2\)) exhibits a \(1\,\text{dB}\) improvement at BER \(10^{-4}\), and increasing \(m_{sc}\) to \(2\) yields \(1.4\,\text{dB}\) gain.

Spatial coupling leads to threshold saturation: the iterative decoder’s waterfall region approaches the MAP threshold of the base PCC ensemble, and increases in coupling memory (\(m_{sc}\)) or decoding window (\(w\)) further advance performance at the cost of higher latency and memory demands. A window \(w\gtrsim 2(m_{sc}+1)\) is generally sufficient to exploit most coupling gains. Excessively large \(w\) can degrade LLR reliability due to edge effects, which may be mitigated by LLR scaling or optimized message-passing schedules.

## 6. Hardware and Implementation Considerations

The SC-PCC decoder enables efficient VLSI design due to several attributes:

- Linear complexity in constraint length \(\nu\), avoiding the computational intensity of BCJR-based trellis decoding.
- High natural parallelism, as \(k\) information bits are independently threshold-decoded prior to syndrome updates.
- Hardware operations are restricted to additions, comparisons, and box-plus computations, precluding the need for exponentiation or division, resulting in reduced power consumption.

## 7. Significance and Broader Impact

The SC-PCC decoder with CSOC components and APP threshold decoding achieves notable coding gains over uncoupled PCCs at equivalent complexity and latency by leveraging spatial coupling. The resulting threshold saturation phenomenon demonstrates that performance can approach theoretical MAP limits using practical, scalable decoding rules. This framework highlights the utility of spatial coupling in enhancing the performance of turbo-like constructions while maintaining architectural efficiency [2109.01955].

Source: https://www.emergentmind.com/topics/pccc-decoder