Test: Threads- 2 - Computer Science Engineering (CSE) MCQ

Every thread have its own stack, register, and PC, so only address space that is shared by all thread for a single process. Option (C) is correct.

The gantt chart is using preemptive priority scheduling algorithm:

Waiting Time = Completion time - Arrival time - Burst Time Therefore, waiting time of process P1 is = 49 - 0 - 11 = 38 So, option (C) is correct.

Let three process be P0, P1 and P2 with arrival times 0, 2 and 6 respectively and CPU burst times 10, 20 and 30 respectively. At time 0, P0 is the only available process so it runs. At time 2, P1 arrives, but P0 has the shortest remaining time, so it continues. At time 6, P2 also arrives, but P0 still has the shortest remaining time, so it continues. At time 10, P1 is scheduled as it is the shortest remaining time process. At time 30, P2 is scheduled.

Wait and signal are the atomic operation possible on semaphore.

(a) (i) The Many - to - one model maps many user threads to one kernel thread (ii) The one - to - one model maps one user thread to one kernel thread (iii) The many - to - many model maps many user threads to smaller or equal kernel threads

(b) (i) Many - to - one model maps many kernel threads to one user thread (ii) One - to - one model maps one kernel thread to one user thread (iii) Many - to - many model maps many kernel threads to smaller or equal user threads All satement are correct. So, option (A) is correct.

P: Wait operation decrements the value of the counting semaphore by 1. V: Signal operation increments the value of counting semaphore by 1. Current value of the counting semaphore = 10 a) after 3 P operations, value of semaphore = 10-3 = 7 d) after 2 v operations, and 5 operations value of semaphore = 10 + 2 - 5 = 7 Hence option (C) is correct.

P operation : Decrements the value of semaphore by 1 V operation : Increments the value of semaphore by 1 Initially, value of semaphore = 7 After 20 P operations, value of semaphore = 7 - 20 = -13 Now, after xV operations, value of semaphore = 5 -13 + xV = 5 xV = 5 + 13 = 18 So, option (A) is correct.

MS-DOS is an operating system for x86-based personal computers mostly developed by Microsoft. It doesn't provide multi-user facility. XENIX is a discontinued version of the Unix operating system for various microcomputer platforms, licensed by Microsoft from AT&T Corporation. It doesn't provide multi-user facility. OS/2 is a series of computer operating systems, initially created by Microsoft and IBM. It doesn't provide multi-user facility. So, Option (D) is correct.

Advantage of User level thread:

1- Scheduling is application dependent.

2- Thread switching doesn’t require kernel mode privileges.

3- The library procedures invoked for thread management in user level threads are local procedures.

4- User level threads are fast to create and manage.

5- User level thread can run on any operating system.

Disadvantage of User-level thread:

1- Most system calls are blocked on a typical OS.

2- Multiprocessing is not supported for multi-threaded application.

So, Option (A) is correct.

To avoid deadlock 'm' >= peak demands(P₁ + P₂ + P₃) i.e. m >= peak demands(2 + 5 + 7) m >= peak demands(14) So, option (B) is correct.

Current allocation of P₁P₂P₃P₄ are 3, 4, 2, 1 which is 10 in total. We have 12 total no of resources and out of them 10 are allocated so, we have only 2 resources. There is 5, 5, 3, 2 resources are needed for P₁P₂P₃P₄ respectively. So, P₄ will run first and free 3 resources after execution. Which are sufficient for P₃ So it will execute and do free 5 resources. Now P₁ and P₂ both require 5 resources each So we can execute any of them first but we will give priority to P₁. The execution order will be P₄P₃P₁P₂.

SO, option (C) is correct.

System crashes once in 30 days and need 10 minutes to get repaired. Either convert 30 days into minute or 10 minute into days 30 days = 30 ∗ 24 ∗ 60 minute fraction of time system is not available = (10 / (30 ∗ 24 ∗ 60 )) ∗ 100 = 0.023% Availability = 100 - 0.023 = 99.97%

So, option (D) is correct.

For 'n' processes to be scheduled on one processor, there can be n! different schedules possible. Example: Suppose an OS has 4 processes to schedule P1, P2, P3 and P4. For scheduling the first process, it has 4 choices, then from the remaining three processes it can take 3 choices, and so on. So, total schedules possible are 4*3*2*1 = 4!

Option (C) is correct.

Whenever a process is just created, it is kept in Ready queue. When it starts execution, it is in Running state, as soon as it starts doing input/output operation, it is kept in the blocked state.

Round Robin is a starvation free scheduling algorithm as it imposes a strict time bound on the response time of each process i.e. for a system with 'n' processes running in a round robin system with time quanta tq, no process will wait for more than (n-1) t_q time units to get its CPU turn. Option (D) is correct.

• System calls are usually invoked by using a software interrupt.
• Polling is the process where the computer or controlling device waits for an external device to check for its readiness or state, often with low-level hardware.
• Privileged instruction is an instruction (usually in machine code) that can be executed only by the operating system in a specific mode.
• In direct jump, the target address (i.e. its relative offset value) is encoded into the jump instruction itself.

So, option (C) is correct.

Priority inversion is a scenario in scheduling when a higher priority process is indirectly preempted by a lower priority process, thereby inverting the relative priorities of the process. This problem can be eliminated by temporarily raising the priority of lower priority level process, so that it can not preempt the higher priority process.

Option (A) is correct.

seek time = 2 =(2 + 14 + 4 + 4 + 38 + 8) = 420 msec 1000 msec = 1 sec 420 msec = 0.42 sec So, option (D) is correct.

In an operating system, indivisibility of operation means processor can not be pre-empted. One a process starts its execution it will not suspended or stop its execution inside the processor.

So, option (C) is correct.

In round robin algorithm, the size of time quanta plays a very important role as: If size of quanta is too small: Context switches will increase and it is counted as the waste time, so CPU utilization will decrease. If size of quanta is too large: Larger time quanta will lead to Round robin regenerated into FCFS scheduling algorithm. So, option (D) is correct.