Chapter 8 CPU OrganizationG.RajendraAssistant Professor, MCA Department, LBRCE

Central Processing UnitThe part of the computer performs the bulk of data processing operations is called the central processing unit

The CPU is made up of three major parts:Register setALUControl units

CPUThe central processing unit (CPU) of a computer is the main unit that dictates the rest of the computer organization

1. Register set: Stores intermediate data during the execution of instructions;2. Arithmetic logic unit (ALU): Performs the required micro-operations for executing the instructions;3. Control unit: supervises the transfer of information among the registers and instructs the ALU as to which operation to perform by generating control signals.

ControlUnitRegistersArithmeticLogic Unit

Central Processing Unit = brainExecutes programs by:Fetching and decoding the next instruction from memoryExecute itConsists of:Control UnitArithmetic Logic Unit (ALU)Registers (high-speed memory)Program Counter (PC)Instruction Register (IR)DiskPrinterMainMemoryControlUnitRegistersArithmeticLogic UnitBusI/O Devices

8-2. General Register OrganizationCPU must have some working space (fast access and close to CPU)

This space is efficiently used to store intermediate values

The most convenient way to communicate registers is trough common bus system

Register Transfer LanguageRegister: A register consists of a group of flip flops with a clock input. Registers are commonly used to store and shift binary data. Register Transfer Language:The symbolic notation used to describe the micro operation transfers among registers is called a register transfer language.The operations executed on data stored in registers are called microoperations.

A Micro operation is an elementary operation performed on the information stored in one or more registers.

Register Transfer LanguageThe internal hardware organization of a digital computer is best defined by specifying The set of registers it contains and their functionThe sequence of micro operations performed on the binary information stored in the registers.The control that initiates the sequence of micro operations.Register Transfer:Computer registers are designated by capital letters ( sometimes followed by numerals) to denote the function of the register.

For example: The register that holds an address for the memory unit is called memory address register and is designated by the name MAR.Other designations for registers are PC (for Program Counter) IR ( for Instruction Register) R1 ( for processor register)The individual flip-flops in an n-bit register are numbered in sequence from 0 to n-1, starting from 0 in the right most position and increasing the numbers towards the leftRegister Transfer Language

Register Transfer LanguageBlock Diagram of Register:

(a) Register R(b). Showing individual bits

R1PC(H) PC(L)

R27 6 5 4 3 2 1150 ( C) Numbering of bits (d) Divided into two parts

Register Transfer LanguageThe most common way to represent a register is by a rectangular box with the name of the register inside.The symbol PC(0-7) or PC(L) or Lower Order Byte, PC(8-15) or PC(H) or Higher Order ByteThe information transfer from one register to another is designated by symbolic form by means of replacement operator. The statement R2 R1The statement denotes a transfer of the contents of register R1 into register R2. It designates a replacement of the content of R2 by the content of R1.By definition, the content of the source register R1 does not change after the transfer.

Register Transfer LanguageOften we want the transfer to occur only under a predetermined control condition, IF(P=1) then (R2 R1) where p is a control signal generated in the control section.The control function is a Boolean variable that is equal to 1 or 0.The control function is included in the statement as follows:P: R2 R1, control function is terminated by colon.Which means if p =1, then load the contents of register R1 into register R2.

Register Transfer LanguageHardware Implementation of controlled transferFig: Transfer from R1 to R2 when p=1Control UnitR1R2 P Loadclockn

Register Transfer LanguageFig: Basic symbols of the register transfer

Symbol DescriptionexamplesLetters( and Numerals)Denotes a RegisterMAR, R2ParenthesisDenotes a part of a registerR2(0-7), R2(L)R2(8-15), R2(H)Arrow Denotes the transfer of informationR2 R1CommaSeparates two micro operationsR2R1, R1R2

Computer RegistersComputer instructions are normally stored in consecutive memory locations and are executed sequentially one at a time.The control reads an instruction from specific address in memory and executes it. It then continues by reading the next instruction in sequence and executes it, and so on.The computer needs a processor register for manipulating data and a register for holding a memory address

Computer Registers Fig: Basic computer registers and memoryPCAROUTR INTRIRTRMemory4096 words16 bits per wordACDR0011110 15150 15150 7 7 0 0 0

Computer RegistersThe memory unit has a capacity of 4096 words and each word contains 16 bits.Data Register(DR) : hold the operand(Data) read from memoryAccumulator Register(AC) : general purpose processing registerInstruction Register(IR) : hold the instruction read from memoryTemporary Register(TR) : hold a temporary data during processingAddress Register(AR) : hold a memory address, 12 bit width

Computer RegistersProgram Counter(PC) : hold the address of the next instruction to be read from memory after the current instruction is executedInstruction words are read and executed in sequence unless a branch instruction is encounteredA branch instruction calls for a transfer to a nonconsecutive instruction in the programThe address part of a branch instruction is transferred to PC to become the address of the next instructionTo read instruction, memory read cycle is initiated, and PC is incremented by one(next instruction fetch)

Computer RegistersInput Register(INPR) : receive an 8-bit character from an input deviceOutput Register(OUTR) : hold an 8-bit character for an output device

Computer RegistersList of registers for the basic computer

Register Number RegisterRegistersymbol of bits name Function-----------------------DR 16 Data register Holds memory operandsAR12 Address register Holds address for memoryAC16 Accumulator Processor registerIR16 Instruction register Holds instruction codePC12 Program counter Holds address of instructionTR16 Temporary register Holds temporary dataINPR8 Input register Holds input characterOUTR8 Output register Holds output character

Bus and Memory TransferA typical digital computer has many registers, and paths must be provided to transfer information from one register to another.The number of lines will be excessive if separate lines are used between each register and all registers in the system.A more efficient scheme for transferring information between registers in a multiple register is a common bus system.A bus structure consists of a set of common lines one for each bit of a register, through which binary information is transferred one at a time.

Bus and Memory TransferControl signals are determine which register is selected by the bus during each particular register transfer.One way of constructing a common bus system is with multiplexersThe construction of a bus system for four registers is shown in figure.

Bus and Memory TransferS0S1Register CRegister BRegister ARegister D

Bus and Memory Transfer

Sheet1

S1 S0Register selected

0 0A

0 1B

1 0C

1 1D

Memory TransferThe transfer of information from a memory word to the outside environment is called a read operationThe transfer of new information to be stored into the memory is called a write operation.A memory word will be symbolized by letter M.Memory Read and WriteAR: address registerDR: data registerRead: DR M[AR]Write: M[AR] R1

Common Bus SystemThe basic computer has eight registers, a memory unit, and a control unit. Paths must be provided to transfer information from one register to another and between memory and registers. The number of wires will be excessive if connections are made between the outputs of each register and the inputs of other registers. A more efficient scheme for transferring information in a system with many registers is to use a common bus. The connection of the registers and memory of the basic computer to a common bus system is shown in figure.

Common Bus SystemFig: Basic computer registers connected to a common bus

Common Bus SystemThe outputs of seven registers and memory are connected to the common bus. The specific output that is selected for the bus lines at any given time is determined from the binary value of the selection variables S2, S1, and S0.The number along each output shows the decimal equivalent of the required binary selection. For example, the number along the output of DR is 3. The 16-bit outputs of DR are placed on the bus lines when S2S1S0=011 since this is the binary value of decimal 3.

Common Bus SystemThe lines from the common bus are connected to the inputs of each register and the data inputs of the memory.The memory receives the contents of the bus when its write input is activated. The memory places its 16-bit output onto the bus when the read input is activated and S2S1S0=111.Four registers DR, AC, IR, and TR, have 16 bits each.Two registers, AR and PC have 12 bits each since they hold a memory address.

Common Bus SystemThe input registers INPR and the output register OUTR have 8 bits each and communicate with the eight least significant bits in the bus. INPR is connected to provide information to the bus but OUTR can only receive information from the bus.The input data and output data of the memory are connected to the common bus, but the memory address is connected to AR. Therefore, AR must always be used to specify a memory address.The 16 inputs of AC come from an Adder and logic circuit.

Common Bus SystemThis circuit has 3 sets of inputs. One set of 16 bit inputs come from the outputs of the AC. They are used to implement register micro operations such as complement AC and shift AC. Another set of 16-bit inputs come from the data register DR. The inputs from DR and AC are used for arithmetic and logic micro operations, such as add DR to AC or AND DR to AC. The result of an addition is transferred to AC and the end carry-out of the addition is transferred to the flip flop E (extended AC bit).A third set of 8-bit inputs come from the input register INPR.

Computer InstructionsBasic Computer Instruction Format

Memory-Reference Instructions (OP-code = 000 ~ 110)

Register-Reference Instructions (OP-code = 111, I = 0)

Input-Output Instructions(OP-code =111, I = 1)IOpcodeAddress110121415

Computer InstructionsEach format has 16 bits. The operation code (opcode) part of the instruction contains three bits and the remaining 13 bits depends on the operation code encountered.A memory-reference instruction uses 12 bits to specify an address and one bit to specify the addressing mode I. I is equal to 0 for direct address and to 1 for indirect address.The register-reference instructions are recognized by the operation code 111 with a 0 in the leftmost bit (bit 15) of the instruction.

Computer InstructionsA register reference instruction specifies an operation on or a test of the AC register. An operand from memory is not needed; therefore, the other 12 bits are used to specify the operation or test to be executed.Similarly, an input-output instruction does not need a reference to memory and is recognized by the operation code 111 with a 1 in the left most bit of the instruction. The remaining 12 bits are used to specify the type of input-output operation or test performed.

Computer InstructionsThe type of instruction is recognized by the computer control from the four bits in positions 12 through 15 of the instruction. If the three opcode bits in positions 12 though 14 are not equal to 111, the instruction is a memory-reference type and the bit in position 15 is taken as the addressing mode I. if the 3 bit opcode is equal to 111, control then inspects the bit in position 15. if this bit is 0, the instruction is register-reference type. If the bit is 1, the instruction is an input-output type.It may seem that the computer is restricted to a maximum of eight distinct operations.

Computer InstructionsThe total number of instructions chosen for the basic computer is equal to 25The instructions for the computer are listed in table. The symbol designation is a three letter word and represents an abbreviation intended for programmers and users.The hexadecimal code is equal to the equivalent hexadecimal number of the binary code used for the instruction.

BASIC COMPUTER INSTRUCTIONS Hex CodeSymbol I = 0 I = 1 DescriptionAND 0xxx 8xxx AND memory word to ACADD 1xxx 9xxx Add memory word to ACLDA 2xxx Axxx Load AC from memorySTA 3xxx Bxxx Store content of AC into memoryBUN 4xxx Cxxx Branch unconditionallyBSA 5xxx Dxxx Branch and save return addressISZ 6xxx Exxx Increment and skip if zero

CLA 7800 Clear ACCLE 7400 Clear ECMA 7200 Complement ACCME 7100 Complement ECIR 7080 Circulate right AC and ECIL 7040 Circulate left AC and EINC 7020 Increment ACSPA 7010 Skip next instr. if AC is positiveSNA 7008 Skip next instr. if AC is negativeSZA 7004 Skip next instr. if AC is zeroSZE 7002 Skip next instr. if E is zeroHLT 7001 Halt computer

INP F800 Input character to ACOUT F400 Output character from ACSKI F200 Skip on input flagSKO F100 Skip on output flagION F080 Interrupt onIOF F040 Interrupt off

Instruction set completenessThe of instructions are said to be complete if the computer includes a sufficient number of instructions in each of the following categoriesArithmetic, Logical and shift instructionsInstructions for moving information to and from memory and processor registersProgram control instructions together with instructions that check status conditionsInput and output instructions

Arithmetic Micro operationsA micro operation is an elementary operation performed with the data stored in registers. Classified into four categories1. Register transfer micro operations transfer binary information from one register to another.2. Arithmetic micro operations perform arithmetic operations on numeric data stored in registers.3. Logic micro operations perform bit manipulation operations on non-numeric data stored in registers4. Shift micro operations perform shift operations on data stored in registers.

Arithmetic Micro operationsThe arithmetic micro operation is defined by the statement R3 R1+R2 specifies an add micro operation .It states that the contents of register R1 are added to the contents of register R2 and the sum transferred to the register R3. subtraction is most often implemented through complementation and addition.Instead of using the minus operator, we can specify the subtraction by the following statement.R3 R1+ R2+ 1

Arithmetic Micro operationsR2 is the symbol for the 1s complement of R2. Adding 1 to the 1s complement produces the 2s complement. Adding the contents of R1 to the 2s complement of R2 is equivalent to R1- R2.The increment and decrement micro operations are symbolized by plus-one and minus-one operations respectively.

Arithmetic Micro operations

Symbolic Designation DescriptionR3 R1 + R2Contents of R1 plus R2 transferred to R3R3 R1 R2Contents of R1 minus R2 transferred to R3R2 R2 Complement the contents of R2 (1s complement)R2 R2 + 12s Complement the contents of R2 (negate)R3 R1 + R2 + 1R1 plus the 2s complement of R2 (subtract) R1 R1 + 1 Increment the contents of R1 by oneR1 R1 1Decrement the contents of R1 by one

Stack organizationA useful feature that is included in the CPU of most computers is a stack or Last-In, First-Out(LIFO) list.A storage device that stores information in such a manner that the item stored last is the first item retrieved.Stack in digital computer is essentially a memory unit with an address register(SP) that can count only after an initial value is loaded into the stack.The register that holds the address for the stack is called a Stack Pointer(SP), because its value always points at the top in the stack.

Stack organizationThe two operations of a stack are the insertion and deletion of items. The operation of insertion is called PUSH (or push-down) because it can be thought as the result of pushing a new item on top.The operation of deletion is called POP(or pop-up) because it can be thought of as the result of removing one item so that the stack pops up.These operations are simulated by incrementing or decrementing the stack pointer register.

Stack organizationRegister Stack: A stack can be organized as a collection of a finite number words or registers.Fig: Block diagram of a 64-word stack

Stack OrganizationNote: FULL 1 ,when the stack is full, FULL 0 , when the stack is not full EMTY 1, when the stack is empty of items EMTY 0, when the stack is not emptyThe 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.Three items are placed in the stack: A, B and C, in that order. Item C is on top of the stack so that the content of SP is now 3.To remove the top item, the stack is popped by reading the memory word at address 3 and decrementing the content of SP. Item B is now on the top of stack, since SP holds the address 2.

Stack OrganizationTo insert a new item, the stack is pushed by incrementing SP and writing a word in the next-higher location in the stack.Note: Item C has been readout but not physically removed. This does not matter because when the stack is pushed, a new item is written in its place.In a 64-word stack, stack pointer contains 6 bit because 2^6 = 64. since SP has only six bits, it cannot exceed a number grater than 63(111111 in binary). When 63 is incremented by 1, the result is 0 since 111 111 + 1= 1000000 in binary but SP can accommodate only the six least significant bits. Similarly, when 000 000 is decremented by 1, the result is 111111.

Stack OrganizationThe 1-bit register FULL is set to 1 when the stack is full, and the 1-bit register EMTY 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.Initially, SP is cleared to 0, EMTY 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.

Stack OrganizationThe PUSH operation is implemented with the following sequence of micro operations. SP SP+1 Increment stack pointer M[SP] DR Write item on top of the stack If (SP=0) then (FULL1) Check if stack is full EMTY 0 Mark the stack not empty.The stack pointer is incremented so that it points to the address of the next-higher word.A memory write operation inserts the words from DR into the top of the stack.

Stack OrganizationThe first item stored in the stack is at address 1. The last item is stored at address 0.If SP reaches 0, the stack is full of items, so FULL is set to 1. This condition is reached if the top item prior to the last push was in location 63 and after incrementing SP, the last item is stored in location 0.Once the item is stored at location 0, there are no more empty registers in the stack. If an item is written in the stack, obviously the stack cannot be empty, so EMTY is cleared to 0.

Stack OrganizationA new item is deleted from the stack if the stack is not empty(if EMTY=0) . The POP operation consists of the following sequence of micro operations.DR M[SP] Read item from the top of stackSP SP -1 Decrement stack pointerIf (SP=0 ) then Check is stack is empty (EMTY1) FULL 0 Mark the stack not full.The top Item is read from the stack into DR. The stack pointer is then decremented. If its value reaches 0, the stack is empty, so EMTY is set to 1.

Stack OrganizationThis condition is reached if the item read was in location 1. once this item is readout, SP is decremented and reaches the value 0, which is the initial value of SP.Note: A POP operation reads the item from location 0 and then SP is decremented. SP changes to 111111, which is equivalent to decimal 63. in this configuration, the word in address 0 receives the last item in the stack.Stack is PUSHED when FULL = 0 or POPED when EMTY = 0

Stack OrganizationReverse Polish NotationA stack organization is very effective for evaluating arithmetic expressions. The common arithmetic expressions are written in infix notation with each operator written between the operandsExample: A * B + C * DThe star (denoting multiplication) is placed between two operands A and B or C and D. the plus is between the two products.

Stack Organizationprefix notation, places the operator before the operands.The postfix notation, referred to as Reverse Polish Notation(RPN) places the operators after the operands.Example: A + B infix notation + AB Postfix notation AB + Postfix or Reverse Polish NotationThe Reverse Polish Notation is a form suitable for stack manipulation.

Stack OrganizationThe expression A * B + C * D is written as AB *CD* Evaluated as followsScan the expression from left to right.When an operator is reached, perform the operation with the two operands found on the left side of the operator.Replace the two operands and the operator by the result obtained from the operation.Example: infix 3 * 4 + 5 * 6 = 42 postfix 3 4 * 5 6 * + 12 5 6 * + 12 30 + 42

Stack OrganizationReverse Polish notation evaluation with a stack. Stack is the most efficient way for evaluating arithmetic expressions.(Example) using stacks to do this. 3 * 4 + 5 * 6 = 42=> 3 4 * 5 6 * +

Instruction CodesA process is controlled by a programA program is a set of instructions that specify the operations, data, and the control sequenceAn instruction is stored in binary code that specifies a sequence of microoperationsInstruction codes together with data are stored in memory (Stored Program Concept)A computer instruction is a binary code that specifies a sequence of microoperations for the computer.Instruction codes together with data are stored in memory.

Instruction CodesInstruction code is a group of bits that instruct the computer t perform a specific operation. It is usually divided into parts, each having its own particular interpretation(Explanation or Understanding).The most basic part of an instruction code is its operation part. The operation code of an instruction is a group of bits that define such operations as add, subtract, multiply, shift and complement.The operation part of an instruction code specifies the operation to be performed. This operation must be performed on some data stored in processor registers or in memory.

Instruction CodesAn instruction code must therefore specify not only the operation but also the registers or the memory words where the operands are to be found, as well as registers or memory words where the results is to be stored.Stored program OrganizationThe simplest way to organize a computer is to have one processor register and instruction code format with two parts. The first part specifies the operation to be performed and the second part specifies an address.

Instruction CodesThe memory address tells the control where to find an operand in memory. This operand is read from memory and used as the data to be operated on together with the data stored in the processor register.For a memory unit with 4096 words we need 12 bits to specify an address since 2^12=4096. If we store each instruction code in one 16-bit memory word, we have available four bits for the operation code to specify one out of 16 possible operations, and 12 bits to specify the address of an operand.The control reads a 16-bit instruction from the program portion of the memory. It uses the 12-bit address part of the instruction to read an operand from the data portion of memory. It then executes the operation specified by the operation code.

Instruction Codes

Instruction CodesFig: Stored program Organization.

Opcode AddressBinary OperandInstruction Format151211015

Instruction CodesFig: Stored Program OrganizationInstructions(Program)

Operands(data)

Processor Register(accumulator or AC )Memory4096 * 16

Instruction CodesComputers that have a single-processor register usually assign to it the name accumulator and label it AC. The operation is performed with the memory operand and the content of AC.If an operation in an instruction code does not need an operand from memory, the rest of the bits in the instruction can be used for other purposes.For example, operations such as clear AC, complement AC, and increment AC operate on data stored in the AC register. They do not need an operand from memory.

Instruction CodesInstruction code formatInstruction code format with two parts : Op. Code + AddressOp. Code : specify 16 possible operations(4 bits)Address : specify the address of an operand(12 bits)If an operation in an instruction code does not need an operand from memory, the rest of the bits in the instruction (address field) can be used for other purpose

instructionNot an instruction

Instruction codesDirect and Indirect AddressIt is sometimes convenient to use the address bits of an instruction code not as an address but as the actual operand. When the second part of an instruction code specifies an operand, the instruction is said to have an immediate operand. when the second part specifies the address of an operand, the instruction is said to have a direct address. This is contrast to a third possibility called indirect address, where the bits in the second part of the instruction designate an address of a memory word in which the address of the operand is found.

Instruction CodeIt consists of a 3-bit operation code, 12-bit address, and an indirect address mode bit designated by I. The mode bit is 0 for direct address and 1 for indirect address.The memory word that holds the address of the operand in an indirect address instruction is used as a pointer to an array of data.IOp codeAddress151411012Fig: Instruction Format

Instruction CodeFig: Demonstration of direct and indirect address

Instruction CycleThe program is executed in the computer by going through a cycle for each instruction.In the basic computer each instruction cycle consists of the following phasesFetch an instruction from memoryDecode the instruction Read the effective address from memory if the instruction has an indirect addressExecute the instruction upon the completion of step 4, the control goes back to step1 to fetch, decode, and execute the next instruction. This process continues unless a HALT instruction is encountered.

Instruction CycleFetch and DecodeInitially, the program counter PC is loaded with the address of the first instruction in the program. The sequence counter SC is cleared to 0, providing a decoded timing signal T0. After each clock pulse, SC is incremented by one, so that the timing signals go through a sequence T0, T1, T2, and so on. The micro operations for the fetch and decode phases can be represented by the following register transfer statements.

Instruction CycleT0: AR PCT1: IR M[AR], PC PC+1T2: D0,.,D7 Decode IR(12-14), ARIR(0-11),IIR(15).on Since only AR is connected to the address inputs of memory, it is necessary to transfer the address from PC to AR during the clock transition associated with timing signal T0. The instruction read from the memory is then placed in the instruction register IR with the clock transition associated with the timing signal T1. At the same time, PC is incremented by one to prepare it for the address of the next instruction in the program.

Instruction CycleAt time T2, the operation code in IR is decoded, the indirect bit is transferred to flip-flop I, and the address part of the instruction is transferred to AR. The figure shows how the first two register transfer statements are implemented in the bus system. To provide the data path for the transfer of PC to AR we must apply a timing signal T0 to achieve the following connection.1. Place the content of PC onto the bus by making the bus selection inputs S2S1S0 equal to 010.2. Transfer the content of the bus to AR by enabling the LD input of AR

FETCH and DECODET0: AR PC (S0S1S2=010, T0=1)T1: IR M [AR], PC PC + 1 (S0S1S2=111, T1=1)T2: D0, . . . , D7 Decode IR(12-14), AR IR(0-11), I IR(15)S2S1S0Bus7Memory

unitAddressReadARLDPCINRIRLDClock125Common busT1T0Instruction Cycle

Instruction CycleThe next clock transition initiates the transfer from PC to AR since T0=1. In order to implement the second statementT1: IR M[AR], PC PC+1 it is necessary to use timing signal T1 to provide the following connections in the bus system.Enable the read input of memoryPlace the content of memory on to the bus by making S2S1S0= 111.Transfer the content of the bus to IR by enabling the LD input of IR.Increment PC by enabling the INR input of PC

Instruction CycleDetermine the Type of InstructionThe timing signal that is active after the decoding is T3. During time T3, the control unit determines the type of instruction that was just read from memory. Decoder output D7 is equal to 1 if the operation code is equal to binary 111 we determine that if D7=1, the instruction must be register or input-output instruction type. If D7=0, the operation code must be one of the other seven values 000 through 110, specifying a memory-reference instruction.Fig: Flowchart for instruction cycle (initial configuration)

Instruction Cycle..Control then inspects the value of the first bit of the instruction, which is now available in flip-flop I. If D7=0 and I=1, we have a memory-reference instruction with an indirect address. It is then necessary to read the effective address from memory.The micro operations for the indirect address condition can be symbolized by the register transfer statement AR M[AR].Initially, AR holds the address part of the instruction. This address is used during the memory read operation. The word at the address given by AR is read from memory and placed on the common bus.

Register Reference InstructionRegister reference instruction are recognized by the control when D7=1 and I =0. These instructions use bits 0 through 11 of the instruction code to specify one of 12 instructions. These 12 bits are available in IR(0-11). They were also transferred to AR during time T2

Register Reference Instruction

Register Reference Instructionr = D7 IT3 => Register Reference InstructionBi = IR(i) , i=0,1,2,...,11r:SC 0 Clear SCCLArB11:AC 0 Clear ACCLErB10:E 0 Clear ECMArB9:AC AC Complement ACCMErB8:E E Complement ECIRrB7:AC shr AC, AC(15) E, E AC(0) Circulate rightCILrB6:AC shl AC, AC(0) E, E AC(15) Circulate leftINCrB5:AC AC + 1 Increment ACSPArB4:if (AC(15) = 0) then (PC PC+1) Skip if positiveSNArB3:if (AC(15) = 1) then (PC PC+1) Skip if negativeSZArB2:if (AC = 0) then (PC PC+1) Skip if AC zeroSZErB1:if (E = 0) then (PC PC+1) Skip if E zeroHLTrB0:S 0 (S is a start-stop flip-flop) Halt computer

Memory Reference InstructionsThe decoded output Di for i = 0, 1, 2, 3, 4, 5, and 6 from the operation decoder that belongs to each instruction is included in the table. The effective address of the instruction is in the address register AR and was placed there during timing signal T2 when I = 0, or during timing signal T3 when I = 1. The execution of the memory-reference instructions starts with timing signal T4 the symbolic description of each instruction is specified in the table in terms of register transfer notation.

Memory Reference InstructionsThe actual execution of the instruction in the bus system will require a sequence of micro operations. This is because data stored in memory cannot be processed directly. The data must be read from memory to a register where they can be operated on with logic circuits. We now explain the operation of each instruction and list the control functions and micro operations needed for their execution

Memory Reference InstructionsTable: Memory Reference Instruction

SymbolOperation Decoder Symbolic descriptionANDD0AC AC M[AR]ADDD1AC AC + M[AR], E CoutLDAD2AC M[AR]STAD3M[AR] ACBUND4PC ARBSAD5M[AR]PC, PCAR+1ISZD6M[AR]M[AR]+1,If M[AR]+1 =0 then PC PC +1

Memory Reference Instructions AND to AC This is an instruction that performs the AND logic operation on pairs of bits in AC and the memory word specified by the effective address. The result of the operation is transferred to AC. The micro operations that execute this instruction are: D0T4 : DR M[AR] D0T5: AC AC DR, SC 0.The control function for this instruction uses the operation decoder D0 since this output of the decoder is active when the instruction has an AND operation whose binary code value is 000. Two timing signals are needed to execute the instruction.

Memory Reference InstructionsTwo timing signals are needed to execute the instruction. The clock transition associated with timing signal T4 transfers the operand from memory into DR. The clock transition associated with the next timing signal T5 transfers to AC the result of the AND logic operation between the contents of DR and AC.The clock transition associated with timing signal T4 transfers the operand from memory into DR. The clock transition associated with the next timing signal T5 transfers to AC the result of the AND logic operation between the contents of DR and AC.

Memory Reference Instruction ADD to AC The instruction adds the content of the memory word specified by the effective address to the value of AC. The sum is transferred into AC and the output carry Count is transferred to the E (extended accumulator) flip-flop. The micro operations needed to execute this instruction are D1T4: DR M[AR] D1T5: AC AC + DR, E Cout, SC 0

Memory Reference InstructionThe same two timing signals, T4 and T5, are used again but with operation decoder D1 instead of D0, which was used for the AND instruction. After the instruction is fetched from memory and decoded, only one output of the operation decoder will be active, and that output determines the sequence of micro operations that the control follows during the execution of a memory-reference instruction.

Memory Reference Instruction LDA : Load to ACThis instruction transfers the memory word specified by the effective address to AC. The microoperations needed to execute this instruction areD2T4: DR M[AR]D2T5: AC DR, SC 0

Memory Reference Instruction STA : Store ACThis instruction stores the content of AC into the memory word specified by the effective address.Since the output of AC is applied to the bus and the data input of memory is connected to the bus,we can execute this instruction with one micro operation:D3T4: M[AR] AC, SC 0

Memory Reference InstructionThis instruction transfers the program to the instruction specified by the effective address.Remember that PC holds the address of the instruction to be read from memory in the next instruction cycle in the program sequence. BUN : Branch UnconditionallyThe BUN instruction allows the programmer to specify an instruction out of sequence and we say that the program branches (or jumps) unconditionally. The instruction is executed with one micro operation: D4T4: PC AR, SC 0

Memory Reference InstructionBSA : Branch and Save Return AddressThis instruction is useful for branching to a portion of the program called a subroutine or procedure. When executed, the BSA instruction stores the address of the next instruction in sequence (which is available in PC) into a memory location specified by the effective address.The effective address plus one is then transferred to PC to serve as the address of the first instruction in the subordinate. M[AR] PC, PC AR + 1D5T5: PC AR, SC 0

MEMORY REFERENCE INSTRUCTIONS Memory, PC after execution210BSA135Next instructionSubroutine20PC = 21AR = 1351361BUN135 Memory, PC, AR at time T40BSA135Next instructionSubroutine2021135PC = 1361BUN135MemoryMemoryBSA: Branch and Save Return Address

Timing signal T4 initiates a memory write operation, places the content of PC onto the bus, and enables the INR input of AR. The memory write operation is completed and AR is incremented by the time the next clock transition occurs. The bus is used at T5 to transfer the content of AR to PC.

Memory Reference InstructionISZ : Increment and Skip if ZeroThis instruction increments the word specified by the effective address, and if the incremented value is equal to 0, PC is incremented by 1.This is done with the following sequence of microoperations:D6T4: DR M[AR]D6T5: DR DR + 1D6T6 : M[AR] DR, if (DR = 0) then (PC PC + 1), SC 0

FLOWCHART FOR MEMORY REFERENCE INSTRUCTIONSMemory-reference instructionDR M[AR]DR M[AR]DR M[AR]M[AR] AC

SC 0ANDADDLDASTAAC AC DR

SC 0AC AC + DR

E Cout

SC 0AC DR

SC 0D T04D T14D T24D T34D T05D T15D T25PC AR

SC 0M[AR] PC

AR AR + 1DR M[AR]BUNBSAISZD T44D T54D T64DR DR + 1D T55D T65PC AR

SC 0M[AR] DR

If (DR = 0)

then (PC PC + 1)

SC 0D T66

Instruction FormatsComputers fall into one of three types of CPU organizations.1. Single Accumulator Organization2. General Register Organization3. Stack OrganizationSingle Accumulator Organization: All operations are performed with an implied accumulator register. The instruction format of this type of computer uses one address field.Ex: ADD X AC AC + M[X]

Instruction FormatsComputers fall into one of three types of CPU organizations.1. Single Accumulator Organization2. General Register Organization3. Stack OrganizationSingle Accumulator Organization: All operations are performed with an implied accumulator register. The instruction format of this type of computer uses one address field.Ex: ADD X AC AC + M[X]

Instruction FormatsComputers fall into one of three types of CPU organizations.1. Single Accumulator Organization2. General Register Organization3. Stack OrganizationSingle Accumulator Organization: All operations are performed with an implied accumulator register. The instruction format of this type of computer uses one address field.Ex: ADD X AC AC + M[X]

Instruction FormatsGeneral Register Organization: The instruction format in this type of computer needs three registers address fields.ADD R1, R2, R3 R1 R2+ R3We can reduce from three to two if the destination register is the same as one of the source register. ADD R1, R2R1 R1+R2 MOV R1, R2R1 R2 (OR R2 R1)Thus ,a transfer type of instruction need two address fields to specify the source and the destination.

Instruction FormatsADD R1, X R1 R1 + M[X]. It has two address fields, one form register R1 and the other from the Memory address X.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 X to the top of stack. Operation type instruction do not need an address field in stack organized computers.

Instruction FormatsTo 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.We assume that the operands are in memory at address A, B, C and D; and the result must be stored in memory at address X.

Instruction FormatsThree- Address Instructions: Computer with three addresses instruction format can use each address field to specify either processor register are memory operand.X = (A + B) * (C + A)ADDR1, A, BR1 M [A] + M [B]ADD R2, C, DR2 M [C] + M [D] MUL X, R1, R2M [X] R1 * R2

Instruction FormatsThe advantage of the three address formats is that it results in short program when evaluating arithmetic expression. The disadvantage is that the binary-coded instructions require too many bits to specify three addresses.Two Address Instruction:Most common in commercial computers. Each address field can specify either a processes register on a memory word.X = (A + B) * ( C + D)

Instruction FormatsMOVR1, AR1M [A]ADDR1, BR1 R1 + M [B]MOVR2, CR2 M [C]ADDR2, DR2 R2 + M [D]MULR1, R2R1 R1 * R2MOVX, R1M [X] R1One Address instructionIt used an implied accumulator (AC) register for all data manipulation. For multiplication/division, there is a need for a second register.

Instruction FormatsLOAD AAC M [A]ADD BAC AC + M [B]STORE T M [T] ACLOAD CAC M (C) ADD DAC AC + M (D)MUL TAC AC * M (T)STOREXM [] AC

Instruction FormatsAll operations are done between the AC register and a memory operand. Its the address of a temporary memory location required for storing the intermediate result.Zero Address InstructionA stack organized computer does not use an address field for the instruction ADD and MUL. The PUSH & POP instruction, however, need an address field to specify the operand that communicates with the stack (TOS top of the stack)

Instruction FormatsPUSHATOS APUSH BTOS BADDTOS (A + B)PUSH CTOS CPUSH DTOS DADDTOS (C + D)MULTOS (C + D) * (A + B)POPXM [X] TOS

Addressing ModesAddressing is a method to provide access to the data stored in memory. Different ways in which the address of an operand is specified in an instruction is referred to as addressing mode. The operation field of an instruction specifies the operation to be performed. This operation must be executed on some data stored in computer register as memory words. The way the operands are chosen during program execution is dependent on the addressing mode of the instruction.

Addressing ModesThe addressing mode specifies a rule for interpreting or modifying the address field of the instruction between the operand is activity referenced. Computer use addressing mode technique for the purpose of accommodating one or both of the following provisions.1. To give programming versatility to the uses by providing such facilities as pointer to memory, counters for top control, indexing of data, and program relocation.2. To reduce the number of bits in the addressing fields of the instruction.

Addressing ModesThe basic operation cycle of the computerFetch the instruction from memoryDecode the instructionExecute the instructionThe decoding done in phase 2 determines the operation to be performed, the addressing mode of the instruction, and the location of the operands. The computer then executes the instruction and return to step 1 to fetch the next instruction.

Addressing ModesInstructions may be defined with a variety of addressing modes and sometimes, two or more addressing modes are combined in one instruction.There may or may not be an address field in the instruction. If there is an address field, it may designate a memory address or a processor register.Addressing modes modify the address field of the instruction, there are two modes that need no address field at all. These re implied and immediate modes.Various addressing modes are

Addressing Modes(1) Implied mode(2) Immediate mode(3) Register mode(4) Register mode(5) Register indirect mode(6) Auto increment/ Auto decrement mode(7) Direct Address mode(8) Indirect Address mode(9) Relative Address mode(10) Indexed Addressing mode(11) Base Register Addressing mode

Addressing ModesImplied Mode:In this mode the operands are specified implicitly in the definition of the instruction.For example: The instruction complement accumulator 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

Addressing ModesZero-address instructions in a stack organization computer are implied-mode instructions since the operands are implied to be on top of the stack.ExamplesRAL : Rotate the contents of the accumulator left RLC: Rotate the contents of the accumulator left through carryCMA : Take the complement of the contents of the accumulator

Addressing ModesImmediate Mode: In this mode the operand is specified in the instruction itself. In other words, an immediate mode instruction has an operand field rather than address field.Example: MVI A, 06 : Move 06 to the accumulator ADI 05 : Add 05 to the content of the accumulatorRegister Mode: In this mode the operands are in registers that reside within the CPU. In other words the contents of a register is the operand.

Addressing ModesExample:MOV A ,B : Transfer the contents of the register B to register A.ADD B : Add the contents of the register B to the contents of the accumulator.No memory accessVery fast executionVery limited address spaceRegister Indirect Mode: In this mode the instruction specifies a register in the CPU whose contents gives the address of the operand in memory. In other words, the selected register contains the address of the operand rather than the operand itself.

Register Indirect Addressing DiagramRegister Address ROpcodeInstructionMemoryOperandPointer to OperandRegisters

Addressing ModesDirect Addressing: In this mode the effective address is equal to the address part of the instruction. The operand resides in memory and its address is given directly by the address field of the instruction.Advantages:Single memory reference to access dataNo additional calculations to work out effective addressLimited address space

Direct Addressing DiagramAddress AOp codeInstructionMemoryOperand

Addressing ModesIndirect Addressing: In this mode the address field of the instruction gives the address where the effective address is stored in memory.Control fetches the instruction from memory and uses its address part to access memory again to the read the EA.e.g. ADD (A) : Add contents of cell pointed to by contents of A to accumulatorMultiple memory accesses to find operandHence slower

Indirect Addressing DiagramAddress AOpcodeInstructionMemoryOperandPointer to operand

Addressing ModesAuto Increment or Auto Decrement ModeThis is similar to the register indirect mode except that the register is incremented or decremented after(or before) its value is used to access memory.When the address stored in the register refers to a table of data in memory, it is necessary to increment or decrement the register after every access to the table.

Addressing ModesRelative Addressing Mode: In this mode the content of PC is added to the address part of the instruction in order to obtain the effective address.Example: Assume that the PC contains an address 825 and the address part of the instruction contains the number 24. The instruction at location 825 is read from the memory during the fetch phase and the PC is then incremented by one to 826. The EA computation for the relative address mode is 826+24=850Relative addressing is often used with branch-type instructions.

Addressing ModesDirect Relative Addressing Mode:Address of operand = EA = Content of PC + DisplacementIndirect Addressing Mode: Address of operand is calculated by adding the content of register indicated by the base register and displacementAddress of Operand = EA = Displacement + Base address

Addressing ModesExample: If PCMain Memory80024Here 800+24 =824; the address of the memory Location.Now, 100 will be added to the content of register R1

ADDR124

800

100

Addressing ModesIndexed Addressing Mode: In this mode the content of an index register is added to the address part of the instruction to obtain EA. The index register is a special CPU register that contains an index value

Example: index Main Memory500524Here the index register contains the index valueEA= 500 +24 =524. Now 1001 will be added to the content of R1

ADDR1500

24

1001

**l*p*.**t***1469