ARCHITECTURE OF COMPUTERS

Vistula University
 WHAT IS ARCHITECTURE OF COMPUTERS?

Computer architecture is a fundamental field in computer science and plays a crucial role in the
design and development of computer systems. Understanding computer architecture is essential
for computer scientists, engineers, and anyone working with computers, as it forms the
foundation for designing efficient and capable computing devices.
Overview

• Hardware Components
• Instruction Sets

• Memory Hierarchy

• Data Path and Control Unit

• Pipeline Processing

• Parallel Processing
• I/O System

• System Organization

• Performance and Efficiency

• Instruction Set Architecture (ISA)
Introduction to ARCHITECTURE OF COMPUTERS

• Hardware Components: Computer architecture deals with the physical components that
make up a computer system. These components include:

• Central Processing Unit (CPU): The CPU is the "brain" of the computer and is responsible for
executing instructions and performing calculations.
• Memory: This includes various types of memory, such as RAM (Random Access Memory) for
data storage during program execution and storage devices like hard drives or SSDs for long-
term data storage.

• Input and Output Devices: These include peripherals like keyboards, mice, monitors,
printers, and other devices used for interacting with the computer.
• Storage Devices: Hard drives, solid-state drives, and other storage media are part of
computer architecture. They are used to store data and programs.
Introduction to ARCHITECTURE OF COMPUTERS

• Instruction Sets: Computer architecture defines the set of instructions that a CPU can
understand and execute. This includes the format of instructions, their operation codes
(opcodes), and how they are decoded and executed by the CPU.

• Memory Hierarchy: Computer systems use a hierarchy of memory to store data. This
hierarchy includes registers, cache memory, main memory (RAM), and secondary storage.
Computer architecture determines how data is managed and accessed within this hierarchy.

• Data Path and Control Unit: The data path is responsible for performing arithmetic and logic
operations, while the control unit manages the execution of instructions and the flow of data
between different components.

• Pipeline Processing: Modern computer architectures often employ pipelining, a technique

that allows multiple instructions to be processed simultaneously in different stages of the
pipeline, improving overall performance.
Introduction to ARCHITECTURE OF COMPUTERS

• Parallel Processing: Computer architecture also addresses the concept of parallel processing,
where multiple processors work together to perform tasks simultaneously, increasing
computational power.

• I/O System: Computer architecture defines how input and output operations are managed,
including communication with external devices and peripherals.
• System Organization: It covers the overall organization of the computer system, including
how components are connected, how they communicate, and how they are controlled.

• Performance and Efficiency: Computer architecture aims to optimize the performance and
efficiency of a computer system. This includes considerations like clock speed, instruction
throughput, and power consumption.

• Instruction Set Architecture (ISA): ISA defines the interface between hardware and
software. It specifies how software can communicate with the hardware, including the
available instructions and their formats.
A simple computer model

A simple computer model typically consists

of a basic set of components that illustrate
the fundamental principles of computer
architecture. Below, I'll describe a
simplified computer model with its key
components:
A simple computer model

1. Central Processing Unit (CPU):

– The CPU is the brain of the computer, responsible for executing instructions. In a simple
model, you can represent the CPU as a black box that performs computations.

2. Memory:
– Memory is used to store data and instructions that the CPU needs to work with. In a
simple model, you can have two types of memory:

• RAM (Random Access Memory): This is used for storing data and program
instructions that the CPU is currently working with. It's volatile, meaning its
contents are lost when the computer is turned off.

• ROM (Read-Only Memory): This contains firmware or instructions that are

permanently stored and can't be modified by the user. It typically includes the
computer's boot instructions.
A simple computer model

3. Input and Output (I/O):

– You can represent input and output devices as part of your model. These devices allow
the computer to interact with the external world. Simple examples include a keyboard
and a display for input and output, respectively.
4. Control Unit (CU):

– The control unit manages the execution of instructions. It fetches instructions from
memory, decodes them, and controls the flow of data within the CPU. In your simple
model, you can show a basic control unit as a component responsible for instruction
execution.
5. Registers:

- Registers are small, high-speed storage locations within the CPU used for temporary data
storage during computations. In a basic model, you can represent a few essential registers,
such as the program counter (PC) to keep track of the current instruction, and general-
purpose registers for data manipulation.
A simple computer model

6. Instruction Set:
– Define a simple set of instructions that the CPU can execute. These instructions can
include basic arithmetic operations (add, subtract), data movement (load, store), and
control flow (jump, branch).
7. Bus:

– The bus is a communication pathway that allows data and instructions to move between
the CPU, memory, and I/O devices. In a simple model, you can represent a data bus and
an address bus for data transfer and addressing memory locations, respectively.
8. Clock:

– A clock signal is used to synchronize the operations of the CPU. It determines the speed
at which the CPU executes instructions.
A simple computer model

Here's a simplified flow of how this simple computer model works:

1. The CPU fetches an instruction from memory based on the program counter (PC).

2. The control unit decodes the instruction.

3. The CPU performs the operation specified by the instruction, which may involve reading data
from memory or registers, performing calculations, and storing results.
4. The program counter is updated to point to the next instruction.

5. This process continues until the program completes.

Flynn Taxonomy

The Flynn taxonomy, proposed by Michael

J. Flynn in 1966, is a classification system
for computer architectures based on the
number of instruction streams (single or
multiple) and the number of data streams
(single or multiple) that a computer can
process concurrently. Flynn's taxonomy
categorizes computers into four main
classes:
Flynn Taxonomy
Flynn taxonomy

1. SISD (Single Instruction, Single Data):

1. In an SISD architecture, there is a single processing unit (CPU) that executes a single
instruction stream on a single data stream at a time. This is the classic von Neumann
architecture found in most traditional computers. The CPU fetches instructions one at a
time from memory and operates on data sequentially. This is the simplest and most
common type of computer architecture.
Flynn taxonomy

SIMD (Single Instruction, Multiple Data):

1. In a SIMD architecture, there is a single control unit that issues the same instruction to
multiple processing elements, each of which operates on different elements of a single
data stream simultaneously. SIMD architectures are well-suited for tasks that involve
parallel processing of large datasets, such as graphics processing units (GPUs) used in
graphics rendering and scientific simulations.
Flynn taxonomy

MISD (Multiple Instruction, Single Data):

1. In a MISD architecture, multiple processing units execute different instructions on the

same data stream. This architecture is relatively rare in practice and is not commonly
used for general-purpose computing. It can be found in some specialized applications
where multiple algorithms are applied to the same data stream independently.

MISD architectures are not commonly found in practical computer systems. They are more
of a theoretical concept and are rarely implemented in real-world computing.
Flynn taxonomy

MIMD (Multiple Instruction, Multiple Data):

1. In a MIMD architecture, multiple processing units operate independently, each with its
own instruction stream and data stream. MIMD architectures are common in modern
multiprocessor and multithreaded systems. Each processor can execute different
programs or instructions on different data, making MIMD architectures highly flexible
and suitable for a wide range of parallel computing tasks. high-performance computing
HPC
Harvard and Princeton architecture

The Harvard architecture and Princeton architecture are two fundamental computer
architecture designs that differ in how they handle the storage and access of
instructions and data. Here's an overview of each architecture
 Separate Instruction and Data Memory:

• In the Harvard architecture, there are separate memory

units for instructions (instruction memory) and data
(data memory). This means that instructions and data
are stored in physically distinct memory modules.

Parallel Instruction Fetch and Data

Access:
• Because instructions and data have separate memory
paths, the Harvard architecture can fetch instructions
and access data simultaneously. This parallelism can
lead to faster program execution in some cases.

Common Use Cases:

Harvard Architecture: • Harvard architectures are often found in embedded

systems, microcontrollers, and some specialized
processors where high throughput and predictable
performance are essential. They are also used in digital
signal processors (DSPs) and certain types of FPGA
(Field-Programmable Gate Array) designs.

Advantages:

• Reduced risk of instruction and data conflicts.

• Efficient for real-time and control-oriented applications.
• Can provide a high level of performance for specific
tasks.

Disadvantages:

• Typically more complex to design and implement.

• May require more hardware components.
 Unified Memory for Instructions and Data:

• In the Princeton architecture, instructions and data share a

common memory. Both program instructions and data are
stored in the same memory unit.

Single Memory Bus:

• Because both instructions and data share the same memory,

there is usually a single memory bus through which
instructions and data are fetched. This means that the CPU
alternates between fetching instructions and accessing data.

Common Use Cases:

• The Princeton architecture is the foundation for most general-

Princeton Architecture (also known as purpose computers, including personal computers and
Von Neumann Architecture): servers. It is highly flexible and versatile, making it suitable for
a wide range of applications.

Advantages:

• Simplicity in design compared to Harvard architecture.

• Versatility for a wide range of computing tasks.
• Common and widely adopted.

Disadvantages:

• Potential for instruction and data conflicts when accessing

memory.
• Limited ability to perform simultaneous instruction fetch and
data access.
Machine, assembly and high-level programming languages.
Machine, assembly and high-level programming languages.

Machine language, assembly language,

and high-level programming languages are
three distinct levels of programming
languages used for writing computer
programs. Each level has its own
characteristics and serves different
purposes in software development. Let's
explore each of them
Machine Language:
• Lowest Level: Machine language is the lowest-level programming language that a computer
understands. It consists of binary code (0s and 1s) and is specific to the architecture of the
computer's CPU.
• Directly Executable: Machine code is directly executed by the computer's hardware. Each
instruction corresponds to a specific operation the CPU can perform, such as arithmetic, data
movement, or control flow.

• Difficult for Programmers: Writing programs in machine language is highly labor-intensive

and error-prone. Programmers need to have an in-depth understanding of the computer's
architecture to write even simple programs.

• Platform-Specific: Machine code is not portable; it is tied to a particular CPU architecture.

Programs written in machine code won't work on a different CPU without modification.
• Examples: Binary code, which consists of sequences of 0s and 1s, is an example of machine
language.
Assembly Language:
• Low-Level Human-Readable Language: Assembly language is a low-level, human-readable
programming language that serves as a bridge between machine language and higher-level
languages.
• Symbolic Representation: Assembly language uses symbolic names (mnemonics) to
represent machine instructions, making it easier for programmers to write and understand
code.

• Assembler: Programs written in assembly language must be translated into machine code
using an assembler, which converts the mnemonics into the corresponding binary
instructions.

• Platform-Specific: Like machine language, assembly code is platform-specific and tied to a

particular CPU architecture.
• Examples: x86 assembly language, ARM assembly language, and MIPS assembly language are
examples of assembly languages used on different CPU architectures.
High-Level Programming Languages:
• Abstraction: High-level programming languages are designed to be more abstract and user-
friendly than machine and assembly languages. They use English-like syntax and provide a
higher level of abstraction from the hardware.
• Portability: Programs written in high-level languages are generally portable across different
platforms, as long as there is a compatible compiler or interpreter for the target platform.

• Productivity: High-level languages make programming more accessible and efficient. They
offer built-in functions and data structures that simplify common tasks.
• Examples: Some popular high-level programming languages include Python, Java, C++,
JavaScript, Ruby, and C#. These languages are used for a wide range of software
development tasks, from web development to scientific computing.
Microprocessor families

Microprocessors are at the heart of

modern computing devices, ranging from
personal computers and smartphones to
embedded systems and IoT devices.
Various microprocessor families have been
developed over the years, each with its
own set of features, capabilities, and
applications. Here are some prominent
microprocessor families
Microprocessor families

Intel x86 Family:

• The Intel x86 family includes a range of microprocessors that have been dominant in
personal computers and servers for several decades. The family's architecture includes
processors like the Intel 8086, 80286, 80386, Pentium, Core i-series, and many more.

• x86 processors are known for their compatibility, power, and performance. They run
operating systems like Windows and Linux and are widely used in desktops, laptops, and
servers.

AMD x86 Family:

• AMD (Advanced Micro Devices) also produces x86-compatible processors that compete with
Intel's offerings. AMD's processors, such as the Ryzen and EPYC series, are used in desktops,
laptops, and servers.
Microprocessor families

ARM Family:

• ARM (Advanced RISC Machines) processors are known for their energy efficiency and are
commonly found in mobile devices, embedded systems, and IoT devices. ARM architecture
licenses its designs to various manufacturers, including Apple, Qualcomm, and Samsung.

• The ARM Cortex-A series is used in smartphones and tablets, while the Cortex-M and Cortex-
R series are designed for embedded systems and real-time applications.

MIPS Family:

• MIPS (Microprocessor without Interlocked Pipeline Stages) processors have been used in
various applications, including networking equipment, embedded systems, and gaming
consoles. They are known for their simplicity and efficiency.

• MIPS processors have been used in products like Cisco routers and early versions of Sony's
PlayStation gaming consoles.
Microprocessor families

PowerPC Family:

• The PowerPC architecture was developed by a consortium of companies, including IBM,

Motorola, and Apple. PowerPC processors have been used in Apple Macintosh computers
(before the switch to Intel processors), IBM workstations, and some gaming consoles like the
Nintendo GameCube.

SPARC Family:

• SPARC (Scalable Processor Architecture) processors are designed by Oracle (formerly Sun
Microsystems) and have been used in servers and high-performance computing systems.
They are known for their reliability and scalability.
Microprocessor families

RISC-V Family:

– RISC-V is an open-source, modular instruction set architecture (ISA) that is gaining

popularity. It is designed to be highly customizable and is used in a variety of
applications, from embedded systems to supercomputers. Many companies and
organizations have adopted RISC-V to develop custom processors.
Zilog Z80 Family:

– The Zilog Z80 is a classic 8-bit microprocessor that gained popularity in the early days of
personal computing. It was used in home computers like the ZX Spectrum and some
early arcade machines.
Summary

1. Computer Architecture:

Computer architecture refers to the design and organization of a computer system's

components, including the CPU, memory, input/output devices, and more. It encompasses
both hardware and software aspects.

2. Instruction Set Architecture (ISA):

ISA defines the interface between hardware and software, specifying the set of instructions
a CPU can execute, instruction formats, addressing modes, data types, and more.

3. Flynn's Taxonomy:

Flynn's taxonomy classifies computer architectures into four categories based on the
concurrency of instruction and data streams: SISD (Single Instruction, Single Data), SIMD
(Single Instruction, Multiple Data), MISD (Multiple Instruction, Single Data), and MIMD
(Multiple Instruction, Multiple Data).
Summary

4. Harvard Architecture vs. Princeton Architecture:

1. The Harvard architecture separates instruction and data memory, allowing for parallel
instruction fetching and data access. It's common in embedded systems.

2. The Princeton (Von Neumann) architecture uses a unified memory for both instructions
and data, with a single memory bus. It's the basis for most general-purpose computers.

5. Programming Languages:

1. Machine language consists of binary code and is the lowest-level language directly
understood by computers.

2. Assembly language is a low-level human-readable language that uses mnemonics to

represent machine instructions.

3. High-level programming languages are more abstract and user-friendly, offering

portability and productivity. Examples include Python, Java, and C++.
Summary

Microprocessor Families:

• Microprocessors are central processing units (CPUs) found in various computing devices.

• Prominent microprocessor families include:

• Intel x86 and AMD x86 for personal computers and servers.
• ARM for mobile devices and embedded systems.

• MIPS for networking equipment and gaming consoles.

• PowerPC for IBM workstations and older Macintosh computers.

• SPARC for servers.

• RISC-V, an open-source ISA.

• Zilog Z80, a classic 8-bit CPU.
End of Lecture