# Pipelining (DSP implementation)

Pipelining is an important technique used in several applications such as digital signal processing (DSP) systems, microprocessors, etc. It originates from the idea of a water pipe with continuous water sent in without waiting for the water in the pipe to come out. Accordingly, it results in speed enhancement for the critical path in most DSP systems. For example, it can either increase the clock speed or reduce the power consumption at the same speed in a DSP system.

## Concept

Pipelining allows different functional units of a system to run concurrently. Consider an informal example in the following figure. A system includes three sub-function units (F$_0$, F$_1$ and F$_2$). Assume that there are three independent tasks (T$_0$, T$_1$ and T$_2$) being performed by these three function units. The time for each function unit to complete a task is the same and will occupy a slot in the schedule.
If we put these three units and tasks in a sequential order, the required time to complete them is five slots.
However, if we pipeline T$_0$ to T$_2$ concurrently, the aggregate time is reduced to three slots.
Therefore, it is possible for an adequate pipelined design to achieve significant enhancement on speed.

## Costs and disadvantages

Pipelining cannot decrease the processing time required for a single task. The advantage of pipelining is that it increases the throughput of the system when processing a stream of tasks.
Applying too many pipelined functions can lead to increased latency - that is, the time required for a single task to propagate through the full pipe is prolonged. A pipelined system may also require more resources (buffers, circuits, processing units, memory etc.), if the reuse of resources across different stages is restricted.

## Comparison with parallel approaches

Another technique to enhance the efficiency through concurrency is parallel processing. The core difference is that parallel techniques usually duplicate function units and distribute multiple input tasks at once amongst them. Therefore, it can complete more tasks per unit time but may suffer more expensive resource costs.
For the previous example, the parallel technique duplicates each function units into another two. Accordingly, all the tasks can be operated upon by the duplicated function units with the same function simultaneously. The time to complete these three tasks is reduced to three slots.

## Pipelining in FIR filters

Consider a 3-tap FIR filter:
    $y(n)=ax(n)+bx(n-1)+cx(n-2)$
which is as shown in the following figure.
Assume the calculation time for multiplication units is T$_m$ and T$_a$ for add units. The critical path, representing the minimum time required for processing a new sample, is limited by 1 multiplication and 2 add function units. Therefore, the sample period is given by
    $T_{\text{sample}}\geq T_{m}+2T_{a}$
However, such structure may not be suitable for the design with the requirement of high speed. To reduce the sampling period, we can introduce extra pipelining registers along the critical data path. Then the structure is partitioned into two stages and the data produced in the first stage will be stored in the introduced registers, delaying one clock to the second stage. The data in first three clocks is recorded in the following table. Under such pipelined structure, the sample period is reduced to
    $T_{\text{sample}}\geq T_{m}+T_{a}.$

## Pipelining in 1st-order IIR filters

By combining look-ahead techniques and pipelining, we are able to enhance the sample rate of target design. Look-ahead pipelining will add canceling poles and zeroes to the transfer function such that the coefficients of the following terms in the denominator of the transfer function are zero.
    $\{z^{-1},\ldots ,z^{-(M-1)}\}$
Then, the output sample y(n) can be computed in terms of the inputs and the output sample y(n − M) such that there are M delay elements in the critical loop. These elements are then used to pipeline the critical loop by M stages so that the sample rate can be increased by a factor M.
Consider the 1st-order IIR filter transfer function
    $H(z)={\frac {1}{1-az^{-1}}}$
The output y(n) can be computed in terms of the input u(n) and the previous output.
    $y(n)=ay(n-1)+u(n)$
In a straightforward structure to design such function, the sample rate of this recursive filter is restricted by the calculation time of one multiply-add operation.
To pipeline such design, we observe that H has a pole at
    $z=a,a\leq 1$
Therefore, in a 3-stage pipelined equivalent stable filter, the transfer function can be derived by adding poles and zeros at
    $z=ae^{\pm ({\frac {2j\pi }{3}})}$
and is given by
    $H(z)={\frac {1+az^{-1}+a^{2}z^{-2}}{1-a^{3}z^{-3}}}$
Therefore, the corresponding sample rate can be increased by a factor 3.

## Other examples of pipelined DSP systems

* Pipelined Walsh–Fourier transform
* Pipelined unitary transforms
* Pipelined DFT
* Pipelined FFT