Transition from Uniprocessors to Multiprocessors

Transition from Uniprocessors to Multiprocessors

• For decades, computer performance improved rapidly, allowing programs to run faster without requiring programmers to change their code. Increases in clock speed and architectural innovations drove this. However, around 2002, this trend slowed dramatically due to power limitations (the "power wall"). To continue improving performance, the industry was forced to switch from designing single, powerful processors (uniprocessors) to chips with multiple processors or cores.

• This marked a major turning point: the industry began emphasizing parallelism and throughput (the amount of work done per unit of time) rather than just the response time (the time it takes for a single task to complete).

1. The Need for Change

• For many years, computer designers improved performance mainly by increasing the speed of single processors. Faster processors could complete more instructions every second, reducing program execution time.

• However, around 2002, improvements in single‒processor performance began to slow down. Power consumption and heat generation became major limiting factors. As a result, no processor designers could no longer just increase clock speed to get higher performance.

• To continue improving performance, designers introduced multiple processors (called cores) on a single chip. This new approach led to the development of multicore processors.

2. Multicore Processor

• A multicore processor is a single chip that contains two or more independent processors (called cores). For example:

■ A dual‒core processor has 2 cores,

■ A quad‒core processor has 4 cores and

■ An octa‒core processor has 8 cores.

Each core can execute instructions independently, allowing the computer to run multiple tasks or parts of a program simultaneously. This improves throughput (the total work Is done), though not always the response time of a single program.

3. Impact on Software and Programmers

• In earlier times, programmers didn't have to worry about parallelism. Now, to gain significant performance improvements, programs must be rewritten to take advantage of multiple cores.

• This means programmers must:

 ■ Divide a program into parts that can run in parallel,

 ■ Balance the workload across cores and

 ■ Minimize communication and synchronization between the parts.

• Writing such parallel programs is difficult because programmers must make the program not only correct but also efficient and fast.

4. Challenges of Parallel Programming

• Parallel programming introduces several key challenges :

■ Scheduling: Dividing tasks so all processors are busy at the same time.

■ Load Balancing: Ensuring all processors get an equal amount of work.

■ Synchronization: Managing when processors must wait for others to finish certain tasks.

■ Communication Overhead : Reducing the time spent exchanging data between processors.

5. Parallelism

• Parallelism can appear at many levels in computer systems:

1. Instruction‒Level Parallelism (ILP): The CPU overlaps instruction execution internally (e.g., pipelining).

2. Data‒Level Parallelism (DLP): Multiple arithmetic operations happen at once (e.g., vector or SIMD processing).

3. Thread‒level or task‒level parallelism: Multiple processors run different threads or tasks concurrently.

6. Hardware / Software Interface and Parallelism

• The Hardware / Software Interface plays a vital role in managing parallelism. Both hardware designers and programmers must work together to achieve performance gains.

• The move toward explicit parallel programming has driven major innovations at every level of computer architecture. To efficiently execute programs on multicore systems, both hardware and software must work together to manage concurrency and data sharing.

• The following components illustrate how computer systems are designed to support parallel execution.

1. Synchronization and instructions

■ When multiple tasks run in parallel, they often need to co‒ordinate with each other ‒ especially when accessing shared data. Hardware provides special synchronization instructions (such as locks, semaphores, or atomic operations) to ensure that shared data is accessed in the correct order and without conflict.

■ These synchronization mechanisms prevent problems like data corruption or race conditions, which can occur when two processors try to update the same data at the same time.

2. Subword parallelism

■ Subword parallelism is a simple but powerful form of parallelism. It allows one instruction to perform operations on multiple smaller data elements at once. For example, when multiplying two vectors, each containing several numbers, the processor can use wide arithmetic units to process multiple pairs of numbers simultaneously.

This technique improves performance in applications involving multimedia, graphics, and scientific computations, where many similar operations are repeated on different data.

3. Cache coherence

■ In a multicore processor, all cores often share the same main memory, but each has its own cache (a small, fast local memory). When one core updates shared data in its cache, the other cores might still hold outdated copies of that data.

■ Cache coherence protocols ensure that all cores see the most recent version of shared data. These hardware mechanisms update or invalidate old copies across caches automatically, maintaining consistency and correctness in parallel programs.

4. High‒throughput I/O and RAID

■ To handle large amounts of input / output (I/O) data quickly, early computer systems introduced Redundant Arrays of Inexpensive Disks (RAID). RAID connects multiple disks to work together in parallel, offering much higher data throughput compared to a single disk.

■ Although RAID is now valued for data reliability (due to redundancy and fault tolerance), it was originally developed to increase I/O performance through parallel data access.

5. Graphics Processing Units (GPUs)

■ Graphics Processing Units (GPUs) were originally designed to accelerate computer graphics. However, modern GPUs have evolved into powerful parallel computing devices that can execute thousands of operations simultaneously.

■ GPUs contain hundreds or thousands of simple cores and are ideal for applications that require massive data parallelism, such as artificial intelligence, machine learning, image processing, and scientific simulations.

Review Questions

1. Explain the need for introducing multicore processors.

2. Describe the working and benefits of a multicore processor.

3. Discuss the challenges faced in parallel programming.

4. Explain how the Hardware ‒ Software Interface supports parallelism.

5. What is cache coherence? Why is it important in multicore processors?

6. Differentiate between throughput and response time.

7. Explain subword parallelism.

8. What is RAID? How does it represent parallelism in I/O operations?

9. Describe the role of GPUs in parallel computing