The pipeline structures used for instruction
pipelining may be applied in some cases to other processing tasks.
If pipelining is to be useful, however, we must be faced with
the need to perform a long sequence of essentially similar tasks.
Large numerical applications often make use of repeated arithmetic
operations for processing the elements of vectors and arrays.
Architectures specialized for applications if this type often
provide pipelines to speed processing of floating-point arithmetic
sequences. This type of pipelining is called **arithmetic pipelining.**

Arithmetic pipelines differ from instruction
pipelines in some important ways. They are generally **synchronous.**
This means that each stage executes in a fixed number of clock
cycles. In a synchronous pipeline, moreover, no buffering between
stages is provided. Each stage must be ready to accept the data
passed from a previous stage when that data is produced.

Another important difference is that an
arithmetic pipeline may be **nonlinear**. The "stages"
in this type of pipeline are associated with key processing components
such as adders, shifters, etc. Instead of a steady progression
through a fixed sequence of stages, a task in a nonlinear pipeline
may use more than one stage at a time, or may return to the same
stage at several points in processing.

As an example of a pipelined arithmetic unit we consider a floating point adder. This pipeline accepts as input two normalized floating point numbers of the form:

Here *a* and *b* are 2's complement
fractions in the range 0.5<f<1.0.
*p* and *q* are corresponding base 2 exponents. The
normalized sum is to be computed. Four stages can be identified
for this pipeline:

- Input the original fractions and exponents. Compute the larger exponent and the exponent difference. Shift the fraction corresponding to the smaller exponent right for a number of places equal to the difference. Both fractions are now adjusted to match the same (larger) exponent. Output the exponent and the two fractions.
- Add the two fractions, producing a sum. Pass through the exponent unchanged. Output the exponent and fractions.
- Count leading zeros in the result fraction. Shift the fraction to normalize. Output the original exponent, the fraction, and the count.
- Add the exponent and count. Output the adjusted exponent and the normalized fraction.