Test: Operating System - 1 - Computer Science Engineering (CSE) MCQ

Given:

20 resources of same type.

Four processes with demand of 4, 5, x, y respectively.

So, (4 - 1) + (5 - 1) + (x -1) + (y -1) + 1 = 20

3 + 4 + x – 1 + y – 1 + 1 = 20

7 + x – 1 + y = 20

x + y + 7 = 21

x + y = 14

Maximum value of x + y so that there will be no deadlock in system = 14.

The round-robin (RR) scheduling algorithm is designed especially for timesharing systems.

It is similar to FCFS scheduling, but preemption is added to enable the system to switch between processes.

A small unit of time, called a time quantum or time slice, is defined.

The ready queue is treated as a circular queue. The CPU scheduler goes around the ready queue, allocating the CPU to each process for a time interval of up to 1-time​ quantum.

Time quantum = 5 units

Gantt Chart:

Calculations

Average turn around time = 20 + 35 + 50 + 60 + 65 / 5 = 46

Data:

Remaining Need(X) = (max-needs-X) – (has-X)

Remaining Need(Y) = (max-needs-Y) – (has-Y)

Calculation:

Available resource of X = 40

Available resource of Y = 40

Sequence: ACDB

Need of A(30, 30) ≤ available of (40, 40)

A is executed and release the resource held by it

Available of X = 40 + 35 = 75

Available of Y = 40 + 10 = 55

Available of (X, Y) = (75, 55)

Need of C(75, 30) ≤ available of (75, 55)

Also Need of D(X, Y) ≤ available of (X, Y)

Taking C first (as an exercise take D and solve)

C is executed and release the resource held by it

Available of X = 75 + 35 = 110

Available of Y = 55 + 20 = 75

Available of (X, Y) = (110, 75)

Need of D(50, 20) ≤ available of (110, 75)   // B won't be satisfied

D is executed and release the resource held by it

Available of X = 110 + 0 = 110

Available of Y = 75 + 70 = 145

Available of (X, Y) = (110, 140)

Need of B(50, 140) ≤ available of (110, 140)

B is executed and release the resource held by it

Available of X = 110 + 50 = 160

Available of Y = 145 + 140 = 285

Available of (X, Y) = (160, 2885)

∴ safe sequence is ACDB

Similarly, safe sequence is ADCB

Statement I: not true (False)

In deadlock prevention, number the resource uniquely and never requests a lower-numbered resource

Statement II:  True

In deadlock avoidance, the request for the resources is always granted if the resulting state is safe.

Statement IIiI not true (False)

In deadlock prevention, the request can be made after releasing the resource

Statement I and III are not true

Concepts:

V(S): Signal will increment the semaphore variable, that is, S++. 

P(S): Signal will decrement the semaphore variable., that is, S--. 

Data:

Shared variable = x = 10

Counting semaphore = S = 2

Calculation:

If Process A is executed completely

x = 10 – 2 = 8

and S = 2

Process C reads the value and decrement it by 3

x = 8 – 3 = 5

S = 1

Note that still process C doesn’t write it to memory

If Process B is executed completely

x = 8 + 3 = 11

S = 1

If Process D is executed completely

x = 11 + 2 = 13

S = 1

Now, C writes the value x = 5

∴ minimum possible value is 5.

Concepts:

V(S): Signal will increment the semaphore variable, that is, S++. 

P(S): Signal will decrement the semaphore variable., that is, S--. 

Data:

Initial counting semaphore = x = 1

Signal operation = 11 V

Wait operation = 17 P

n process in blocked state

Final counting semaphore (F) = -n

Formula:

n = x + 13P + 5V

Calculation:

n = 1 + 13(-1) + 5(+1)

∴ n = -7

∴ number of process in blocked state is 7

Concept:

Best fit algorithm: In this method, algorithm searches the complete list of partitions and then chooses the smallest hole in which process can fit with minimum internal fragmentation.

Worst fit algorithm: In this method, algorithm searches the complete list of partitions and then chooses the largest hole in which process can fit with maximum internal fragmentation.

Given partitions are:

250KB, 470KB, 600 KB, 500 KB, 300KB, and 410 KB

Processes are: 350 KB, 200 KB, 468 KB and 480 KB

Using best fit policy:

Using worst fit policy:

Using worst fit, one process cannot be allocated any partition. 

Data:

Virtual address space (VAS) = 48 bits

Virtual memory (VA) = 2⁴⁸ Byte

Physical Memory (PA) = 256 GB

Page size (PS) = 4 KB = 2¹² B

Page Table size (PTS) = 4 bytes

Formula:

pagetablesize=VAPS×PTS

Calculation:

The number of levels of paging required is 4.

Important Points:

If page table size (PTS) is less than or equal to page size, then page table can be stored in that level.

EAT = h_t (t_t + t_m) + (1 – h_t) [p * (t_t + (n + 1) t_m) + (1 – p) = t_d]

= 0.7 * (0 + 5 μs) + 0.3 * [0.8(0 + 2 * 5 μs) + 0.2 * 25 ms]

= 3.5 μs + 0.3 * [8 μs + 5000 μs]

= 1505.9 μs = 1.5 ms

Option 1: TRUE:

If a user-level thread block then entire process will get blocked

Option 2: FALSE

Kernel level threads are independent that is why they also require more context switch than user – level threads.

Option 3: TRUE

Every thread has its own register and stack

Option 4: TRUE

Communication between multiple threads is easier, as the threads shares common address space. while in process we have to follow some specific communication technique for communication between two process.