(a) Multi-core processing refers to the use of multiple processing units, or "cores," within a single

CPU (central processing unit). Each core is capable of executing its own instructions
independently, allowing for more efficient handling of tasks by splitting them across multiple
cores. This parallel processing capability significantly boosts performance, especially for tasks
that can be divided into smaller, concurrent processes, such as video editing, gaming, and
running complex simulations. In applications that are optimized for multi-core systems, this
results in faster computation and smoother execution, as workloads are distributed evenly
across available cores. For single-threaded tasks, however, performance improvements may be
minimal because only one core will be utilized. Overall, multi-core processing enhances a
system's ability to handle demanding applications, improve multitasking capabilities, and
provide a more responsive user experience.
(b) Amdahl’s Law is a formula used to predict the theoretical maximum speedup in a system when a
portion of the task is parallelized. It highlights the limitations of parallel computing, particularly
when only a fraction of a program can be parallelized, and the rest remains serial (i.e., must be
processed sequentially). The law is expressed as:

Where:

𝑆max is the maximum speedup.

Amdahl’s Law demonstrates that even if a large portion of a task is parallelized, the speedup achievable
is limited by the serial portion. For example, if 90% of a task can be parallelized (i.e.,

𝑃=0.9

P=0.9), and the remaining 10% must be executed serially, adding more processors will yield diminishing
returns as the serial portion becomes the bottleneck.

In the context of parallel computing, Amdahl’s Law emphasizes that simply increasing the number of
cores or processors won't result in a linear increase in performance if the program has parts that can’t
be parallelized. This is especially important for real-world applications, where achieving 100%
parallelization is often impossible. The law underscores the importance of optimizing both parallel and
serial components of a program to maximize performance gains in a parallel computing environment.
(c)

SISD (Single Instruction, Single Data)

SISD, represents the simplest form of computer architecture. In this model, a single processor executes
one instruction at a time, operating on one piece of data. Essentially, SISD processes tasks sequentially,
meaning it handles one instruction and one data element at a time. This architecture was common in
early computers and remains the foundation for most basic computing tasks today. For example, a
single-core processor in a traditional desktop computer follows this pattern of operation, executing each
instruction one after the other.

The primary advantage of SISD lies in its simplicity. The design of the processor is straightforward, and
its programming model is easy to understand and implement. It's well-suited for tasks that don't require
parallel processing, such as basic arithmetic or simple control operations. Additionally, since there is
only one instruction and data stream to manage, there is minimal complexity in terms of
synchronization and communication between processors, making SISD ideal for straightforward
computational problems. However, the SISD architecture becomes a limiting factor when faced with
modern, high-demand applications. Because it processes instructions one at a time, it struggles to
handle tasks that require heavy computational power, such as large-scale simulations, image processing,
or artificial intelligence. The single-threaded nature of SISD means that even if a task can be split into
multiple operations, it must still be processed serially, which can significantly slow down performance
compared to more advanced architectures.

SIMD (Single Instruction, Multiple Data)

SIMD, is an architecture designed to handle parallel processing by applying the same instruction to
multiple data elements simultaneously. This approach enables processors to perform the same
operation on different pieces of data at the same time, making it ideal for tasks where the same
computation needs to be repeated over a large dataset. A prime example of SIMD in action is the use of
Graphics Processing Units (GPUs)or vector processors, which leverage this architecture to accelerate
tasks like rendering images, scientific simulations, and machine learning computations.

SIMD operates by breaking down a task into smaller, independent operations, which can then be
executed simultaneously across multiple data elements. For example, in graphics rendering, each pixel
on the screen may need to undergo the same transformation (like adjusting brightness or applying a
filter). With SIMD, rather than processing each pixel one by one, the same operation can be applied to
many pixels at once, vastly speeding up the overall computation.

One of the biggest advantages of SIMD is its ability to dramatically boost performance for certain types
of tasks that can be parallelized. It achieves this by making efficient use of the processor’s resources,
allowing multiple pieces of data to be processed in parallel without requiring multiple instructions or
complex task splitting. SIMD is particularly effective in applications like image processing, video
encoding/decoding, scientific simulations, and machine learning, where large arrays of data can be
processed in the same manner.
MIMD (Multiple Instruction, Multiple Data)

MIMD, is an architecture that supports the simultaneous execution of different instructions on different
pieces of data across multiple processors. Unlike SIMD, where a single instruction is applied to multiple
data points in parallel, MIMD allows each processor in the system to execute its own distinct instruction
on its own unique data. This flexibility makes MIMD one of the most versatile and scalable architectures,
particularly suitable for complex and diverse computational workloads.

In a typical MIMD system, you might have a multi-core processor, a cluster of computers, or a
supercomputer, where each processing unit (core or node) can independently carry out different tasks.
For example, one processor might be working on a mathematical model while another is handling data
input/output, and a third is performing image processing, all in parallel. This independence enables
MIMD to efficiently handle tasks that are not easily divisible into repetitive operations, such as
simulations, real-time systems, and complex decision-making processes in machine learning or artificial
intelligence.

There are two main types of MIMD architectures:

1. Shared Memory MIMD: In this system, all processors share access to a single memory space. This
allows for easier communication and data sharing between processors but can lead to issues like
contention (when multiple processors try to access the same memory location simultaneously) and
synchronization (coordinating the tasks of multiple processors).

2. Distributed Memory MIMD: Here, each processor has its own local memory, and processors
communicate with one another through a network. While this type eliminates contention issues
inherent in shared memory systems, it requires more complex programming models to manage data
communication and synchronization between processors.

The main advantage of MIMD is its flexibility. Since each processor can execute different instructions on
different data, it can handle a wide variety of tasks concurrently. This makes MIMD ideal for applications
that require both parallelism and task diversity, such as database management, scientific simulations,
and real-time processing. MIMD systems can scale from a few processors to thousands of processors,
making them suitable for everything from multi-core consumer processors to large-scale
supercomputers. The complexity of coordinating tasks between processors, especially in shared-
memory systems, can lead to bottlenecks and inefficiencies. Distributed memory systems, while
scalable, require more complex algorithms for data distribution and inter-processor communication.
Additionally, efficient software design and programming techniques are crucial to ensure that the full
potential of MIMD is realized, as improper synchronization can lead to poor performance or errors.
MIMD is a highly versatile and scalable architecture capable of handling complex, multi-tasking
workloads. It excels in environments where multiple, diverse tasks need to be processed concurrently
and is used extensively in modern multi-core processors, clusters, and supercomputing systems.
MISD (Multiple Instruction, Single Data)

MISD, is an architecture where multiple processors simultaneously execute different instructions on the
same data. This is a very specialized and rare form of parallel computing architecture and has limited
practical use. In MISD, each processor applies a different operation to the same data stream, which
might seem counterintuitive compared to the more common models like SIMD and MIMD.

One of the theoretical use cases for MISD is in fault-tolerant systems or error correction. For instance, if
multiple processors apply different instructions (or computations) to the same data, the results can be
compared to detect and correct errors. This type of system could be useful in applications where high
reliability and correctness are paramount, such as spacecraft navigation systems, critical safety systems,
or other high-risk environments where data integrity is crucial.

An example of a potential MISD setup could be a system where multiple processors are evaluating the
same data in parallel using different algorithms. For instance, one processor might be checking for one
type of error while another looks for a different kind, ensuring that multiple verification processes occur
on the same data stream to reduce the likelihood of errors going unnoticed.

However, despite these niche use cases, MISD is not commonly implemented in real-world systems for
several reasons:

Inefficiency: Having multiple processors working on the same data, but performing different
instructions, is often inefficient. This is because it doesn't naturally fit into many types of computation,
where different processors are generally better used working on different data elements (as in MIMD) or
the same data (as in SIMD).

Limited Applications: The use cases for MISD are extremely narrow and specialized, making it
impractical for general-purpose computing. Most parallel processing tasks benefit from the uniformity
of SIMD or the flexibility of MIMD rather than the redundancy of MISD.

Complexity: Coordinating multiple processors executing different operations on the same data requires
complex management, synchronization, and communication, which adds overhead without providing
significant performance benefits for most types of problems.
(d)

Modern Graphics Processing Units (GPUs)and Central Processing Units (CPUs) serve different roles in a
computing system, with each being optimized for specific types of tasks. CPUs are general-purpose
processors designed for versatility, capable of handling a wide variety of workloads with complex control
flows. They typically have fewer cores—ranging from 4 to 16—but each core is powerful, running at high
clock speeds (3–5 GHz). CPUs excel at tasks that require sequential processing, like running operating
systems, managing user input, and executing single-threaded applications. Their architecture is designed
for low-latency, high-complexity tasks, and they can handle complex decision-making and branching
operations efficiently. On the other hand, GPUs are specialized processors designed for parallel
computing. They feature thousands of smaller cores (often over 1,000), optimized for performing the
same operation across large datasets simultaneously, making them ideal for tasks that require massive
data parallelism. GPUs are typically used in scenarios like 3D rendering, image processing, machine
learning, and deep learning, where large volumes of data can be processed in parallel. Unlike CPUs,
which prioritize low-latency and complex tasks, GPUs focus on throughput and are built to handle
repetitive computations efficiently across many threads at once. The lower clock speeds of GPUs (1.5–2
GHz) reflect their design for parallel processing, rather than single-threaded performance. The
programming model for GPUs is also distinct, utilizing frameworks like CUDA or OpenCL, which are built
to leverage the parallel nature of GPUs, while CPUs typically rely on traditional single-threaded or multi-
threaded programming. While GPUs tend to consume more power due to their parallel architecture,
they are much more energy-efficient for specific tasks, such as running deep learning models or
rendering high-resolution graphics. Despite their differences, both CPUs and GPUs are complementary in
modern computing systems—CPUs manage general-purpose computing, while GPUs accelerate specific
workloads that benefit from parallelism.