CSA UNIT IV

• Computer Organization is about how the components of a

computer system, like the CPU, memory, and input/output
devices, are connected and work together to execute
programs. It focuses on the operational aspects and how
hardware components are implemented to support the
architecture.

INTRODUCTION OF COMPUTER:

A computer is an electronic device that processes, stores, and

executes instructions to perform tasks. It includes key components
such as the CPU (Central Processing Unit), RAM (Memory), storage
(HDD/SSD), input devices (keyboard, mouse), output devices (monitor,
printer), and peripherals (USB drives).

CPU:
A Central Processing Unit (CPU), often called the "brain" of a
computer, is the primary processor that executes instructions and
manages data. It's a hardware component responsible for carrying out
the instructions of computer programs, performing arithmetic, logical
operations, and input/output tasks.

Computer Architecture
Computer architecture is the functional design and structure of a
computer system. It focuses on how a computer’s hardware
components, like the CPU and memory, work together to execute
instructions efficiently. It involves decisions about the instruction set,
data paths, and control units to optimize performance and
functionality.

COMPUTR DESIGN:
Computer design encompasses the process of creating and
designing computer systems, including hardware components,
software, and digital devices. It involves developing computer
architecture, circuit design, and integrating hardware and software
components.
Stored program concept concept:
The stored program concept, a fundamental principle in computer
science, states that both the instructions (program) and the data a
computer operates on are stored in the same memory. This allows the
computer to execute different programs by simply changing the
contents of memory, rather than requiring physical rewiring of the
hardware.

Von Neumann Architecture

Von Neumann Architecture is a digital computer architecture whose
design is based on the concept of stored program computers where
program data and instruction data are stored in the same memory. This
architecture was designed by the famous mathematician and
physicist John Von Neumann in 1945.
Advantages of Von Neumann Architecture
• Simplicity: The fact that all data and instructions are stored
in a single memory space helps the process of designing a
computer system as there is no need to create complicated
systems of routing since pathways may coincide.
• Cost-Effective: A smaller number of components is needed as
compared to the other architectural designs hence more
economical.
• Flexibility: A program can Always be changed or altered
without experiencing a change in some underlying physical
aspects such as the circuitry.
Disadvantages of Von Neumann Architecture
• Bottleneck Issues: The shared bus can be a problem because
the data and control instructions cannot be obtained
simultaneously and therefore it becomes slow.
• Memory Corruption: Since the data and instructions reside in
the same memory, then there is a temptation of one erasing
the other thereby producing system faults.

Harvard Architecture:
The Harvard architecture is a computer architecture that separates
memory storage and buses for instructions and data, unlike the von
Neumann architecture, which uses a single memory and bus for both.
This separation allows the CPU to access instructions and read/write
data simultaneously, overcoming the bottleneck of von Neumann's
architecture and enhancing processing speed.

Advantage of Harvard Architecture

• Fast and efficient data access: Since Harvard architecture has
separate memory spaces for instructions and data, it allows
 for parallel and simultaneous access to both memory spaces,
which leads to faster and more efficient data access.
• Better performance: The use of fixed instruction length,
parallel processing, and optimized memory usage in Harvard
architecture can lead to improved performance and faster
execution of instructions.
• Suitable for real-time applications: Harvard architecture is
commonly used in embedded systems and other real-time
applications where speed and efficiency are critical.
• Security: The sepa5y spaces can also provide a degree of
security against certain types of attacks, such as buffer
overflow attacks.
Disadvantages of Harvard Architecture
• Complexity: The use of separate memory spaces for
instructions and data in Harvard architecture adds to the
complexity of the processor design and can increase the cost
of manufacturing.
• Limited flexibility: Harvard architecture has limited flexibility
in terms of modifying instructions at runtime because
instructions and data are stored in separate memory spaces.
This can make certain types of programming more difficult or
impossible to implement.
• Higher memory requirements: Harvard architecture requires
more memory than Von Neumann architecture , which can
lead to higher costs and power consumption.
• Code size limitations: Fixed instruction length in Harvard
architecture can limit the size of code that can be executed,
making it unsuitable for some applications with larger code
bases.

CISC vs. RISC Architectures

123

Reduced Instruction Set Computing (RISC) and Complex Instruction Set Computing (CISC) are
two different approaches to designing the instruction set of a CPU. Each has its own advantages
and disadvantages, and they are suited to different types of applications and hardware
environments.

RISC (Reduced Instruction Set Computing)

RISC architecture aims to simplify the hardware by using a small set of simple instructions that
can be executed quickly. The main characteristics of RISC include:

• Simpler Instructions: RISC processors use a smaller set of simple instructions, making
them easier to decode and execute quickly1.
• Single Clock Cycle Execution: Most instructions in RISC can be executed in a single clock
cycle1.
 • More General-Purpose Registers: RISC processors typically have more general-purpose
registers1.
• Simple Addressing Modes: RISC uses simple addressing modes1.
• Pipeline Capability: RISC architectures are highly pipelined, allowing for faster instruction
processing1.

Advantages of RISC

• Faster Execution: Due to simpler instructions, RISC processors can execute instructions
faster1.
• Lower Power Consumption: RISC processors consume less power, making them ideal for
portable devices1.
• Easier to Design and Manufacture: The simpler architecture of RISC processors makes
them easier and potentially cheaper to design and produce3.

Disadvantages of RISC

• More Instructions Required: RISC processors require more instructions to perform

complex tasks1.
• Increased Memory Usage: More memory is needed to store the additional instructions1.
• Higher Compiler Complexity: The performance of RISC processors can depend heavily on
the compiler2.

CISC (Complex Instruction Set Computing)

CISC architecture aims to reduce the number of instructions per program by using complex
instructions that can perform multiple operations. The main characteristics of CISC include:

• Complex Instructions: CISC processors use a larger set of complex instructions1.

• Variable Instruction Length: Instructions in CISC can vary in length1.
• Multiple Clock Cycles: Instructions may take more than one clock cycle to execute1.
• Fewer General-Purpose Registers: CISC processors typically have fewer general-purpose
registers1.
• Complex Addressing Modes: CISC uses complex addressing modes1.

Advantages of CISC

• Reduced Code Size: CISC processors use complex instructions that can perform multiple
operations, reducing the amount of code needed1.
• More Memory Efficient: Fewer instructions are needed to perform complex tasks,
resulting in more memory-efficient code1.
• Widely Used: CISC processors have been in use for a longer time, so they have a larger
user base and more available software1.

Disadvantages of CISC

• Slower Execution: CISC processors take longer to execute instructions due to their
complexity1.
• More Complex Design: The complex instruction sets make CISC processors more
difficult to design and manufacture1.
• Higher Power Consumption: CISC processors consume more power due to their complex
instruction sets
What is Register Transfer Language?
Register Transfer Language (RTL) is a low-level language that is used to
describe the functioning of a digital circuit and, more specifically, the
transfer of information between registers. It provides how data moves
from one register to the other and how data is processed within the digital
system. Through RTL, there is a capability of creating abstraction levels
where high-level design descriptions can be created and easily linked to
low-level hardware implementation in designing, simulating, as well as
synthesizing digital circuits.
Key Concepts of Register Transfer Language(RTL)
• The meaningful descriptions are provided by RTL for the flow of
data between the registers of the hardware.
• It is applied to the representation of synchronous circuits:
circuits that are controlled by clock signals.
• Transfer of data and logical operations are described for the
register level.
• As mentioned earlier, RTL designs are documented most often
in hardware description languages, including Verilog or VHDL.
• It is an abstraction layer between high-order Application
Specific Integrated Circuits (ASICs) and physical devices.
Usage of RTL in Digital Design
• Proclaims the nature of hardware at the register-transfer level.
• Formerly utilized to model data flow while using registers.
• Assists in generation to gate level of designs.
• It allows simulation and validation of the relevant behaviors of
the hardware under design.
• Serves as the foundation for developing circuits within the
digital domain with the use of HDLs.

Micro-operations
The operation executed on the data store in registers are called micro-
operations. They are detailed low-level instructions used in some
designs to implement complex machine instructions.

Register Transfer
The information transformed from one register to another register is
represented in symbolic form by replacement operator is called Register
Transfer.

Replacement Operator
In the statement, R2 <- R1, <- acts as a replacement operator. This
statement defines the transfer of content of register R1 into register R2.
There are various methods of RTL
1. General way of representing a register is by the name of the
register enclosed in a rectangular box as shown in (a).

2. Register is numbered in a sequence of 0 to (n-1) as shown in

(b).

3. The numbering of bits in a register can be marked on the top of

the box as shown in (c).

4. A 16-bit register PC is divided into 2 parts- Bits (0 to 7) are

assigned with lower byte of 16-bit address and bits (8 to 15)
are assigned with higher bytes of 16-bit address as shown in
(d).

Instruction Set of a Basic Computer

The basic computer has 16-bit instruction register (IR) which can denote
either memory reference or register reference or input-output instruction.
Memory Reference Instructions
These instructions refer to memory address as an operand. The other
operand is always accumulator. Specifies 12-bit address, 3-bit opcode
(other than 111) and 1-bit addressing mode for direct and indirect

addressing.
Register Reference Instructions
These instructions perform operations on registers rather than memory
addresses. The IR(14 - 12) is 111 (differentiates it from memory
reference) and IR(15) is 0 (differentiates it from input/output
instructions). The rest 12 bits specify register operation.

Input/Output Instructions
These instructions are for communication between computer and outside
environment. The IR(14 - 12) is 111 (differentiates it from memory
reference) and IR(15) is 1 (differentiates it from register reference
instructions). The rest 12 bits specify I/O operation.

Essential Instructions in a Basic Computer

Program Counter (PC) is a key part of a computer, and its instructions
are the basic tasks a computer performs. These instructions are handled
by the computer's CPU (Central Processing Unit) and form the
foundation for more complex operations. Some examples of basic PC
instructions include:
Symbol Hexadecimal Code Description

AND 0xxx, 8xxx AND memory word to AC

ADD 1xxx, 9xxx Add memory word to AC

LDA 2xxx, Axxx Load memory word to AC

STA 3xxx, Bxxx Store AC content in memory

BUN 4xxx, Cxxx Branch Unconditionally

BSA 5xxx, Dxxx Branch and Save Return Address

ISZ 6xxx, Exxx Increment and skip if 0

CLA 7800 Clear AC

CLE 7400 Clear E(overflow bit)

CMA 7200 Complement AC

CME 7100 Complement E

CIR 7080 Circulate right AC and E

CIL 7040 Circulate left AC and E

INC 7020 Increment AC

Symbol Hexadecimal Code Description

SPA 7010 Skip next instruction if AC > 0

SNA 7008 Skip next instruction if AC < 0

SZA 7004 Skip next instruction if AC = 0

SZE 7002 Skip next instruction if E = 0

HLT 7001 Halt computer

INP F800 Input character to AC

OUT F400 Output character from AC

SKI F200 Skip on input flag

SKO F100 Skip on output flag

ION F080 Interrupt On

IOF F040 Interrupt Off

Note: In the given table,

1. AC (Accumulator): A register that temporarily stores data
during arithmetic or logic operations.
2. E (Carry/Overflow Bit): A single-bit register used for carry
operations or overflow detection in arithmetic calculations.
Example of Instruction Execution
• ADD Instruction:
Suppose the memory address 0001 contains the value 5, and the
AC currently holds 10. The ADD instruction fetches the value from
memory, adds it to the AC, and stores the result in the AC.
AC ← AC + M[0001]
Result: AC = 10 + 5 = 15
Uses of Basic Computer Instructions
 • Data manipulation: Basic computer instructions are used to
handle data in the computer system, including moving data
between memory and the CPU.
• Control flow: Basic instructions guide the flow of a program by
branching to different parts based on conditions.
• Input/output operations: Instructions are used to transfer data
between the computer and external devices like keyboards,
printers, or monitors.
• Program execution: They load programs into memory and
control their execution by moving data in and out of the
program.
• System maintenance: These instructions handle tasks like
memory allocation, interrupt management, error detection and
correction.
Issues of Basic Computer Instructions
• Complexity: Instructions can be hard to understand, especially
for beginners, making programming challenging.
• Limited functionality: Basic instructions can handle only simple
tasks. Programmers require to write extra code for complex
operations.
• Compatibility: Instructions may vary across different computer
systems This can require programmers to write separate code
for each system, which can be time-consuming and inefficient.
• Security: Basic computer instructions can be vulnerable to
security threats, such as buffer overflows and code injection
attacks.
• Maintenance: Basic computer instructions can be difficult to
maintain, particularly as systems become more complex and
code becomes more extensive. This can require significant
resources, time and effort.

# **Common Bus System**

## **Introduction to Common Bus System**

A **Common Bus System** is a structure used in computer

architecture to facilitate communication between different
components (such as registers, memory, and I/O devices) by providing
a shared pathway for data transfer. Instead of having separate
connections between each component, a single bus is used to
transmit data, addresses, and control signals efficiently.
The bus system helps in reducing complexity, cost, and physical
wiring while improving modularity and scalability in computer design.

---

## **Types of Buses**

There are three primary types of buses in a computer system:

### **1. Data Bus**

- **Function:** Carries actual data (instructions or operands) between

the CPU, memory, and I/O devices.

- **Bidirectional:** Data can flow in both directions (read/write).

- **Width:** Determines how many bits can be transferred at a time

(e.g., 8-bit, 16-bit, 32-bit, 64-bit).

### **2. Address Bus**

- **Function:** Carries memory addresses from the CPU to memory or

I/O devices to specify where data should be read from or written to.

- **Unidirectional:** Only the CPU sends addresses.

- **Width:** Determines the maximum addressable memory (e.g., 16-

bit address bus = 2¹⁶ = 64KB memory).

### **3. Control Bus**

- **Function:** Carries control signals that manage operations (e.g.,

read, write, interrupt, clock signals).

- **Bidirectional:** Some signals are input (e.g., interrupts), while

others are output (e.g., read/write signals).

- **Examples:**

- **Read (RD):** Indicates data is being read from memory.

- **Write (WR):** Indicates data is being written to memory.

- **Clock (CLK):** Synchronizes operations.

- **Interrupt Request (IRQ):** Requests CPU attention.

---

## **16-bit Common Bus System**

A **16-bit Common Bus System** means that the data bus can
transfer **16 bits (2 bytes)** at a time. The address bus width
determines the memory capacity, while the control bus ensures
proper coordination.

### **Data Movement Among Registers Using Bus**

In a typical CPU, registers (like **Accumulator, Program Counter,

General-Purpose Registers**) exchange data via the common bus.
Here's how data movement works:

1. **Selection of Source Register:**

- A **multiplexer (MUX)** selects which register will place its data

on the bus.

- Example: If **Register A** is selected, its 16-bit value is placed on

the data bus.

2. **Bus Transmission:**

- The selected data travels over the **data bus**.

3. **Selection of Destination Register:**

- The destination register (e.g., **Register B**) reads the data from
the bus.

- A **control signal** (e.g., `LOAD_B`) enables Register B to store

the incoming data.

4. **Control Signals:**

- The **Control Unit** generates signals like:

- `MUX_SELECT` (chooses source register).

- `LOAD` (enables destination register to accept data).

 - `READ/WRITE` (if memory is involved).

### **Example: Transfer from Register R1 to Register R2**

1. **Step 1:** MUX selects **R1** → Data from R1 is placed on the

bus.

2. **Step 2:** Control signal `LOAD_R2` is activated.

3. **Step 3:** **R2** reads the bus data and stores it.

### **Advantages of Common Bus System**

- **Simplified Design:** Fewer physical connections.

- **Cost-Effective:** Reduces wiring complexity.

- **Modularity:** Easy to add new components.

- **Efficient Data Transfer:** Centralized communication.

### **Disadvantages**

- **Bus Contention:** Only one device can transmit at a time (requires

arbitration).

- **Speed Limitation:** Bus bandwidth can become a bottleneck.

---

## **Conclusion**

The **Common Bus System** is a fundamental concept in computer

organization, enabling efficient data transfer between registers,
memory, and I/O devices using **Data, Address, and Control buses**.
In a **16-bit system**, 16-bit data transfers occur, with proper
coordination through control signals. This architecture simplifies
design while ensuring structured communication.

**[CO4: Understand the organization and architecture of computer

systems, including bus structures and register operations.]**