his problem explores pipeline design. Pipelining involves balancing the pipe stages. A perfectly balanced pipeline is one where every stage in the pipeline takes exactly the same amount of time to complete. However, in practice perfectly balanced pipelines are rarely possible. (i) Hence, good pipeline implementations create simple and near-balanced designs where each pipeline stage takes roughly the same amount of time. (ii) The second important aspect of pipeline design is that each pipeline stage generates results that are used by the following pipeline stages. Keep these two points (i) and (ii) in mind while you answer this question. This figure displays a non-pipelined implementation of a simple microprocessor that executes only ALU instructions. The simple microprocessor has to perform several tasks. First, it computes the address of the next instruction to fetch by incrementing the PC. Second, it uses the PC to access the I-cache. Then the instruction is decoded. The instruction decoder itself is divided into smaller tasks. First, it has to decode the instruction type. Once the opcode is decoded, it has to decode what functional units are needed for executing the instruction. Concurrently, it also decodes what source registers or immediate operands are used by the instruction and which destination register is written to. Once the decode process is complete the register file is accessed (the immediate data are accessed from the instruction itself) to get the source data. Then the appropriate ALU function (as specified by the function decoder) is activated to compute the results, which are then written back to the destination register. Note that the decoding mechanism in this microprocessor is different from the MIPS decoder we have discussed. In the MIPS decoder, decode was treated as a single operation, i.e., the decoder does not need to know the opcode before it can decode the source registers. In this simple microprocessor, however, the decoder has to know the opcode before it can decode the source and destination operands. Furthermore, the task of decoding the source and destination operands is actually subdivided into multiple smaller tasks. Question: Generate a 5-stage (IF, ID1, ID2, EX, WB) pipelined implementation of the simple processor outlined above that balances each pipeline stage, ignoring all data hazards. Each sub-block in the diagram above is a primitive unit that cannot be further partitioned into smaller ones. The original functionality must be maintained in the pipelined implementation. In other words, there should be no difference to a programmer writing code whether this machine is pipelined or otherwise. Show the diagram of your pipelined implementation. You can draw pipeline stage registers first and then put blocks into different stages to make sure functionality and balance stage delays. You don’t need to draw a complete diagram showing all connections, and making some key connections to show the instruction flow is good enough.
This problem explores pipeline design. Pipelining involves balancing the pipe
stages. A perfectly balanced pipeline is one where every stage in the pipeline takes
exactly the same amount of time to complete. However, in practice perfectly balanced
pipelines are rarely possible. (i) Hence, good pipeline implementations create simple
and near-balanced designs where each pipeline stage takes roughly the same amount
of time. (ii) The second important aspect of pipeline design is that each pipeline stage
generates results that are used by the following pipeline stages. Keep these two points
(i) and (ii) in mind while you answer this question.
This figure displays a non-pipelined implementation of a simple microprocessor
that executes only ALU instructions. The simple microprocessor has to perform
several tasks. First, it computes the address of the next instruction to fetch by
incrementing the PC. Second, it uses the PC to access the I-cache. Then the
instruction is decoded. The instruction decoder itself is divided into smaller tasks.
First, it has to decode the instruction type. Once the opcode is decoded, it has to
decode what functional units are needed for executing the instruction. Concurrently, it
also decodes what source registers or immediate operands are used by the instruction
and which destination register is written to. Once the decode process is complete the
register file is accessed (the immediate data are accessed from the instruction itself) to
get the source data. Then the appropriate ALU function (as specified by the function
decoder) is activated to compute the results, which are then written back to the
destination register.
Note that the decoding
MIPS decoder we have discussed. In the MIPS decoder, decode was treated as a
single operation, i.e., the decoder does not need to know the opcode before it can
decode the source registers. In this simple microprocessor, however, the decoder has
to know the opcode before it can decode the source and destination operands.
Furthermore, the task of decoding the source and destination operands is actually
subdivided into multiple smaller tasks.
Question: Generate a 5-stage (IF, ID1, ID2, EX, WB) pipelined implementation of
the simple processor outlined above that balances each pipeline stage, ignoring
all data hazards. Each sub-block in the diagram above is a primitive unit that
cannot be further partitioned into smaller ones. The original functionality must
be maintained in the pipelined implementation. In other words, there should be
no difference to a programmer writing code whether this machine is pipelined
or otherwise. Show the diagram of your pipelined implementation. You can
draw pipeline stage registers first and then put blocks into different stages to
make sure functionality and balance stage delays. You don’t need to draw a
complete diagram showing all connections, and making some key connections
to show the instruction flow is good enough.
Step by step
Solved in 3 steps
