Section I

a) Processes that demand more Input/Output (I/O) resources compared to CPU resources are typically
I/O-bound processes. These processes spend a significant amount of time waiting for data to be
read from or written to storage devices, such as hard drives, solid-state drives, or network resources,
rather than actively performing computations with the CPU.
Examples of processes that are often I/O-bound include:
File operations: Tasks involving reading or writing large files, like copying, moving, or compressing
files.
Database operations: Database applications that read or write data to/from a disk, especially those that
involve complex queries, indexing, or data retrieval.
Network communication: Processes that rely on network operations, such as downloading large files,
streaming media, or web server requests.
Data backup and synchronization: Backing up data or synchronizing files across devices or cloud
storage services often involves significant I/O operations.
Data processing with large datasets: Applications dealing with massive datasets, like data analytics,
machine learning, and scientific simulations, may require substantial I/O operations to read and write
data.
Virtualization and containerization: Managing virtual machines or containers can be I/O-intensive,
as they often involve reading/writing disk images, snapshots, or network data.
Multimedia processing: Video editing, audio processing, and 3D rendering are examples of tasks that
require I/O for reading and writing media files.

b)

c) A context switch is an essential operating system operation that allows a multitasking operating
system to efficiently manage multiple processes or threads running on a single CPU core. It
involves saving the current state of a running process, loading the state of another process, and
switching the CPU's execution to that process.
 d) In “a” part → Internal Fragmentation and in “b” part → External Fragmentation

e) Yes, it is possible to have concurrency without parallelism. Concurrency and parallelism are
related concepts in the context of executing tasks, but they have distinct meanings:
Concurrency: Concurrency refers to the ability of a system to handle multiple tasks or processes
seemingly simultaneously. These tasks may be interleaved in such a way that they appear to make
progress concurrently, even on a single CPU core. Concurrency is often achieved using techniques
like multitasking or multi-threading, where the CPU rapidly switches between different tasks,
giving the illusion of parallel execution.
✓ Example: In a multitasking operating system, multiple applications can run concurrently
on a single-core CPU. While it may seem like they are running simultaneously, the CPU is
actually quickly switching between them.
Parallelism: Parallelism, on the other hand, involves the actual simultaneous execution of multiple
tasks on multiple CPU cores or processing units. Parallelism takes advantage of hardware resources
to achieve true simultaneous execution, offering potential performance improvements for
computationally intensive tasks.
✓ Example: In a multi-core CPU system, different cores can execute different tasks in
parallel, resulting in true parallelism

Section II
Question#2:
1. The program starts in the main function.
2. It declares an array nums with 5 elements and initializes it with values 0, 1, 2, 3, and 4.
3. It declares variables i and pid.
4. It calls fork(), which creates a new process. Let's call the original process "Parent" and
the new process "Child."
5. In the Parent process (because pid > 0), it encounters the wait(NULL) statement, which
makes the Parent process wait for the Child process to complete. The Child process has not
reached the wait(NULL) statement yet.
6. In the Child process (because pid == 0), it enters the loop:
• For i = 0, it multiplies nums[0] by -0 (which remains 0) and prints "CHILD: 0 ".
• For i = 1, it multiplies nums[1] by -1, resulting in -1, and prints "CHILD: -1 ".
• For i = 2, it multiplies nums[2] by -2, resulting in -4, and prints "CHILD: -4 ".
• For i = 3, it multiplies nums[3] by -3, resulting in -9, and prints "CHILD: -9 ".
• For i = 4, it multiplies nums[4] by -4, resulting in -16, and prints "CHILD: -16 ".
So, the Child process prints the following at LINE X: "CHILD: 0 CHILD: -1 CHILD: -4
CHILD: -9 CHILD: -16."

Final Output:
Because the child is a copy of the parent, any changes the child makes will occur in its copy of the data and
won’t be reflected in the parent. As a result, the values output by the child at line X are 0, -1, -4, -9, -16.
The values output by the parent at line Y are 0, 1, 2, 3, 4

Question#3:
Amdahl's Law is a formula used to estimate the maximum potential speedup achievable by
parallelizing a program. It states that the speedup of a program using multiple processors is limited
by the portion of the program that cannot be parallelized. The formula for Amdahl's Law is:
OR
By putting values: 1/ 0.05+(1-0.05)/100 = 16.806

Question#4:
First-fit algorithm: The first-fit algorithm places each process in the first free memory partition that is
large enough to accommodate it. In this case, the following allocations would be made:

Process Size Memory partition

P1 (200 MB) 200 MB 100 MB (remainder: 100 MB)
P2 (15 MB) 15 MB 40 MB (remainder: 25 MB)
P3 (185 MB) 185 MB 170 MB (remainder: 15 MB)
P4 (75 MB) 75 MB 205 MB (remainder: 130 MB)
P5 (175 MB) 175 MB 300 MB (remainder: 125 MB)
P6 (80 MB) 80 MB 185 MB (remainder: 105 MB)

All process requests are satisfied.

Best-fit algorithm: The best-fit algorithm places each process in the smallest free memory partition that is
large enough to accommodate it. In this case, the following allocations would be made:

Process Size Memory partition

P2 (15 MB) 15 MB 40 MB (remainder: 25 MB)
P3 (185 MB) 185 MB 185 MB
P4 (75 MB) 75 MB 170 MB (remainder: 95 MB)
P5 (175 MB) 175 MB 205 MB
P6 (80 MB) 80 MB 130 MB (remainder: 50 MB)

Process P1 cannot be satisfied because there is no free memory partition that is large enough to
accommodate it.

Worst-fit algorithm: The worst-fit algorithm places each process in the largest free memory partition that
is large enough to accommodate it. In this case, the following allocations would be made:
 Process Size Memory partition
P1 (200 MB) 200 MB 300 MB (remainder: 100 MB)
P5 (175 MB) 175 MB 205 MB
P6 (80 MB) 80 MB 185 MB (remainder: 105 MB)
P3 (185 MB) 185 MB 170 MB (remainder: 15 MB)
P4 (75 MB) 75 MB 130 MB (remainder: 55 MB)

Process P2 cannot be satisfied because there is no free memory partition that is large enough to
accommodate it.

Efficiency of the algorithms

The first-fit algorithm is the fastest of the three algorithms because it simply searches for the first free
memory partition that is large enough to accommodate the process. However, it can lead to external
fragmentation, which is when there are small free memory partitions that cannot be used by any process.
The best-fit algorithm is more efficient than the first-fit algorithm because it reduces external fragmentation
by allocating processes to the smallest free memory partition that is large enough to accommodate them.
However, it is slower than the first-fit algorithm because it requires more time to search for the appropriate
partition. The worst-fit algorithm is the most efficient of the three algorithms at reducing external
fragmentation because it allocates processes to the largest free memory partition that is large enough to
accommodate them. However, it can lead to internal fragmentation, which is when there is wasted space
within a memory partition because the process allocated to it is smaller than the partition size.

Question#5: