Introduction to Computer Architecture and Organization

Overview

Computers have evolved from large, power-hungry machines to compact and intelligent systems. To understand how computers actually work—from hardware circuits to executing instructions—we need to study Computer Architecture and Organisation.

This subject forms the foundation of computer science, connecting hardware design principles with how software uses them. It covers concepts like:

CPU design and control units
Memory and instruction formats
Addressing techniques
Generations of computing technology

Computer Architecture – Definition and Meaning

Computer Architecture refers to the conceptual structure and functional behaviour of a computer system as seen by the programmer. It defines what a computer can do and how it does it, focusing on the system's logical aspects rather than its physical design.

Key Aspects of Computer Architecture:

Instruction Set Architecture (ISA): Specifies the instructions a CPU can execute (e.g., addition, branching).
Data Types and Formats: Defines how data (numbers, characters, etc.) are represented and manipulated.
Registers and Memory Organisation: Describes data storage hierarchy.
I/O Mechanisms: How computers communicate with the external world.
Performance and Control: How efficiently resources are managed and controlled.

In short, architecture focuses on programmer-visible attributes, shaping how the software interacts with hardware.

Computer Organisation – Definition and Focus

Computer Organisation deals with the operational structure and physical implementation of a computer. It focuses on internal hardware components, signal processing, and data transfer mechanisms.

Key Components Covered:

Arithmetic Logic Unit (ALU)
Control Unit
Memory (RAM, Cache, ROM)
Input and Output Units
Communication Buses

While architecture is about concepts, organisation is about actual implementation—the circuits, registers, and control signals that make everything work.

Simplified Example

Architecture: Defines that the CPU supports “Add” and “Multiply.”
Organisation: Describes whether these operations are performed using a separate multiply circuit or repeated additions internally.

Difference between Computer Architecture and Computer Organisation

Aspect	Computer Architecture	Computer Organization
Focus	Logical design and instruction set	Physical structure and hardware implementation
Concerned with	Functionality and capabilities	Data flow and control signals
Example	Instruction formats, addressing modes	Memory hierarchy, I/O channels
Viewpoint	Programmer’s perspective	Hardware engineer’s perspective
Impact	Defines how software is written	Defines system performance and speed

Both concepts are interlinked — you can think of architecture as a blueprint and organisation as construction details.

Evolution of Computer Systems

Computer systems have undergone tremendous evolution. Each generation introduced new technology, components, and efficiency improvements.

First Generation Computers (1940–1956)

Technology Used: Vacuum Tubes
Languages Used: Machine and Assembly Languages
Storage Device: Magnetic drums
Characteristics:

Large, expensive, consumes high power
Slow processing speed
Huge heat generation due to vacuum tubes

Examples:
ENIAC, UNIVAC I, EDVAC, EDSAC

Impact:
Introduced electronic digital computation, though limited to scientific and defence applications.

Second Generation Computers (1956–1963)

Technology Used: Transistors replaced vacuum tubes.
Languages: Assembly and Early High-Level Languages (COBOL, FORTRAN).
Storage Device: Magnetic core memory.
Characteristics:

Faster and smaller
More reliable, less heat generation
Easier to maintain
Batch processing introduced

Examples: IBM 1401, IBM 7090

Third Generation Computers (1964–1971)

Technology Used: Integrated Circuits (ICs) replaced transistors.
Memory: Magnetic storage and secondary devices.
Features:

Multiprogramming and time-sharing systems
Better input/output management
Portable high-level programming

Examples: IBM 360 series, Honeywell 6000, PDP-8
Impact: Beginning of general-purpose and commercial computing.

Fourth Generation Computers (1971–Present)

Technology Used: Microprocessors and VLSI (Very Large Scale Integration).
Memory: Semiconductor memory chips
Characteristics:

Portable and affordable personal computers
GUI-based systems
Networking and communication features are integrated

Examples: Apple II, IBM PC, Intel 8085, 8086 processors

Impact:
Computer revolution at the consumer level; rise of personal and business computing.

Fifth Generation Computers (Present and Beyond)

Technology Used: AI, Fuzzy Logic, Parallel Processing, Quantum Computing
Features:

Natural language processing
High-speed communication systems
Cloud and distributed computing
Extremely low energy consumption

Examples: AI-enabled supercomputers, IBM Watson, Google Tensor systems

Impact:
Focus on intelligence and automation rather than just speed or size.

Basic Structure of a Computer System

A computer performs five essential functions regardless of size or design:

Input: Accepts data and instructions (keyboard, scanner, sensors).
Processing: Executes data operations (CPU).
Storage: Temporarily or permanently holds data.
Output: Displays processed results (monitor, printer).
Control: Manages all components through the control unit.

Block Diagram of a Computer System

Main Components:

Input Unit: Converts data from human format into machine-readable form.
Memory Unit: Stores data, instructions, and results.
Arithmetic Logic Unit (ALU): Performs calculations and logical comparisons.
Control Unit (CU): Directs all operations of the CPU.
Output Unit: Converts machine data into human-readable form.

These parts communicate through the system bus—a network of data, address, and control lines.

Structure and Function of a Computer

Every computer system operates through the Input-Process-Output cycle with stages such as:

Fetch: Load instruction from memory.
Decode: Determine required operation.
Execute: Perform the task in ALU.
Store: Write back results to memory.

This cycle is called the Instruction Cycle.

Structure of Computer System (Top Level)

At the top level, a computer system includes:

Central Processing Unit (CPU): The core computing unit.
Main Memory: Temporary data and instruction storage.
Input/Output Subsystem: Peripheral communication interface.
System Interconnect: Mechanism for communication among components.

This structural hierarchy ensures modularity and efficiency in design.

Structure of the CPU

The Central Processing Unit acts as the brain of the computer. It executes program instructions, performs arithmetic and logic operations, and controls overall activities.

CPU Components:

Arithmetic Logic Unit (ALU):
- Executes addition, subtraction, and logical comparisons.
- Contains accumulators, temporary registers, and status flags.
- Example: ALU checks if two numbers are equal or greater than one another.
Control Unit (CU):
- Determines execution sequence.
- Sends and receives control signals to manage memory, ALU, and I/O devices.
- Example: After the “ADD” instruction, CU fetches operands and directs ALU.
Registers:
- Small high-speed memory units are inside the CPU.
- Types: Accumulator (AC), Program Counter (PC), Memory Address Register (MAR), Memory Buffer Register (MBR).
Cache Memory:
- Temporary high-speed memory that stores frequently used instructions.
- Reduces delay in accessing main memory.

Structure of Control Unit

The Control Unit (CU) is like the nervous system of a computer. It fetches, decodes, and executes instructions step-by-step.

Components of the Control Unit:

Instruction Register (IR): Holds the instruction currently being executed.
Program Counter (PC): Keeps track of the next instruction address.
Instruction Decoder: Interprets the opcode and sends control signals.
Timing and Control Circuits: Synchronise signals and manage timing.

The CU ensures operations occur in the correct sequence and under the required timings.

Examples of Computer Families

1. IBM Series

IBM 1401, IBM 360, and IBM 370 families — early leaders in the mainframe market.
Introduced the concept of backward compatibility.

2. Intel Family

8085, 8086 → Pentium Series → Core i3/i5/i7 → Modern Intel Core Ultra
Dominates personal computing and server processors.

3. AMD Family

Known for performance-to-cost ratio in gaming and high-computing systems.

4. Apple Family

Macintosh systems and M-series chips are optimised for energy efficiency.

5. ARM Processors

Used in mobile and IoT devices for low power consumption.

Significance: Families show continuity in design philosophy while improving speed, efficiency, and compatibility over generations.

Future Trends in Computer Architecture

As technology advances, future trends in computer architecture focus on speed, intelligence, and energy efficiency.

Key Trends:

Quantum Computing: Based on qubits rather than bits — exponentially faster for complex problems.
Neural & AI-integrated Chips: Hardware optimised for deep learning operations.
Parallel and Distributed Processing: Enhances performance using multiple cores and GPUs.
Optical Computing: Uses photons instead of electrons for ultra-fast data transfer.
Green Computing: Focuses on low power consumption and sustainable materials.
Cloud Integration: Hardware designed for virtualisation and high network throughput.

These innovations represent the ongoing shift from traditional computing to intelligent computing ecosystems.

Instruction and Instruction Format

What is an Instruction?

An instruction is a binary command that tells the CPU what operation to perform and on which data.

Basic Components:

Operation Code (Opcode): Specifies the operation.
Operands: Specify data or memory locations.
Addressing Mode: Indicates how operand addresses are located.

Types of Instructions:

Data Transfer: Move data between memory and registers (LOAD, STORE).
Arithmetic: Perform mathematical operations (ADD, SUB, MUL, DIV).
Logical: Perform bitwise operations (AND, OR, NOT).
Branching: Alter program sequence (JUMP, CALL).
I/O Instructions: Input and output operations (READ, WRITE).

Instruction Formats

An instruction format defines how instruction bits are divided into fields.

Typical Fields:

Opcode Field: 6–8 bits for defining operation.
Address Field: Indicates the operand’s address.
Mode Field: Optional, defines the addressing rule.

Common Instruction Formats:

Zero Address Format: Used in stack-based architectures.
One Address Format: Uses an accumulator for all operations.
Two Address Format: Common in general-purpose CPUs.
Three Address Format: Enables complex operations, reduces instruction count.

Example:

ADD R1, R2, R3 // R1 = R2 + R3

Instruction Set Design Issues

Designing an instruction set involves trade-offs between simplicity and efficiency.

Major Design Considerations:

Instruction Length: Shorter instructions = faster fetching, but limited address space.
Number of Operands: One, two, or three operand formats affect capacity.
Addressing Modes: Flexibility for handling data efficiently.
Instruction Types: Balance between arithmetic, logical, and control operations.
Encoding: Compact binary representation improves memory usage.

Example:
RISC (Reduced Instruction Set Computing) favours a few simple instructions, while CISC (Complex Instruction Set Computing) supports many multi-step instructions.

A Milestone in Computer Organisation – IAS Computer

The IAS Computer, developed in 1946 at the Institute for Advanced Study (Princeton) by John von Neumann, marked a revolution. It introduced the concept of stored program architecture, which all modern computers follow.

Structure of the IAS Computer

Main Components:

Memory Unit: Holds both instructions and data in binary form.
Arithmetic Logic Unit (ALU): Executes arithmetic and logic operations.
Control Unit (CU): Fetches instructions and directs operations.
Input and Output System: Manages data entry and output results.

Word Length: 40 bits
Memory Capacity: 1,000 words approximately

The IAS design grew into what’s now known as the Von Neumann Architecture, still used in nearly every processor today.

Instruction Format of the IAS Computer

Each 40-bit word could store two 20-bit instructions.
Each instruction comprised:

Opcode (8 bits): Specifies the operation.
Address (12 bits): Specifies memory location.

Representation:

| Opcode | Address | Opcode | Address |

Example:
If the left instruction is ADD 007, and the right one is SUB 008, both fit in a single 40-bit memory word.

Expanded Structure of the IAS Computer

The IAS Computer used several registers to manage its operation:

Register	Full Form	Purpose
MBR	Memory Buffer Register	Temporarily holds data during transfer
MAR	Memory Address Register	Holds the address of data or instruction
IBR	Instruction Buffer Register	Holds right-hand instruction temporarily
PC	Program Counter	Holds the address of the next instruction
AC	Accumulator	Stores intermediate arithmetic results
MQ	Multiplier-Quotient Register	Used for multiplication/division

This structure defined the Fetch → Decode → Execute process still used in CPUs today.

IAS Instructions

The IAS computer supported the following fundamental instruction groups:

Arithmetic Operations: ADD, SUB, MUL, DIV.
Load/Store Operations: LOAD M(X), STORE M(X).
Control Transfers: JUMP, CONDITIONAL JUMP.
Input/Output: READ, WRITE.

Example Operation:
LOAD M(100) → Load value from address 100 into the accumulator.
ADD M(101) → Add value from address 101 to the accumulator.

Addressing Modes

Definition

An addressing mode determines how the CPU finds the operand (the data to be processed) for an instruction.

Importance

Different addressing modes offer flexibility and efficient program execution by optimising memory access.

Common Addressing Modes:

Immediate Addressing
- Operand is embedded within the instruction.
- Example: MOV A, #10 – Loads value 10 directly into A.
Direct Addressing
- Instruction specifies the actual address of the operand.
- Example: MOV A, [1000] – Load from memory address 1000.
Indirect Addressing
- The address field holds the address of another memory location containing data.
- Example: Pointer-based access.
Register Addressing
- Operand stored in CPU register.
- Example: ADD R1, R2.
Register Indirect Addressing
- The register contains the address of the operand in memory.
- Example: MOV A, @R1.
Indexed Addressing
- Base address plus index register for arrays.
- Example: MOV A, [BASE + i].
Relative Addressing
- Address specified relative to the current instruction’s address (used in jumps).

Comparison of Addressing Techniques

Mode	Speed	Flexibility	Typical Use
Immediate	Fast	Low	Constants
Direct	Medium	Low	Fixed addresses
Indirect	Slow	High	Dynamic data structures
Register	Very Fast	Moderate	Temporary operations
Indexed	Moderate	High	Arrays, loops

Key Takeaways

Computer Architecture defines system capabilities; organisation explains how they’re implemented.
The five generations of computers highlight progress from vacuum tubes to AI-driven devices.
The CPU remains the brain of computers—its efficiency defines system performance.
The IAS Computer was the foundational model for modern stored program architecture.
Instruction formats and addressing modes allow CPUs to interpret, locate, and manipulate data effectively.
Future computing trends focus on AI integration, quantum processing, and energy efficiency.

Introduction to Computer Architecture and Organization – Complete Notes (BCA Level)