UNIVERSITY OF YAOUNDÉ I

FACULTY OF SCIENCES
DEPARTMENT OF COMPUTER SCIENCES
ICT4D L3

Performance Issues in
Computer Organization

Author:
CHE SWANSEN S.

November 25, 2024

Contents
1 Introduction to Performance Issues 3

2 Designing for Performance 3

2.1 Microprocessor Speed . . . . . . . . . . . . . . . . . . . . . 3
2.2 Performance Balance . . . . . . . . . . . . . . . . . . . . . 4
2.3 Improvements in Chip Organization and Architecture . . . 4

3 Key Measures of Performance 4

3.1 Cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.2 Clock Speed . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.3 Instruction Execution Rate . . . . . . . . . . . . . . . . . . 6
3.4 Word Length . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.5 Data Bus Width . . . . . . . . . . . . . . . . . . . . . . . 6
3.6 Address Bus Width . . . . . . . . . . . . . . . . . . . . . . 7
3.7 Parallel Processing . . . . . . . . . . . . . . . . . . . . . . 7
3.8 Instruction Pipelining . . . . . . . . . . . . . . . . . . . . . 7

4 Multicore and Parallel Architectures 8

4.1 Multicore Processors . . . . . . . . . . . . . . . . . . . . . 8
4.2 Many Integrated Cores (MICs) . . . . . . . . . . . . . . . 9
4.3 General-Purpose GPUs (GPGPUs) . . . . . . . . . . . . . 9

5 Performance Laws 10
5.1 Amdahl’s Law . . . . . . . . . . . . . . . . . . . . . . . . . 10
5.2 Little’s Law . . . . . . . . . . . . . . . . . . . . . . . . . . 10

6 Benchmarking 10
6.1 What is Benchmarking? . . . . . . . . . . . . . . . . . . . 10
6.2 Why is Benchmarking Important? . . . . . . . . . . . . . . 11
6.3 Types of Benchmarks . . . . . . . . . . . . . . . . . . . . . 11
6.3.1 Synthetic Benchmarks . . . . . . . . . . . . . . . . 11
6.3.2 Real-World Benchmarks . . . . . . . . . . . . . . . 12
6.3.3 Component-Specific Benchmarks . . . . . . . . . . 12
6.4 Key Benchmarking Metrics . . . . . . . . . . . . . . . . . . 12
6.5 Benchmarking Tools and Suites . . . . . . . . . . . . . . . 13
6.6 Challenges in Benchmarking . . . . . . . . . . . . . . . . . 13
6.7 SPEC Benchmarks: An Example . . . . . . . . . . . . . . 13
6.8 Calculating the Mean . . . . . . . . . . . . . . . . . . . . . 13
6.8.1 Arithmetic Mean . . . . . . . . . . . . . . . . . . . 14
6.8.2 Harmonic Mean . . . . . . . . . . . . . . . . . . . . 14

1
 6.8.3 Geometric Mean . . . . . . . . . . . . . . . . . . . 15
6.8.4 Comparison of Means . . . . . . . . . . . . . . . . . 15

7 Exercises 16
7.1 Basic Measures of Computer Performance . . . . . . . . . 16
7.2 Factors Affecting Processor Performance . . . . . . . . . . 16
7.3 Instruction Pipelining . . . . . . . . . . . . . . . . . . . . . 17
7.4 Benchmarking and Performance Evaluation . . . . . . . . . 17
7.5 Advanced Topics: Amdahl’s and Little’s Laws . . . . . . . 17
7.6 Designing for Performance . . . . . . . . . . . . . . . . . . 18
7.7 Comprehensive Problem . . . . . . . . . . . . . . . . . . . 18

2
1 Introduction to Performance Issues
Computer architecture plays a crucial role in determining the performance
of computing systems. Performance issues in computer architecture in-
volve understanding the various factors that impact the speed, efficiency,
and cost of executing programs. These factors range from the hardware
design, such as processor architecture and memory organization, to the
software design, including algorithms and compilers. Understanding these
performance issues is essential not only for designing efficient systems but
also for evaluating the trade-offs involved in improving specific aspects of
performance.
The key question in performance analysis is: *How can we design sys-
tems that perform tasks faster and more efficiently while balancing power
consumption, cost, and scalability?* Addressing this question requires a
deep dive into metrics, benchmarks, and architectural innovations that
optimize system performance.

2 Designing for Performance

Designing for performance involves a combination of architectural innova-
tions and optimization strategies to meet the demands of modern comput-
ing tasks. The following subsections break down some key considerations
in performance-oriented design:

2.1 Microprocessor Speed

Microprocessor speed, measured in terms of clock frequency (GHz), repre-
sents the number of clock cycles a processor can complete in one second.
Early improvements in computer performance were heavily driven by in-
creases in clock speed. For example, in the early 2000s, processors reached
speeds of up to 3 GHz, providing significant gains in performance.
However, increasing clock speed has limitations. Higher clock speeds
lead to increased power consumption and heat generation, which are major
challenges for modern microprocessors. Consequently, the focus has shifted
to architectural improvements, such as pipelining, branch prediction, and
multicore processors, to achieve better performance without solely relying
on clock speed.

3
2.2 Performance Balance
Achieving performance balance is critical because improving one aspect
of the system often exposes bottlenecks in another. For example, increas-
ing processor speed without addressing memory access delays can result
in the processor waiting for data. This issue, commonly referred to as
the ”memory wall,” demonstrates the need to balance processor speed,
memory bandwidth, and I/O performance.
One approach to achieving balance is through the use of caches. Caches
reduce the time required to access frequently used data, bridging the gap
between processor speed and memory latency. Another example is opti-
mizing the instruction set architecture (ISA) to ensure instructions can be
executed efficiently by the processor.

2.3 Improvements in Chip Organization and Archi-

tecture
Modern processors incorporate various techniques to improve performance
at the chip level:
• Out-of-order execution: Allows instructions to be executed as
soon as their operands are available, rather than strictly following
program order.
• Superscalar architecture: Enables multiple instructions to be ex-
ecuted simultaneously by providing multiple execution units.
• Advanced cache hierarchies: Multi-level caches (L1, L2, and L3)
minimize memory latency.
• Energy-efficient designs: Techniques such as dynamic voltage
scaling reduce power consumption without compromising performance.

3 Key Measures of Performance

Understanding and measuring performance requires specific metrics and
models. These metrics allow us to evaluate and compare systems objec-
tively.

3.1 Cache
The cache is a small, high-speed memory located within or close to the
processor. Its purpose is to store frequently accessed data and instructions,

4
reducing the time the processor spends fetching data from the slower main
memory (RAM). Caches are organized hierarchically into levels:
• L1 Cache: The smallest and fastest cache is located directly on the
processor core. It stores critical data and instructions.
• L2 Cache: Larger and slower than L1, shared among cores in some
architectures.
• L3 Cache: Even larger and slower, typically shared across all cores
in a multicore processor.

Figure 1: Cache Memory.

The effectiveness of the cache is measured by the cache hit rate, which
is the percentage of memory accesses that the cache can serve. Higher
hit rates improve processor performance significantly. For example, in
a gaming application, a high hit rate reduces the latency in accessing
textures or rendering data.

3.2 Clock Speed

Clock speed is one of the simplest measures of a processor’s performance.
For example, a 3 GHz processor completes 3 billion clock cycles per sec-
ond. While higher clock speeds often indicate faster processors, they are

5
not always indicative of real-world performance. Factors like the number
of instructions executed per cycle (IPC) and memory access delays also
significantly impact overall performance.

3.3 Instruction Execution Rate

The instruction execution rate, measured as the number of instructions
executed per second, provides a more comprehensive view of performance.
It can be calculated using the formula:
Instructions × CPI
Execution Time =
Clock Frequency
Here, CPI (Cycles Per Instruction) reflects the average number of cycles
required to execute an instruction. A lower CPI indicates a more efficient
processor. For example, if a program executes 109 instructions with a CPI
of 1.2 on a 3 GHz processor, the execution time is:
109 × 1.2
Execution Time = = 0.4 seconds.
3 × 109

3.4 Word Length

Word length refers to the number of bits a processor can process at a
time. Common word lengths include 32-bit and 64-bit architectures. A 64-
bit processor can handle larger integers and memory addresses, enabling
it to process data more efficiently in applications that require extensive
calculations or large datasets.
For example, a 32-bit processor has a maximum addressable memory
space of 232 bytes (4 GB), while a 64-bit processor can address up to 264
bytes. This extended memory addressing is crucial for modern applications
like big data processing and 3D modelling.

3.5 Data Bus Width

The data bus width determines the amount of data the processor can
transfer to and from memory in a single operation. For example, a 32-bit
data bus can transfer 4 bytes of data at a time, while a 64-bit data bus
can transfer 8 bytes.
Wider data buses improve performance by allowing the processor to
access and manipulate larger chunks of data simultaneously. This is par-
ticularly beneficial in applications involving large datasets, such as video
editing or numerical simulations.

6
3.6 Address Bus Width
The address bus width defines the maximum amount of memory the pro-
cessor can address. For instance:

• A 32-bit address bus can address 232 memory locations (4 GB).

• A 64-bit address bus can address 264 memory locations, which trans-
lates to 16 exabytes.

Systems with wider address buses are capable of addressing signifi-

cantly larger amounts of memory, which is essential for modern applica-
tions like databases, virtualization, and high-performance computing.

3.7 Parallel Processing

Parallel processing involves dividing a task into smaller sub-tasks that
can be executed simultaneously by multiple cores or processors. Parallel
processing significantly reduces execution times for tasks that can be split,
such as rendering graphics, scientific computations, and training machine
learning models.
For example, rendering a 3D animation involves calculating lighting,
shading, and textures for millions of pixels. By dividing the task across
multiple cores or GPUs, rendering time is dramatically reduced.
Parallel processing techniques include:

• Task parallelism: Different tasks are executed in parallel (e.g.,

downloading a file while running a program).

• Data parallelism: The same operation is applied to different chunks

of data in parallel (e.g., matrix multiplication in linear algebra).

3.8 Instruction Pipelining

Instruction pipelining is a technique used to improve processor throughput
by overlapping the execution of multiple instructions. The pipeline is
divided into stages, such as fetching, decoding, executing, and writing
results. While one instruction is being executed, the next can be decoded,
and another fetched, resulting in multiple instructions being processed
simultaneously.
A classic example is a laundry analogy:

• Washing, drying, and folding clothes represent the stages of a pipeline.

7
 Figure 2: Instruction Pipelining

• Instead of waiting for one batch of clothes to be fully washed, dried,

and folded, the pipeline allows new clothes to enter the washer while
the first batch is being dried.
Pipelining improves overall throughput but introduces challenges such
as hazards:
• Data hazards: When instructions depend on the results of previous
instructions.
• Control hazards: Occur when the pipeline cannot determine the
next instruction due to branching.
Modern processors use techniques like branch prediction and out-of-
order execution to minimize these hazards and maximize pipeline effi-
ciency.

4 Multicore and Parallel Architectures

4.1 Multicore Processors
Multicore processors integrate multiple processing cores on a single chip,
enabling true parallelism. This design allows multiple threads or processes
to execute concurrently, improving system throughput and responsiveness.
For example, a quad-core processor can execute four independent threads
simultaneously.

8
 However, software must be optimized for multicore systems to realize
their full potential. Tasks that cannot be parallelized, such as sequential
code, may not benefit significantly from additional cores.

Figure 3: Quad-core Processor.

4.2 Many Integrated Cores (MICs)

MICs are specialized processors designed for massively parallel workloads.
They often contain dozens or hundreds of simpler cores optimized for tasks
like scientific computing and AI. For example, the Intel Xeon Phi processor
was widely used in high-performance computing (HPC) applications.

4.3 General-Purpose GPUs (GPGPUs)

GPGPUs extend the functionality of traditional graphics processing units
to handle general-purpose parallel computing tasks. CUDA, an NVIDIA
programming model, enables developers to leverage GPU parallelism for
tasks like machine learning and data analytics. For example, training a
neural network using TensorFlow on a GPU can be 10-50 times faster than
on a CPU.

9
5 Performance Laws
5.1 Amdahl’s Law
Amdahl’s Law states that the maximum speedup of a system is limited by
the fraction of the task that cannot be parallelized. It is given by:
1
Speedup = P
(1 − P ) + N

For example, if 75% of a task is parallelizable (P = 0.75) and we use 8

processors (N = 8):
1
Speedup = 0.75 ≈ 3.6.
(1 − 0.75) + 8

This demonstrates diminishing returns as N increases.

5.2 Little’s Law

Little’s Law describes the relationship between the average number of
items in a system (L), the arrival rate (λ), and the average time spent
in the system (W ):
L = λW
For example, if a server processes 10 requests per second (λ = 10) and
each request takes 0.2 seconds (W = 0.2):

L = 10 × 0.2 = 2 requests.

6 Benchmarking
Benchmarking is the process of evaluating the performance of a computer
system, component, or software application by running a set of standard
tests. These tests are designed to measure key performance metrics, such
as speed, throughput, and efficiency. Benchmarking allows comparisons
between systems, identifies performance bottlenecks, and ensures that a
system meets the required performance standards.

6.1 What is Benchmarking?

Benchmarking involves running a series of predefined tests, known as
benchmarks, on a system or its components. These benchmarks produce

10
numerical results that can be used to compare performance across differ-
ent systems or configurations. The results provide valuable insights into
the strengths and weaknesses of a processor, memory subsystem, or entire
system.
For example, benchmarking a processor may involve tests to measure:

• Instruction execution speed.

• Floating-point arithmetic performance.

• Cache and memory latency.

• Multithreaded performance.

6.2 Why is Benchmarking Important?

Benchmarking serves multiple purposes in system design and evaluation:

• Performance Comparison: Benchmarking allows the performance

of different processors, GPUs, or systems to be compared under iden-
tical conditions.

• System Optimization: Benchmark results can help identify bot-

tlenecks, such as slow memory access or inefficient code, enabling
optimization.

• Hardware Validation: Benchmarking ensures that hardware meets

its performance specifications before deployment.

• Real-World Relevance: By running benchmarks that simulate

real-world workloads, developers can predict how a system will per-
form under typical usage scenarios.

6.3 Types of Benchmarks

Benchmarks can be classified based on the type of performance they mea-
sure and the context in which they are applied:

6.3.1 Synthetic Benchmarks

Synthetic benchmarks are designed to test specific components of a sys-
tem in isolation. They generate workloads that mimic real-world tasks to
measure performance. Examples include:

11
 • SPEC CPU: Measures CPU performance for integer and floating-
point operations.
• Linpack: Evaluates floating-point computation performance, com-
monly used to rank supercomputers.

6.3.2 Real-World Benchmarks

These benchmarks are based on actual applications or workloads. They
provide a more accurate picture of how a system performs under practical
scenarios. Examples include:
• Rendering a video file using software like Adobe Premiere Pro.
• Running a database query workload using MySQL or PostgreSQL.

6.3.3 Component-Specific Benchmarks

Some benchmarks are tailored to measure the performance of specific com-
ponents:
• Processor Benchmarks: Evaluate clock speed, instructions per
cycle (IPC), and multithreading efficiency.
• Memory Benchmarks: Measure read/write speeds and latency.
• GPU Benchmarks: Test rendering capabilities, compute perfor-
mance, and gaming frame rates.

6.4 Key Benchmarking Metrics

Benchmarking results are typically presented as metrics that provide in-
sights into system performance. Important metrics include:
• Execution Time: The time taken to complete a specific task or
workload. Shorter execution times indicate better performance.
• Throughput: The number of operations a system can perform in a
given time. For example, the number of transactions per second in
a database system.
• Latency: The delay in completing a task, such as memory access
latency.
• Power Efficiency: The amount of work completed per watt of
power consumed. This is critical for battery-powered devices and
data centers.

12
6.5 Benchmarking Tools and Suites
Several tools and suites are commonly used for benchmarking:
• SPEC (Standard Performance Evaluation Corporation): A
widely recognized organization that provides benchmarks for CPUs,
memory, and entire systems.
• PassMark: A benchmarking tool that evaluates overall system per-
formance, including CPU, memory, and disk speeds.
• Geekbench: A cross-platform tool that tests single-core and mul-
ticore performance for CPUs and GPUs.
• Cinebench: A popular GPU and CPU benchmark that tests ren-
dering performance.

6.6 Challenges in Benchmarking

Although benchmarking provides valuable insights, it is not without chal-
lenges:
• Relevance: A benchmark may not accurately reflect the workloads
of specific applications.
• Hardware Variability: Performance can vary depending on hard-
ware configurations, such as cooling solutions or power settings.
• Optimizations: Some systems or software are optimized specifically
for benchmarks, which may not reflect real-world performance.

6.7 SPEC Benchmarks: An Example

The SPEC (Standard Performance Evaluation Corporation) benchmark
suite is widely used for evaluating CPU performance. It includes tests like
SPECint (integer performance) and SPECfp (floating-point performance).
These benchmarks simulate workloads such as compiling programs, run-
ning simulations, and processing large datasets.

6.8 Calculating the Mean

When comparing performance across multiple benchmarks, it is important
to aggregate the results in a way that accurately reflects the system’s over-
all performance. Depending on the nature of the data, different types of

13
averages, or means, are used. Each type has specific use cases and impli-
cations. Below are the key types of means and their detailed explanations:

6.8.1 Arithmetic Mean

The arithmetic mean is the most commonly used average, calculated by
summing all the data points and dividing by the number of data points.
It is straightforward and effective for simple data aggregation but is less
suitable for rates or ratios.

Formula: Pn
i=1 xi
Arithmetic Mean =
n

Example: Suppose a system completes three different tasks with execu-

tion times of 2 ms, 3 ms, and 5 ms. The arithmetic mean execution time
is:
2+3+5
Arithmetic Mean = = 3.33 ms.
3
This provides a simple overall representation of the execution time but
does not reflect task variability.

6.8.2 Harmonic Mean

The harmonic mean is more suitable for averaging rates, such as execu-
tion times or throughput. It gives more weight to smaller values, making
it particularly effective when the data involves inverse relationships, like
tasks per second or operations per unit time.

Formula:
n
Harmonic Mean = Pn 1
i=1 xi

Example: Consider three tasks with execution rates of 50 tasks/sec, 100 tasks/sec,
and 150 tasks/sec. The harmonic mean of the rates is:
3 3
Harmonic Mean = 1 1 1 = ≈ 75.68 tasks/sec.
50 + 100 + 150
0.02 + 0.01 + 0.00667

This value reflects the true average rate more accurately than the arith-
metic mean, especially when the rates vary significantly.

14
6.8.3 Geometric Mean
The geometric mean is ideal for summarizing ratios or benchmark scores
across systems. It is particularly useful when the data involves multi-
plicative relationships or growth rates. The geometric mean avoids the
distortion caused by outliers that can affect the arithmetic mean.

Formula: v
u n
uY
n
Geometric Mean = t xi
i=1

Example: Consider the benchmark scores of a system for three different

tests: 100, 120, and 150. The geometric mean is calculated as:
√
3
√3
Geometric Mean = 100 · 120 · 150 = 1800000 ≈ 123.5.

This provides a balanced average that effectively summarizes the perfor-

mance across all benchmarks, accounting for the proportional differences
between the scores.

6.8.4 Comparison of Means

Each type of mean serves a specific purpose:

• Arithmetic Mean: Best used for additive data, such as summing

up execution times of tasks with equal weight.

• Harmonic Mean: Most effective for rates and scenarios where

smaller values (e.g., faster times) have a greater impact.

• Geometric Mean: Suitable for comparing systems with ratios or

scores that span multiple benchmarks or environments.

Practical Example: Suppose two computer systems, A and B, are

tested using three benchmarks. The scores are as follows:

• System A: 90, 110, 130

• System B: 100, 120, 140

The means for each system are calculated below:

15
 • Arithmetic Mean:
90 + 110 + 130 100 + 120 + 140
System A: = 110, System B: = 120.
3 3

• Harmonic Mean:
3
System A: 1 1 1 ≈ 106.7,
90 + 110 + 130

3
System B: 1 1 1 ≈ 116.4.
100 + 120 + 140

• Geometric Mean:
√3
√
3
System A: 90 · 110 · 130 ≈ 109.5, System B: 100 · 120 · 140 ≈ 119.1.

System B consistently outperforms System A from these calculations,

regardless of the mean used. However, the choice of the mean depends on
the specific analysis requirements.

7 Exercises
7.1 Basic Measures of Computer Performance
1. A computer runs at a clock speed of 3.0 GHz. If a program requires
6 billion instructions to execute and the average CPI is 2.5, calculate
the total execution time of the program in seconds.
2. Explain the difference between clock speed and CPI. Why do these
two factors together determine the performance of a processor?
3. List three factors other than clock speed that affect the performance
of a processor and briefly explain each.

7.2 Factors Affecting Processor Performance

1. A cache memory system has a hit rate of 85%, and the access times
for the cache and main memory are 5 ns and 100 ns, respectively.
Calculate the effective memory access time (EMAT).
2. Define the following terms in the context of processor performance:
• Word length

16
 • Data bus width
• Address bus width

Provide a practical example of how each impacts system perfor-

mance.

3. What is instruction pipelining? Draw a simple 3-stage pipeline

(Fetch, Decode, Execute) for 5 instructions and explain how it im-
proves performance.

7.3 Instruction Pipelining

1. If a processor has a 4-stage pipeline, with each stage taking 2 ns,
calculate the total time to complete 10 instructions under pipelined
execution. Compare this to non-pipelined execution.

2. Identify and describe two types of hazards in instruction pipelining.

Provide an example of each and explain how they can be resolved.

7.4 Benchmarking and Performance Evaluation

1. A computer runs three benchmarks with execution times of 5 s, 10 s,
and 15 s. Calculate the harmonic mean of these execution times.

2. A processor has SPEC scores of 100, 110, and 120 for three bench-
marks. Calculate the geometric mean of these scores.

3. What is the primary goal of benchmarking? Give two examples of

commonly used benchmarking tools and briefly describe what they
measure.

7.5 Advanced Topics: Amdahl’s and Little’s Laws

1. A program is parallelized such that 25% of its execution cannot
be parallelized. If the program runs on 4 processors, calculate the
speedup using Amdahl’s Law.

2. Using Little’s Law, if a web server receives requests at an average

rate of 500 requests/second and the average response time is 20 ms,
calculate the average number of requests in the system.

17
7.6 Designing for Performance
1. A system designer must choose between increasing clock speed from
2.5 GHz to 3.0 GHz or adding a second processor core. Briefly explain
the trade-offs involved in these decisions.

2. How does a multicore processor improve performance? Give an ex-

ample of a task that benefits from multicore processing.

7.7 Comprehensive Problem

A software company wants to evaluate two systems for performance:

System A: SPEC scores = [120, 130, 140], System B: SPEC scores = [110, 140, 150].

1. Calculate the geometric mean for both systems and determine which
performs better.

2. If the company runs a workload consisting of 50% Task 1, 30%

Task 2, and 20% Task 3, which system should they choose based
on weighted SPEC scores?

18