CO UNIT 4 pptx in computer organizations

UNIT-IV
• Microprogrammed Control: Control Memory,
Address Sequencing, Micro Program example,
Design of Control Unit.
• Central Processing Unit: General Register
Organization, STACK Organization. Instruction
Formats, Addressing Modes, Data Transfer and
Manipulation, Program Control, Reduced
Instruction Set Computer

Introduction:
• The part of the computer that performs the bulk of data-processing
operations is called the central processing unit and is referred to as the
CPU.
• The CPU is made up of three major parts, as shown in Figure (1). The
register set stores intermediate data used during the execution of the
instructions.
• The arithmetic logic unit (ALU) performs the required microoperations for
executing the instructions.
• The control unit supervises the transfer of information among the registers
and instructs the ALU as to which operation to perform

• One boundary where the computer designer and the
computer programmer see the same machine is the part of
the CPU associated with the instruction set.
• From the designer's point of view, the computer
instruction set provides the specifications for the design of
the CPU.
• The design of a CPU is a task that in large part involves
choosing the hardware for implementing the machine
instructions.
• The user who programs the computer in machine or
assembly language must be aware of the register set, the
memory structure, the type of data supported by the
instructions, and the function that each instruction
performs.
• The following sections describe the organization and
architecture of the CPU with an emphasis on the user's
view of the computer, how the registers communicate with
the ALU through buses, explain the operation of the
memory stack, the type of instruction formats available, the
addressing modes used to retrieve data from memory, and
also the concept of reduced instruction set computer
(RISC).

General Register Organization:
• We know that the memory locations are needed for storing pointers, counters,
return addresses, temporary results, and partial products during multiplication.
Having to refer to memory locations for such applications is time consuming
because memory access is the most time-consuming operation in a computer.
• It is more convenient and more efficient to store these intermediate values in
processor registers. When a large number of registers are included in the CPU, it is
most efficient to connect them through a common bus system.
• The registers communicate with each other not only for direct data transfers, but
also while performing various micro-operations. Hence it is necessary to provide a
common unit that can perform all the arithmetic, logic, and shift micro-operations
in the processor.

• The output of each register is connected to two multiplexers (MUX) to
form the two buses A and B.
• The selection lines in each multiplexer select one register or the input data
for the particular bus.
• The A and B buses form the inputs to a common arithmetic logic unit
(ALU). The operation selected in the ALU determines the arithmetic or
logic micro-operation that is to be performed.
• The result of the micro-operation is available for output data and also goes
into the inputs of all the registers.
• The register that receives the information from the output bus is selected
by a decoder.
• The decoder activates one of the register load inputs, thus providing a
transfer path between the data in the output bus and the inputs of the
selected destination register.

• The control unit that operates the CPU bus system directs the information
flow through the registers and ALU by selecting the various components in
the system. For example, to perform the operation
R 1 R2 + R3
• the control must provide binary selection variables to the following
selector inputs:
1. MUX A selector (SELA): to place the content of R2 into bus A.
2. MUX B selector (SELB): to place the content of R 3 into bus B.
3. ALU operation selector (OPR): to provide the arithmetic addition A + B.
4. Decoder destination selector (SELD): to transfer the content o f the output
bus into R1.

• Control word
• There are 14 binary selection inputs in the unit, and their combined value
specifies a control word.
• The 14-bit control word is defined in Figure (3). It consists of four fields.
Three fields contain three bits each, and one field has five bits.
• The three bits of SELA select a source register for the A input of the ALU.
The three bits of SELB select a register for the B input of the ALU. The
three bits of SELD select a destination register using the decoder and its
seven load outputs.
• The five bits of OPR select one of the operations in the ALU. The 14-bit
control word when applied to the selection inputs specify a particular
micro-operation

•The encoding of the register selections is specified in the Table (a).
•The 3-bit binary code listed in the first column of the table specifies the binary
code for each of the three fields.
•The register selected by fields SELA, SELB, and SELD is the one whose
decimal number is equivalent to the binary number in the code.
•When SELA or SELB is 000, the corresponding multiplexer selects the
external input data. When SELD = 000, no destination register is selected but
the contents of the output bus are available in the external output.

• The ALU provides arithmetic and logic operations. The encoding of the
ALU Operations are specified in the Table (b). The OPR field has five bits
and each operation is designated with a symbolic name.

STACK Organization:
• A useful feature that is included in the CPU of most computers is a stack or
last-in, first-out (LIFO) list. A stack is a storage device that stores
information in such a manner that the item stored last is the first item
retrieved.
• The operation of a stack can be compared to a stack of trays. The last tray
placed on top of the stack is the first to be taken off.
• The register that holds the address for the stack is called a stack pointer
(SP) because its value always points at the top item in the stack.
• The two operations of a stack are the insertion and deletion of items.
1. Push or push-down (insertion operation)
2. Pop or pop-up (deletion operation)

Register Stack
•A stack can be placed in a
portion of a large memory or it
can be organized as a collection
of a finite number of memory
words or registers.
•Figure shows the organization of
a 64-word register stack.
•The stack pointer register SP
contains a binary number whose
value is equal to the address of
the word that is currently on top
of the stack.
•In a 64-word stack, the stack
pointer contains 6 bits because 2
6 = 64.

• Since SP has only six bits, it cannot exceed a number greater than 63
(111111 in binary).
• When 63 is incremented by 1, the result is 0 since 111111 + 1 = 1000000 in
binary, but SP can accommodate only the six least significant bits.
• Similarly, when 000000 is decremented by 1, the result is 111111. The one-
bit register FULL is set to 1 when the stack is full, and the one-bit register
EMPTY is set to 1 when the stack is empty of items. DR is the data register
that holds the binary data to be written into or read out of the stack.
Push:
• Initially, SP is cleared to 0, EMPTY is set to 1, and FULL is cleared to 0,
so that SP points to the word at address 0 and the stack is marked empty
and not full. If the stack is not full (if FULL = 0), a new item is inserted
with a push operation. The push operation is implemented with the
following sequence of micro-operations;

POP:
• A new item is deleted from the stack if the stack is not empty (if EMPTY =
0). The pop operation consists of the following sequence of micro-
operations:

Memory Stack
•A stack can exist as a stand-
alone unit as in Figure (3) or
can be implemented in a
random-access memory
attached to a CPU.
•The implementation of a stack
in the CPU is done by
assigning a portion of memory
to a stack operation and using a
processor register as a stack
pointer.
• Figure shows a portion of
computer memory partitioned
into three segments: program,
data, and stack

Reverse Polish Notation
• A stack organization is very effective for evaluating arithmetic expressions.
The common mathematical method of writing arithmetic expressions
imposes difficulties when evaluated by a computer.
• The Polish mathematician Lukasiewicz showed that arithmetic expressions
can be represented in prefix notation .
• This representation, often referred to as Polish notation, places the operator
before the operands. The postfix notation, referred to as reverse Polish
notation (RPN), places the operator after the operands. The following
examples demonstrate the three representations:

Conversion to Reverse Polish Notation
• The conversion from infix notation to reverse Polish notation must take
into consideration the operational hierarchy adopted for infix notation.
• This hierarchy dictates that we first perform all arithmetic inside
inner parentheses, then inside outer parentheses, and do multiplication
and division operations before addition and subtraction operations.
• Let I be an algebraic expression written in infix notation. I may contain
parentheses, operands, and operators. For simplicity of the algorithm we
will use only +, –, *, /, % operators.
• The precedence of these operators can be given as follows:
• Higher priority *, /, %
• Lower priority +, –
• the order of evaluation of these operators can be changed by making use of
parentheses.

• For example, if we have an expression A + B * C, then first B * C will be done and the
result will be added to A. But the same expression if written as, (A + B) * C, will
evaluate A + B first and then the result will be multiplied with C.
Consider the expression (A + B) * (C * (D + E) + F)
The converted expression is AB + CDE + * F + *
• Step 1: Add “)” to the end of the infix expression
• Step 2: Push “(” on to the stack
• Step 3: Repeat until each character in the infix notation is scanned
• IF a “(” is encountered, push it onto the stack
• IF an operand (whether a digit or a character) is encountered, add it to the postfix
expression.
• IF a “)” is encountered, then
a. Repeatedly pop from stack and add it to the postfix expression until a “(” is
encountered.
b. Discard the “(”. That is, remove the (from stack and do not add it to the postfix
expression
• IF an operator ‘O’ is encountered, then
a. Repeatedly pop from stack and add each operator (popped from the stack) to the
postfix expression which has the same precedence or a higher precedence than ‘O’
b. Push the operator ‘O’ to the stack Step 4: Repeatedly pop from the stack and add it to
the postfix expression until the stack is empty

Example 1:
A*B+C*D, first add “)” to the given expression i.e., A*B+C*D) and
also push “(” onto the stack

Example 2:
(A + B) * (C * (D + E) + F)
First add “)” to the given expression i.e., (A + B) * (C * (D + E) + F)) and also push “(” onto the stack.

Evaluation of Arithmetic Expressions
1. Push the operands into the stack until an operator is reached
2. Pop the top two operands from the stack, compute the result and also push
the result back into the stack.
3. Continue this process until there are no more operators in the RPN and
the final result is in the stack.
• The following numerical example may clarify this procedure.
• Consider the arithmetic expression (3 * 4) + (5 * 6)
• In reverse Polish notation, it is expressed as 34 * 56 * +

Instruction Formats
• A computer will usually have a variety of instruction code formats. It is the
function of the control unit within the CPU to interpret each instruction code and
provide the necessary control functions needed to process the instruction.
• The bits of the instruction are divided into groups called fields. The most common
fields found in instruction formats are:
1. An operation code field that specifies the operation to be performed.
2. An address field that designates a memory address or a processor register.
3. A mode field that specifies the way the operand or the effective address is
determined.
• Other special fields are sometimes employed under certain circumstances, as for
example a field that gives the number of shifts in a shift-type instruction.
• The operation code field of an instruction is a group of bits that define various
processor operations, such as add, subtract, complement, and shift.
• The bits that define the mode field of an instruction code specify a variety of
alternatives for choosing the operands from the given address.
• In this section we are concerned with the address field of an instruction format
and consider the effect of including multiple address fields in an instruction

• Operations specified by computer instructions are executed on some data stored
in memory or processor registers.
• Operands residing in memory are specified by their memory address. Operands
residing in processor registers are specified with a register address.
• A register address is a binary number of k bits that defines one of 2k registers
in the CPU.
• Computers may have instructions of several different lengths containing
varying number of addresses.
• The number of address fields in the instruction format of a computer depends
on the internal organization of its registers.
• Most computers fall into one of three types of CPU organizations:
1. Single accumulator organization.
2. General register organization.
3. Stack organization.

An accumulator-type organization:
• All operations are performed with an implied accumulator register. The
instruction format in this type of computer uses one address field.
• For example, the instruction that specifies an arithmetic addition is defined by
an assembly language instruction as:
ADD X
• where X is the address of the operand.
• The ADD instruction in this case results in the operation
AC AC + M[X].
• AC is the accumulator register and M [X] symbolizes the memory word
located at address X

A general register type of organization:
• The instruction format in this type of computer needs three register address fields.
• Thus the instruction for an arithmetic addition may be written in an assembly language as
ADD R1 , R2 , R3
• to denote the operation R1 R2 + R 3 . The number of address fields in the instruction
can be reduced from three to two if the destination register is the same as one of the source
registers. Thus the instruction
ADD R1 , R2
• would denote the operation R1 R1 + R2. Only register addresses for R1 and R2 need
be specified in this instruction.
• General register-type computers employ two or three address fields in their instruction
format.
• Each address field may specify a processor register or a memory word. An instruction
symbolized by
ADD R1 , X
• would specify the operation R1 R1 + M[X]. It has two address fields, one for register
R1 and the other for the memory address X.

A stack organization:
• Computers with stack organization would have PUSH and POP instructions which
require an address field. Thus the instruction
PUSH X
• will push the word at address X to the top of the stack.
• The stack pointer is updated automatically. Operation-type instructions do not need
an address field in stack-organized computers.
• This is because the operation is performed on the two items that are on top of the
stack. The instruction
ADD
• in a stack computer consists of an operation code only with no address field.
• This operation has the effect of popping the two top numbers from the stack,
adding the numbers, and pushing the sum into the stack.
• There is no need to specify operands with an address field since all operands are
implied to be in the stack.

• To illustrate the influence of the number of addresses on computer programs, we
will evaluate the arithmetic statement
X = (A + B) • (C + D)
• using zero, one, two, or three address instructions. We will use the symbols ADD,
SUB, MUL, and DIV for the four arithmetic operations;
• MOV for the transfer-type operation;
• and LOAD and STORE for transfers to and from memory and AC register.
• We will assume that the operands are in memory addresses A, B, C, and D, and the
result must be stored in memory at address X.

Addressing Modes
• The operation field of an instruction specifies the operation to be performed.
• This operation must be executed on some data stored in computer registers or
memory words.
• The way the operands are chosen during program execution is dependent on the
addressing mode of the instruction.
• The addressing mode specifies a rule for interpreting or modifying the address
field of the instruction before the operand is actually referenced.
• In simple terms, Addressing mode is the way in which the location of an operand
can be specified in an instruction.
• It generates an effective address (the actual address of the operand). Instruction
format with mode field

• Types of Addressing Modes:
1. Implied Mode
2. Immediate Mode
3. Register Mode
4. Register Indirect Mode
5. Autoincrement or Autodecrement Mode
6. Direct Address Mode
7. Indirect Address Mode
8. Relative Address Mode
9. Indexed Addressing Mode
10. Base Register Addressing Mode
• There are two modes that need no address field at all. These are the implied and
immediate modes.

1. Implied Mode:
• In this mode the operands are specified implicitly in the definition of the
instruction.
• For example, the instruction ”complement accumulator (CMA)” is an implied-
mode instruction because the operand in the accumulator register is implied in the
definition of the instruction.
• In fact, all register reference instructions that use an accumulator are implied-mode
instructions.
• Zero-address instructions in a stack-organized computer are implied-mode
instructions since the operands are implied to be on top of the stack.

Data Transfer and Manipulation:
• Computers provide an extensive set of instructions to give the user the flexibility to carry
out various computational tasks.
• The instruction set of different computers differ from each other mostly in the way the
operands are determined from the address and mode fields.
• Most computer instructions can be classified into three categories:
1. Data transfer instructions
2. Data manipulation instructions
3. Program control instructions
• Data transfer instructions cause transfer of data from one location to another without
changing the binary information content.
• Data manipulation instructions are those that perform arithmetic, logic, and shift
operations.
• Program control instructions provide decision-making capabilities and change the path
taken by the program when executed in the computer.
• The instruction set of a particular computer determines the register transfer operations and
control decisions that are available to the user

1. Data transfer instructions
• Data transfer instructions move data from one place in the computer to another without
changing the data content.
• The most common transfers are between memory and processor registers, between
processor registers and input or output, and between the processor registers themselves.
• a list of eight data transfer instructions used in many computers

•The load instruction has been used mostly to
designate a transfer from memory to a processor
register, usually an accumulator.
•The store instruction designates a transfer from a
processor register into memory.
•The move instruction has been used in computers
with multiple CPU registers to designate a transfer
from one register to another. It has also been used for
data transfers between CPU registers and memory or
between two memory words.
• The exchange instruction swaps information
between two registers or a register and a memory
word.
• The input and output instructions transfer data
among processor registers and input or output
terminals.
•The push and pop instructions transfer data
between processor registers and a memory stack.

2. Data Manipulation Instructions
• Data manipulation instructions perform operations on data and provide the
computational capabilities for the computer.
• The data manipulation instructions in a typical computer are usually divided into three
basic types:
i. Arithmetic instructions
ii. Logical and bit manipulation instructions
iii. Shift instructions

i. Arithmetic instructions
• A special carry flip-flop is used to store the
carry from an operation. The instruction
"add with carry" performs the addition on
two operands plus the value of the carry from
the previous computation.
• Similarly, the "subtract with borrow"
instruction subtracts two words and a borrow
which may have resulted from a previous
subtract operation.
• The negate instruction forms the 2' s
complement of a number.

ii. Logical and Bit Manipulation Instructions
• Logical instructions perform binary
operations on strings of bits stored in
registers.
• They are useful for manipulating individual
bits or a group of bits that represent binary-
coded information.
• The logical instructions consider each bit of
the operand separately and treat it as a
Boolean variable.

iii. Shift Instructions
• Instructions to shift the content of an operand
are quite useful and are often provided in
several variations.
• Shifts are operations in which the bits of a
word are moved to the left or right.
• The bit shifted in at the end of the word
determines the type of shift used. Shift
instructions may specify logical shifts,
arithmetic shifts, or rotate-type operations. In
either case the shift may be to the right or to
the left.

Program Control
• After the execution of a data transfer or data manipulation instruction, control returns to
the fetch cycle with the program counter containing the address of the instruction next in
sequence.
• On the other hand, a program control type of instruction, when executed, may change
the address value in the program counter and cause the flow of control to be altered. In
other words, program control instructions specify conditions for altering the content of
the program counter, while data transfer and manipulation instructions specify
conditions for data-processing operations.
• The change in value of the program counter as a result of the execution of a program
control instruction causes a break in the sequence of instruction execution. This is an
important feature in digital computers, as it provides control over the flow of program
execution and a capability for branching to different program segments.

• Status Bit Conditions:
• It is sometimes convenient to supplement the ALU circuit in the CPU with a status
register where status bit conditions can be stored for further analysis.
• Status bits are also called condition-code bits or flag bits. Figure (6) shows the block
diagram of an 8-bit ALU with a 4-bit status register.
• The four status bits are symbolized by C. S, Z, and V. The bits are set or cleared as a
result of an operation performed in the ALU.
1. Bit C (carry) is set to 1 if the end carry C8 is 1. It is cleared to 0 if the carry is 0.
2. Bit S (sign) is set to 1 if the highest-order bit F7 is 1. It is set to 0 if the bit is 0.
3. Bit Z (zero) is set to 1 if the output of the ALU contains all 0's. It is cleared to 0
otherwise. In other words, Z = 1 if the output is zero and Z = 0 if the output is not zero.
4. Bit V (overflow) is set to 1 if the exclusive-OR of the last two carries is equal to 1, and
cleared to 0 otherwise. This is the condition for an overflow when negative numbers are
in 2's complement. For the 8-bit ALU, V = 1 if the output is greater than + 127 or less
than – 128.

Conditional Branch Instructions:
• To change the flow of execution in the program we use some kind of branching
instructions which are depending on the some conditions result.
• Each mnemonic is constructed with the letter B (for branch) and an abbreviation of the
condition name.
• When the opposite condition state is used, the letter N (for no) is inserted to define the 0
state. Thus BC is Branch on Carry, and BNC is Branch on No Carry.
• If the stated condition is true, program control is transferred to the address specified by
the instruction. If not, control continues with the instruction that follows.
• The conditional instructions can be associated also with the jump, skip, call, or return
type of program control instructions.

CO UNIT 4 pptx in computer organizations

More Related Content

Similar to CO UNIT 4 pptx in computer organizations (20)

Recently uploaded (20)

CO UNIT 4 pptx in computer organizations