Assignment #02

Student Name: Nitasha Huma

Class Roll: 2019-CPE-28
Subject Teacher: Sir Zahid Iqbal
Lab Engineer: Engr. Muhammad Ubaid-ullah
Lab Performed In: MP Lab

______________________
Course Instructor / Lab Engineer
 Q1
Discuss the interrupt system of Intel 8086. What is interrupt pointer? What is
'type' of an interrupt?
Interrupts in 8086 microprocessors

An interrupt is a condition that halts the microprocessor temporarily to work on a different task
and then return to its previous task. Interrupt is an event or signal that request to attention of
CPU. This halt allows peripheral devices to access the microprocessor.
Whenever an interrupt occurs the processor completes the execution of the current instruction
and starts the execution of an Interrupt Service Routine (ISR) or Interrupt Handler. ISR is a
program that tells the processor what to do when the interrupt occurs. After the execution of ISR,
control returns back to the main routine where it was interrupted.
In 8086 microprocessor following tasks are performed when microprocessor encounters an
interrupt:
1. The value of flag register is pushed into the stack. It means that first the value of SP (Stack
Pointer) is decremented by 2 then the value of flag register is pushed to the memory address
of stack segment.
2. The value of starting memory address of CS (Code Segment) is pushed into the stack.
3. The value of IP (Instruction Pointer) is pushed into the stack.
4. IP is loaded from word location (Interrupt type) * 04.
5. CS is loaded from the next word location.
6. Interrupt and Trap flag are reset to 0.
Hardware interrupts can be classified into two types they are
 Maskable Interrupt: The hardware interrupts which can be delayed when a much
highest priority interrupt has occurred to the processor.
 Non Maskable Interrupt: The hardware which cannot be delayed and should process by
the processor immediately.

1. Hardware Interrupts
Hardware interrupts are those interrupts which are caused by any peripheral device by
sending a signal through a specified pin to the microprocessor. There are two hardware
interrupts in 8086 microprocessors. They are:
 (A) NMI (Non Maskable Interrupt) It is a single pin non maskable hardware interrupt
which cannot be disabled. It is the highest priority interrupt in 8086 microprocessors.
After its execution, this interrupt generates a TYPE 2 interrupt. IP is loaded from word
location 00008 H and CS is loaded from the word location 0000A H.
 (B) INTR (Interrupt Request): It provides a single interrupt request and is activated by
I/O port. This interrupt can be masked or delayed. It is a level triggered interrupt. It can
receive any interrupt type, so the value of IP and CS will change on the interrupt type
received.
2. Software Interrupts
These are instructions that are inserted within the program to generate interrupts. There are
256 software interrupts in 8086 microprocessors. The instructions are of the format INT type
 where type ranges from 00 to FF. The starting address ranges from 00000 H to 003FF H.
These are 2-byte instructions. IP is loaded from type * 04 H and CS is loaded from the next
address given by (type * 04) + 02 H. Some important software interrupts are:
 (A) TYPE 0 corresponds to division by zero (0).
 (B) TYPE 1 is used for single step execution for debugging of program.
 (C) TYPE 2 represents NMI and is used in power failure conditions.
 (D) TYPE 3 represents a break-point interrupt.
 (E) TYPE 4 is the overflow interrupt.
Interrupt Pointer

The interrupt vector (or interrupt pointer) table is the link between an interrupt type code and
the procedure that has been designated to service interrupts associated with that code. This
double word pointer contains the address of the procedure that is to service interrupts of that
type.

Q2
Explain the concept of pipelining in 8086. Discuss its advantages and
disadvantages
What is pipelining?
A technique used in advanced microprocessors where the microprocessor begins executing a
second instruction before the first has been completed.
A Pipeline is a series of stages, where some work is done at each stage. The work is not finished
until it has passed through all stages. With pipelining, the computer architecture allows the next
instructions to be fetched while the processor is performing arithmetic operations, holding them
in a buffer close to the processor until each instruction operation can be performed.

How pipelining works?

The pipeline is divided into segments and each segment can execute its operation concurrently
with the other segments.
Once a segment completes an operation, it passes the result to the next segment in the pipeline
and fetches the next operations from the preceding segment.

Characteristics of Pipelines:
Hardware or software implementation – pipelining can be implemented in either software or
hardware.

 Large or Small Scale: Stations in a pipeline can range from simplistic to powerful, and a
pipeline can range in length from short to long.
 Synchronous or asynchronous flow: A synchronous pipeline operates like an assembly
line: at a given time, each station is processing some amount of information. An
asynchronous pipeline, allow a station to forward information at any time.
  Buffered or unbuffered flow: One stage of pipeline sends data directly to another one or
a buffer is placed between each pair of stages.
 Finite Chunks or Continuous Bit Streams: The digital information that passes through
a pipeline can consist of a sequence or small data items or an arbitrarily long bit stream.
Automatic Data Feed or Manual Data Feed – Some implementations of pipelines use a
separate mechanism to move information, and other implementations require each stage
to participate in moving information
Pipelining undergoes in 3 stages namely "Instruction Fetch", " Instruction Decode" and "
Execute".

Instruction Fetch:
The instruction Fetch (IF) stage is responsible for obtaining the requested instruction from
memory. The instruction and the program counter (which is incremented to the next instruction)
are stored in the IF/ID pipeline register as temporary storage so that may be used in the next
stage at the start of the next clock cycle.

Instruction Decode:
The Instruction Decode (ID) stage is responsible for decoding the instruction and sending out the
various control lines to the other parts of the processor. The instruction is sent to the control unit
where it is decoded and the registers are fetched from the register file.

Execution:
The Execution (EX) stage is where any calculations are performed. The main component in this
stage is the ALU. The ALU is made up of arithmetic, logic and capabilities.

Advantages of Pipelining

 Instruction throughput increases.

 Increase in the number of pipeline stages increases the number of instructions executed
simultaneously.
 Faster ALU can be designed when pipelining is used.
 Pipelined CPU’s works at higher clock frequencies than the RAM.
 Pipelining increases the overall performance of the CPU.
Disadvantages of Pipelining

 Designing of the pipelined processor is complex.

 Instruction latency increases in pipelined processors.
 The throughput of a pipelined processor is difficult to predict.
 The longer the pipeline, worse the problem of hazard for branch instructions.
Q3
Draw and explain the architecture of 8086
Internal Architecture of 8086:

It is internally divided into two separate functional units. These are the Bus Interface Unit
(BIU) and the Execution Unit (EU). These two functional units can work simultaneously to
increase system speed and hence the throughput. Throughput is a measure of number of
instructions executed per unit time.
Bus Interface Unit:

The bus interface unit is the Internal Architecture of 8086 to the outside world. It provides a full
16-bit bi-directional data bus and 20-bit address bus. The bus interface unit is responsible for
performing all external bus operations, as listed below.

Functions of Bus Interface Unit

1. It sends address of the memory or I/O.

2. It fetches instruction from memory.
3. It reads data from port/memory.
4. It Writes data into port/memory.
5. It supports instruction queuing.
6. It provides the address relocation facility.
To implement these functions the BIU contains the instruction queue, segment registers
instruction pointer, address summer and bus control logic.

Instruction Queue:

To speed up program execution, the BIU fetches six instruction bytes ahead of time from the
memory. These prefetched instruction bytes are held for the execution unit in a group of registers
called Queue. With the help of queue, it is possible to fetch next instruction when current
instruction is in execution. In Internal Architecture of 8086, operands for multiplication
operations are within registers. Still it requires 100 clock cycles to execute multiply instruction.
Like multiplication there are number of other instructions in 3086 which need a quite a large
number- of clock cycles for execution. During this execution time the BIU fetches the next
instruction or instructions from memory into the instruction queue instead of remaining idle. The
BIU continues this process as long as the queue is not full. Due to this, execution unit gets the
ready instruction in the queue and instruction fetch time is eliminated.
The queue operates on the principle first in first out (FIFO). So that the execution unit gets the
instructions for execution in the order they are fetched. In case of JUMP and CALL instructions,
instruction already fetched in queue are of no use. Hence, in these cases queue is dumped and
newly formed by loading instructions from new address specified by JUMP or CALL
instruction. Feature of fetching the next instruction while the current instruction is executing is
called pipelining.

Segment Registers:

The physical address of the Internal Architecture of 8086 is 20-bits wide to access 1 Mbyte
memory locations. However, its registers and memory locations which contain logical addresses
are just 16-bits wide. Hence 8086 uses memory segmentation. It treats the 1 Mbyte of memory as
divided into segments, with a maximum size of a segment as 64 Kbytes. Thus, any location
within the segment can be accessed using 16 bits. For the selection of the four active segments
the 16-bit segment registers are provided within the BIU of the 8086. These four registers are:

Code segment (CS) register, the data segment (DS) register, the stack segment (SS) register,
and the extra segment (ES) register. These are used to hold the upper 16-bits of the starting
addresses of the four memory segments, on which 8086 works at a particular time. For example,
the value in CS identifies the starting address of 64 K-byte segment known as code segment. By
“starting address “, we mean the lowest addressed byte in the active code segment. The starting
address is also known as base address or segment base.
The BIT) always inserts zeros for the lowest 4 bits (nibble) in the contents of segment register to
generate 20-bit base address. For example, if the code segment register contains 348AH, then
code segment will start at address 348A0H.

Functions of Segment Registers:

1. The CS register holds the upper 16-bits of the starting address of the segment from which
the BIU is currently fetching the instruction code byte.
2. The SS register is used for the upper 16-bits of the starting address for the program stack
(all stack related instructions will operate on stack)
3. ES register and DS register are used to hold the upper 16-bits of the starting address of
the two memory segments Which are used for data.
Instruction Pointer:

The instruction pointer register holds the 16-bit address of the next Code byte within the code
segment. The value contained in the IP is referred to as an offset. This value must be offset from
(added to) the segment base address in CS to produce the required 20-bit physical address.

Execution Unit [EU]:

The execution unit of Internal Architecture of 8086 tells the BIU from where to fetch instructions
or data, decodes instructions and executes instructions. It contains

 Control Circuitry
 Instruction Decoder
 Arithmetic Logic Unit (ALU)
 Flag Register
 General Purpose Registers
 Pointers and Index Registers
Control Circuitry, Instruction Decoder, ALU:

The control circuitry in the EU directs the internal operations. A decoder in the EU translates the
instructions fetched from memory into a series of actions wlifeh the EU performs. ALU is 16-bit.
It can add, subtract, AND, OR, XOR, increment, decrements, complement and shift binary
numbers.

Flag Register:

A flag is a flip–flop which indicates some condition produced by the execution of an instruction
or controls certain operations of the EU. The flag register contains nine active flags as shown in
the Fig. 6.6.
General Purpose Registers:

The EU has. 8 general purpose registers labeled ATI, AL, BH, BL, CH, CL, DH, and DL. These
registers can be used individually for temporary storage of 8-bit data. The AL register is also
called accumulator. Certain pairs of these general-purpose registers can be used together to store
16-bit data, such as AX, BX, CX and DX.

Pointers and Index Registers:

All segment registers are 16-bit. But it is necessary to put 20-bit address (physical address) on
the address bus. To get 20-bit physical address one more register is associated with each segment
register the way IP is associated with CS.

These additional registers belong to the pointer and index group. The pointer and index group
consist of instruction pointer (IP), stack pointer (SP), BP (base pointer), source index (SI) and
destination index (DI) registers.

Stack Pointer (SP) : The stack pointer (SP) register contains the 16-bit offset from the start of
the segment to the top of stack. For stack operation, physical address is produced by adding the
contents of stack pointer register to the segment base address in SS. To do this the contents of the
stack segment register are shifted four bits left and the contents of SP are added to the shifted
result

SS = 4000H after shifting four bits left SS = 40000H

Now
Base Pointer, Source Index and Destination Index (BP, SI and DI)

These three 16-bit registers can be used as general-purpose registers. However, their. main use is
to hold the 16-bit offset of the data word in one of the segments.

Base pointer: We can use the BP register instead of SP for accessing the stack using the based
addressing. mode. In this case, the 20-bit physical stack address. is calculated from BP and SS.
Addressing modes are discussed in later section.

Source Index: Source index (SI) can be used to hold the offset of a data word in the data
segment. In this case, the 20-bit physical data address is calculated from SI and

Destination Index: The ES register. points to the extra segment in which data is stored. String
instructions always use ES and DI to determine the 20-bit physical address for the destination.

Q4
How many interrupt lines does 8086 have
There are 256 software interrupts in 8086 microprocessors. The instructions are of the format
INT type where type ranges from 00 to FF. The starting address ranges from 00000 H to
003FF H. These are 2-byte instructions. IP is loaded from type * 04 H and CS is loaded from
the next address given by (type * 04) + 02 H.

8086 have 5 interrupt lines.

 Q5
Explain the concept of CISC and RISC technology

CISC and RISC (Complex and Reduced Instruction Set Computer, respectively) are dominant
processor architecture paradigms. Computers of the two types are differentiated by the nature of
the data processing instruction sets interpreted by their central processing units (CPUs).

CISC

To improve performance, CISC systems try to reduce the number of instructions programs must
call. To do this, they have large sets of microcode instructions that cover a broad range of tasks.
A single microcode instruction, in turn, when translated in the CPU, may become several tasks
the processor performs. As a consequence, instructions are of variable length and often require
more than one clock cycle to complete.

RISC

RISC systems, on the other hand, seek to improve performance by reducing the number of clock
cycles required to perform tasks. They have small sets of simplified instructions, doing away
with microcode altogether in most cases. While this means that tasks require more instructions,
instructions are all of the same length and usually require only one clock cycle to complete.
Because of this, RISC systems are capable of processing instructions in parallel in a process
called pipelining. The CPU works on more than one instruction at once by starting the second
instruction before it completes the first one. This greatly increases throughput and makes RISC
systems substantially faster than their CISC counterparts. RISC systems do have a few
disadvantages, however. Notably, because programs usually have more instructions, compilers
and applications written in assembly language are more difficult to build for RISC systems.

Examples of RISC and CISC

Examples of CISC processors include the 680x0 and the VAX. RISC processors include the
PowerPC, MIPS, SPARC, and the Alpha. Recent processors in the x86 (e.g., IA-32) family are
often described as CISC, but in reality, they are hybrids of the two architectures.
How these technologies are facilitating in improvement of today’s processor?

The RISC Design Strategies: -

The basic RISC principle: “A simpler CPU is a faster CPU”.

The focus of the RISC design is reduction of the number and complexity of instructions in the
ISA.

A number of the more common strategies include:

1) Fixed instruction length, generally one word.
This simplifies instruction fetch.

2) Simplified addressing modes.

3) Fewer and simpler instructions in the instruction set.

4) Only load and store instructions access memory;

no add memory to register, add memory to memory, etc.

5) Let the compiler do it. Use a good compiler to break complex high-level language statements
into a number of simple assembly language statements.

Typical characteristics of RISC: -

For any given level of general performance, a RISC chip will typically have far fewer transistors
dedicated to the core logic which originally allowed designers to increase the size of the register
set and increase internal parallelism.

Other features, which are typically found in RISC architectures, are:

1. Uniform instruction format, using a single word with the opcode in the same bit positions
in every instruction, demanding less decoding;

2. Identical general-purpose registers, allowing any register to be used in any context,

simplifying compiler design (although normally there are separate floating-point
registers);

3. Simple addressing modes. Complex addressing performed via sequences of arithmetic

and/or load-store operations.

4. Fixed length instructions which

(a) are easier to decode than variable length instructions, and

(b) use fast, inexpensive memory to execute a larger piece of code.

5. Hardwired controller instructions (as opposed to micro coded instructions). This is where
RISC really shines as hardware implementation of instructions is much faster and uses less
silicon real estate than a micro store area.

6. Fused or compound instructions which are heavily optimized for the most commonly used
functions.
7. Pipelined implementations with goal of executing one instruction (or more) per machine
cycle.

8. Large uniform register set

9. minimal number of addressing modes

10. no/minimal support for misaligned accesses.