WOLAITA SODO UNIVERSITY

DEPARTMENT: COMPUTER SCIENCE

COURSE: COA

SECTION: ONE(1)

GROUP: 6th

NAME ID number
1. Gemechis Gurmessa ………………………..………….. Ugr/69416/14

2.Kalkidan Aley………………………..………….. Ugr/69416/14

3.Amanuel………………………..………….. Ugr/69416/14

4.Khalid………………………..………….. Ugr/69416/14

5.Bereket Befa………………………..………….. Ugr/69416/14

Instructor Name: Arba Asha

Submission date 03/ 04/2016 EC

1
Q6. Arithmetic Pipeline and Instruction Pipeline

Introduction
In the world of computer architecture, improving performance and efficiency is a
constant pursuit. Two techniques that have revolutionized the field are Arithmetic
Pipelining and Instruction Pipelining. These pipeline concepts allow for the
parallel execution of multiple instructions, significantly enhancing the speed and
efficiency of processors. In this article, we will delve into the details of Arithmetic
Pipelines and Instruction Pipelines, exploring how they work and the benefits they
bring to computer systems.In this discourse, we delve into the intricacies of two
pivotal pipeline types that have played a pivotal role in shaping modern
computing landscapes: Arithmetic Pipelines and Instruction Pipelin

What is an Arithmetic Pipeline?

Arithmetic Pipeline, also known as the ALU (Arithmetic Logic Unit) Pipeline, is a
technique used in computer architecture to enhance the execution of arithmetic
operations. It leverages parallelism by breaking down arithmetic calculations into
multiple stages or sub-operations, allowing for simultaneous processing of
multiple instructions. This technique significantly improves the speed and
efficiency of processors.

2
3
The concept of an Arithmetic Pipeline revolves around the principle of
overlapping the execution of different arithmetic instructions. Instead of waiting
for each instruction to complete all stages before starting the next one, an
Arithmetic Pipeline enables the processor to initiate the execution of a new
instruction while the previous one is still progressing through the pipeline stages.

The pipeline stages involved in an Arithmetic Pipeline typically include:

Fetch: In this stage, instructions are fetched from memory or cache and loaded
into the pipeline.

Decode: The fetched instructions are decoded to determine the type of arithmetic
operation to be performed and the operands involved.

Execute: This stage performs the actual arithmetic calculation or operation on the
operands. It involves operations such as addition, subtraction, multiplication, or
division.

Writeback: The result of the arithmetic operation is written back to the

appropriate destination.

The beauty of an Arithmetic Pipeline lies in its ability to maximize the utilization of
computational resources. While one instruction is progressing through the
pipeline stages, the subsequent instructions can start their execution in parallel.
This overlapping of instructions allows the processor to perform multiple
arithmetic calculations simultaneously, resulting in improved performance and
throughput.

By breaking down arithmetic operations into smaller stages and executing them
concurrently, Arithmetic Pipelines offer several advantages:

Advantages of Arithmetic Pipeline

4
Increased Throughput: The ability to process multiple instructions simultaneously
enhances the overall throughput of the system, as more instructions can be
executed within a given time frame.

Reduced Latency: The overlapping nature of the pipeline stages reduces the time
taken for an instruction to complete, resulting in lower latency and improved
responsiveness.

Resource Optimization: Pipelining allows for efficient utilization of computational

resources. The processor remains busy most of the time as idle stages are filled
with new instructions, maximizing the utilization of hardware resources.

Improved Efficiency: With the execution of multiple arithmetic instructions in

parallel, the Arithmetic Pipeline improves the overall efficiency of the processor,
enabling it to handle a higher number of instructions per unit of time.

However, it’s worth noting that achieving optimal performance in an Arithmetic

Pipeline can be challenging due to potential dependencies between instructions,
such as data dependencies or control dependencies. Proper handling of these
dependencies and maintaining the correctness of results is crucial to ensuring the
accuracy of arithmetic operations.

What is an Instruction Pipeline?

An Instruction Pipeline, also known as an Instruction Execution Pipeline, is a

technique used in computer architecture to enhance the performance and
efficiency of processors. It enables the simultaneous execution of multiple
instructions by breaking down the instruction execution process into smaller
stages or sub-operations and processing them in parallel.

The primary goal of an Instruction Pipeline is to maximize the utilization of

hardware resources and improve the throughput of instructions. It achieves this
by overlapping the execution of different stages of instruction processing,
allowing for the initiation of a new instruction before the previous one completes
all stages

5
The flowchart for the instruction pipeline is shown below.

The typical stages involved in an Instruction Pipeline are as follows:

Instruction Fetch: The first stage involves fetching instructions

from memory or cache. The instruction pointer is used to determine the next
instruction to fetch.

6
Instruction Decode: In this stage, the fetched instruction is decoded to determine
the operation to be performed and the operands involved. The instruction format
is analyzed to extract the necessary information for subsequent stages.

Execution: The instruction is executed in this stage, which may involve performing
arithmetic or logical operations, accessing memory, or controlling program flow.

Memory Access: If the instruction requires accessing memory, this stage is

responsible for fetching data from memory or writing data back to memory.

Writeback: The result of the instruction execution is written back to the

appropriate destination, such as a register or memory location.

The key idea behind an Instruction Pipeline is to divide the instruction execution
process into smaller stages and allow different instructions to progress through
these stages simultaneously. This parallel processing enables the processor to
handle multiple instructions concurrently, resulting in improved performance and
efficiency.

Working Principles and Types

Diving deeper into the intricacies of Arithmetic Pipelines, their working principles
hinge on the segmentation of arithmetic operations. Imagine a complex
mathematical task; an arithmetic pipeline dissects it into sequential stages, such
as operand fetch, operation, and result storage. Each stage operates on a portion
of the task concurrently, promoting efficiency and reducing the overall processing
time. The fundamental goal is to maximize throughput by allowing multiple
operations to be in progress simultaneously.

Instruction Pipelines, by contrast, are orchestrated around the fetch-decode-

execute cycle. During the fetch stage, instructions are retrieved from memory; in
the decode stage, their opcode and operands are deciphered; execution ensues in
the next stage, and the final write-back stage concludes the process. It's a
symphony of stages, and the brilliance lies in the simultaneous execution of

7
different instructions at various stages. Superscalar pipelines further elevate this
concept by executing multiple instructions in each stage concurrently, making the
pipeline even more efficient.

The realm of types within these pipelines adds another layer of complexity. For
Arithmetic Pipelines, specialization might occur, with different pipelines dedicated
to distinct arithmetic operations like addition, multiplication, or division.
Instruction Pipelines may also feature multiple issue pipelines, capable of
handling a variety of instructions concurrently, widening the scope for parallel
execution.

Benefits of Instruction Pipelining:

Increased Throughput: By processing multiple instructions simultaneously, the
Instruction Pipeline improves the overall throughput of the system. It allows for
the execution of more instructions within a given time frame.

Reduced Latency: The overlapping nature of the pipeline stages reduces the time
taken for an instruction to complete. This results in lower latency and faster
execution of instructions.

Resource Utilization: Instruction Pipelining optimizes the utilization of

computational resources. It keeps the processor busy by allowing instructions to
progress through the pipeline stages in parallel, maximizing the efficiency of
hardware resources.

Improved Performance: The parallel execution of instructions leads to improved

performance. It enables the processor to handle a higher number of instructions
per unit of time, enhancing the overall computational speed.

However, this efficiency doesn't come without disadvantages. The very

complexity that makes pipelines powerful can also introduce challenges. The
design becomes intricate, and pipeline hazards may emerge. Data hazards occur

8
when one stage depends on the results of another still in progress, while control
hazards involve decisions based on incomplete information. These challenges
necessitate sophisticated solutions, contributing to the intricacy of pipeline
design.

Conclusion
Arithmetic Pipelines and Instruction Pipelines are powerful techniques in
computer architecture that have revolutionized the performance and efficiency of
processors. By breaking down arithmetic operations and instruction execution
into smaller stages and processing them in parallel, these pipeline concepts
enable the simultaneous execution of multiple instructions, significantly
enhancing the speed and throughput of computer system

9
Reference
https://www.prepbytes.com/blog/computer-architecture/arithmetic-pipeline-
and-instruction-pipeline/

https://www.geeksforgeeks.org/arithmetic-pipeline-and-instruction-pipeline

10