Quiz - Process Management

Question 1

Consider the following code fragment:

  if (fork() == 0)
  { 
   a = a + 5; 
   printf("%d,%dn", a, &a); 
  }
 else 
  { 
   a = a –5; 
   printf("%d, %dn", a, &a); 
  }

Let u, v be the values printed by the parent process, and x, y be the values printed by the child process. Which one of the following is TRUE?

u = x + 10 and v = y
u = x + 10 and v != y
u + 10 = x and v = y
u + 10 = x and v != y

Question 2

The atomic fetch-and-set x, y instruction unconditionally sets the memory location x to 1 and fetches the old value of x in y without allowing any intervening access to the memory location x. consider the following implementation of P and V functions on a binary semaphore .

void P (binary_semaphore *s) {
  unsigned y;
  unsigned *x = &(s->value);
  do {
     fetch-and-set x, y;
  } while (y);
}

void V (binary_semaphore *s) {
  S->value = 0;
}

Which one of the following is true?

The implementation may not work if context switching is disabled in P.
Instead of using fetch-and-set, a pair of normal load/store can be used
The implementation of V is wrong
The code does not implement a binary semaphore
None of the above

Question 3

Three concurrent processes X, Y, and Z execute three different code segments that access and update certain shared variables. Process X executes the P operation (i.e., wait) on semaphores a, b and c; process Y executes the P operation on semaphores b, c and d; process Z executes the P operation on semaphores c, d, and a before entering the respective code segments. After completing the execution of its code segment, each process invokes the V operation (i.e., signal) on its three semaphores. All semaphores are binary semaphores initialized to one. Which one of the following represents a deadlockfree order of invoking the P operations by the processes?
[GATE CS 2013]

X: P(a) P(b) P(c)
Y: P(b) P(c) P(d)
Z: P(c) P(d) P(a)
X: P(b) P(a) P(c)
Y: P(b) P(c) P(d)
Z: P(a) P(c) P(d)
X: P(b) P(a) P(c)
Y: P(c) P(b) P(d)
Z: P(a) P(c) P(d)
X: P(a) P(b) P(c)
Y: P(c) P(b) P(d)
Z: P(c) P(d) P(a)

Question 4

A shared variable x, initialized to zero, is operated on by four concurrent processes W, X, Y, Z as follows. Each of the processes W and X reads x from memory, increments by one, stores it to memory, and then terminates. Each of the processes Y and Z reads x from memory, decrements by two, stores it to memory, and then terminates. Each process before reading x invokes the P operation (i.e., wait) on a counting semaphore S and invokes the V operation (i.e., signal) on the semaphore S after storing x to memory. Semaphore S is initialized to two. What is the maximum possible value of x after all processes complete execution?
[GATE CS 2013]

2
1
-2
-1

Question 5

A certain computation generates two arrays a and b such that a[i]=f(i) for 0 ≤ i < n and b[i]=g(a[i]) for 0 ≤ i < n. Suppose this computation is decomposed into two concurrent processes X and Y such that X computes the array a and Y computes the array b. The processes employ two binary semaphores R and S, both initialized to zero. The array a is shared by the two processes. The structures of the processes are shown below.

       Process X:                         Process Y:
private i;                         private i;
for (i=0; i < n; i++) {            for (i=0; i < n; i++) {
   a[i] = f(i);                       EntryY(R, S);
   ExitX(R, S);                       b[i]=g(a[i]);
}                                 }

Which one of the following represents the CORRECT implementations of ExitX and EntryY?

ExitX(R, S) {
  P(R);
  V(S);
}

EntryY (R, S) {
  P(S);
  V(R);
}

ExitX(R, S) {
  V(R);
  V(S);
}

EntryY(R, S) {
  P(R);
  P(S);
}

ExitX(R, S) {
  P(S);
  V(R);
}
EntryY(R, S) {
  V(S);
  P(R);
}

ExitX(R, S) {
  V(R);
  P(S);
}
EntryY(R, S) {
  V(S);
  P(R);
}

Question 6

A process executes the code

fork();
fork();
fork();

The total number of child processes created is

3
4
7
8

Question 7

Fetch_And_Add(X,i) is an atomic Read-Modify-Write instruction that reads the value of memory location X, increments it by the value i, and returns the old value of X. It is used in the pseudocode shown below to implement a busy-wait lock. L is an unsigned integer shared variable initialized to 0. The value of 0 corresponds to lock being available, while any non-zero value corresponds to the lock being not available.

  AcquireLock(L){
         while (Fetch_And_Add(L,1))
               L = 1;
   }
  ReleaseLock(L){
         L = 0;
   }

This implementation
[Gate CS 2012]

fails as L can overflow
fails as L can take on a non-zero value when the lock is actually available
works correctly but may starve some processes
works correctly without starvation

Question 8

The time taken to switch between user and kernel modes of execution be t1 while the time taken to switch between two processes be t2. Which of the following is TRUE?
[Gate CS 2011]

t1<t2
t1=t2
t1=t2
nothing can be said about the relation between t1 and t2

Question 9

A thread is usually defined as a “light weight process” because an operating system (OS) maintains smaller data structures for a thread than for a process. In relation to this, which of the following is TRUE?

On per-thread basis, the OS maintains only CPU register state
On per-thread basis, the OS does not maintain virtual memory state
The OS does not maintain a separate stack for each thread
On per-thread basis, the OS maintains only scheduling and accounting information

Question 10

Consider the methods used by processes P1 and P2 for accessing their critical sections whenever needed, as given below. The initial values of shared boolean variables S1 and S2 are randomly assigned.

Method Used by P1
while (S1 == S2) ;
Critical Section
S1 = S2;

Method Used by P2
while (S1 != S2) ;
Critical Section
S2 = not (S1);

Which one of the following statements describes the properties achieved?
[Gate CS 2010]

Mutual exclusion but not progress
Progress but not mutual exclusion
Neither mutual exclusion nor progress
Both mutual exclusion and progress

Question 11

The following program consists of 3 concurrent processes and 3 binary semaphores.The semaphores are initialized as S0 = 1, S1 = 0, S2 = 0.

GateCS2010Q42

How many times will process P0 print ‘0’?

At least twice
Exactly twice
Exactly Thrice
Exactly Once

Question 12

The enter_CS() and leave_CS() functions to implement critical section of a process are realized using test-and-set instruction as follows:

void enter_CS(X)
{
    while test-and-set(X) ;
}
void leave_CS(X)
{
   X = 0;
}

In the above solution, X is a memory location associated with the CS and is initialized to 0. Now consider the following statements:
I. The above solution to CS problem is deadlock-free
II. The solution is starvation free.
III. The processes enter CS in FIFO order.
IV More than one process can enter CS at the same time.
Which of the above statements is TRUE?
[Gate CS 2009]

I only
I and II
II and III
IV Only

Question 13

A process executes the following code

for (i = 0; i < n; i++) 
     fork();

The total number of child processes created is
[Gate CS 2008, ISRO 2017]

n
2ⁿ-1
2ⁿ
2⁽ⁿ⁺¹⁾-1

Question 14

Consider the following statements about user level threads and kernel level threads. Which one of the following statement is FALSE?

Context switch time is longer for kernel level threads than for user level threads.
User level threads do not need any hardware support.
Related kernel level threads can be scheduled on different processors in a multi-processor system.
Blocking one kernel level thread blocks all related threads.

Question 15

Consider the following synchronization construct used by the processes:Here, wants1 and wants2 are shared variables, which are initialized to false.

  /* P1 */
while (true) {
  wants1 = true;
  while (wants2 == true);
  /* Critical
    Section */
  wants1=false;
}
/* Remainder section */       


/* P2 */
while (true) {
  wants2 = true;
  while (wants1==true);
  /* Critical
    Section */
  wants2 = false;
}
/* Remainder section */

Which one of the following statements is TRUE about the above construct?
[Gate CS 2007]

It does not ensure mutual exclusion.
It does not ensure bounded waiting.
It requires that processes enter the critical section in strict alternation.
It does not prevent deadlocks, but ensures mutual exclusion.

Question 16

Which one of the following is FALSE?
[Gate CS 2014]

User level threads are not scheduled by the kernel.
When a user level thread is blocked, all other threads of its process are blocked.
Context switching between user level threads is faster than context switching between kernel level threads.
Kernel level threads cannot share the code segment.

Question 17

Consider two processors P1 and P2 executing the same instruction set. Assume that under identical conditions, for the same input, a program running on P2 takes 25% less time but incurs 20% more CPI (clock cycles per instruction) as compared to the program running on P1. If the clock frequency of P1 is 1GHz, then the clock frequency of P2 (in GHz) is _________.
[Gate CS 2014]

1.6
3.2
1.2
0.8

Question 18

Consider the procedure below for the Producer-Consumer problem which uses semaphores:

Which one of the following is TRUE?
[Gate CS 2014]

The producer will be able to add an item to the buffer, but the consumer can never consume it.
The consumer will remove no more than one item from the buffer.
Deadlock occurs if the consumer succeeds in acquiring semaphore s when the buffer is empty.
The starting value for the semaphore n must be 1 and not 0 for deadlock-free operation.

Question 19

The atomic fetch-and-set x, y instruction unconditionally sets the memory location x to 1 and fetches the old value of x n y without allowing any intervening access to the memory location x. consider the following implementation of P and V functions on a binary semaphore S.

void P (binary_semaphore *s)
{
    unsigned y;
    unsigned *x = &(s->value);
    do
    {
        fetch-and-set x, y;
    }
    while (y);
}
void V (binary_semaphore *s)
{
    S->value = 0;
}

Which one of the following is true?
[Gate CS 2006]

The implementation may not work if context switching is disabled in P
Instead of using fetch-and –set, a pair of normal load/store can be used
The implementation of V is wrong
The code does not implement a binary semaphore

Question 20

Which of the following is false?
[ISRO 2017]

User level threads are not scheduled by the kernel
Context switching between user level threads is faster than context switching between kernel level threads
When a user thread is blocked all other threads of its processes are blocked
Kernel level threads cannot utilize multiprocessor systems by splitting threads on different processors or cores

Question 21

Barrier is a synchronization construct where a set of processes synchronizes globally i.e. each process in the set arrives at the barrier and waits for all others to arrive and then all processes leave the barrier. Let the number of processes in the set be three and S be a binary semaphore with the usual P and V functions. Consider the following C implementation of a barrier with line numbers shown on left.

void barrier (void) {
   P(S);
   process_arrived++;
   V(S);
   while (process_arrived !=3);
   P(S);
   process_left++;
   if (process_left==3) {
      process_arrived = 0;
      process_left = 0;
  }
  V(S);
}

The variables process_arrived and process_left are shared among all processes and are initialized to zero. In a concurrent program all the three processes call the barrier function when they need to synchronize globally. Which one of the following rectifies the problem in the implementation?
[Gate CS 2006]

Lines 6 to 10 are simply replaced by process_arrived
At the beginning of the barrier the first process to enter the barrier waits until process_arrived becomes zero before proceeding to execute P(S).
Context switch is disabled at the beginning of the barrier and re-enabled at the end.
The variable process_left is made private instead of shared

Question 22

Consider two processes P1 and P2 accessing the shared variables X and Y protected by two binary semaphores SX and SY respectively, both initialized to 1. P and V denote the usual semaphone operators, where P decrements the semaphore value, and V increments the semaphore value. The pseudo-code of P1 and P2 is as follows :
P1 :

 While true do {
   L1 : ................
   L2 : ................
   X = X + 1;
   Y = Y - 1;
   V(SX);
   V(SY);             
 }

P2 :

 While true do {
   L3 : ................   
   L4 : ................
   Y = Y + 1;
   X = Y - 1;
   V(SY);
   V(SX);            
}

In order to avoid deadlock, the correct operators at L1, L2, L3 and L4 are respectively:
[Gate CS 2004]

P(Sy), P(Sx); P(Sx), P(Sy)
P(Sx), P(Sy); P(Sy), P(Sx)
P(Sx), P(Sx); P(Sy), P(Sy)
P(Sx), P(Sy); P(Sx), P(Sy)

Question 23

Suppose we want to synchronize two concurrent processes P and Q using binary semaphores S and T. The code for the processes P and Q is shown below.
Process P:

while (1) {
W:
   print '0';
   print '0';
X:
}

Process Q:

while (1) {
Y:
   print '1';
   print '1';
Z:
}

Synchronization statements can be inserted only at points W, X, Y and Z. Which of the following will always lead to an output staring with ‘001100110011’ ?
[Gate CS 2003]

P(S) at W, V(S) at X, P(T) at Y, V(T) at Z, S and T initially 1
P(S) at W, V(T) at X, P(T) at Y, V(S) at Z, S initially 1, and T initially 0
P(S) at W, V(T) at X, P(T) at Y, V(S) at Z, S and T initially 1
P(S) at W, V(S) at X, P(T) at Y, V(T) at Z, S initially 1, and T initially 0

Question 24

Which of the following does not interrupt a running process?
[Gate CS 2001]

A device
Timer
Scheduler process
Power failure

Question 25

Which of the following need not necessarily be saved on a context switch between processes?
[Gate CS 2000]

General purpose registers
Translation look aside buffer
Program counter
All of the above

Question 26

The following two functions P1 and P2 that share a variable B with an initial value of 2 execute concurrently.

P1() 
{ 
   C = B – 1; 
   B = 2*C;  
}

P2()
{
   D = 2 * B;
   B = D - 1; 
}

The number of distinct values that B can possibly take after the execution is:
[Gate CS 2015]

3
2
5
4

Question 27

Two processes X and Y need to access a critical section. Consider the following synchronization construct used by both the processes.

Here, varP and varQ are shared variables and both are initialized to false. Which one of the following statements is true?

The proposed solution prevents deadlock but fails to guarantee mutual exclusion.
The proposed solution guarantees mutual exclusion but fails to prevent deadlock.
The proposed solution guarantees mutual exclusion and prevents deadlock.
The proposed solution fails to prevent deadlock and fails to guarantee mutual exclusion.

Question 28

In a certain operating system, deadlock prevention is attempted using the following scheme. Each process is assigned a unique timestamp, and is restarted with the same timestamp if killed. Let Ph be the process holding a resource R, Pr be a process requesting for the same resource R, and T(Ph) and T(Pr) be their timestamps respectively. The decision to wait or preempt one of the processes is based on the following algorithm.

 if T(Pr) < T(Ph)

     then kill Pr

else wait

Which one of the following is TRUE?
[Gate IT 2004]

The scheme is deadlock-free, but not starvation-free
The scheme is not deadlock-free, but starvation-free
The scheme is neither deadlock-free nor starvation-free
The scheme is both deadlock-free and starvation-free

Question 29

A process executes the following segment of code :

 for(i = 1; i < = n; i++)
    fork ();

The number of new processes created is:

n
((n(n + 1))/2)
2n – 1
3n – 1

Question 30

The semaphore variables full, empty and mutex are initialized to 0, n and 1, respectively. Process P1 repeatedly adds one item at a time to a buffer of size n, and process P2 repeatedly removes one item at a time from the same buffer using the programs given below. In the programs, K, L, M and N are unspecified statements.
P1:

while (1) 
 {  K; 
    P(mutex); 
    Add an item to the buffer; 
    V(mutex);
    L; 
}

P2

while (1)
 {  M; 
    P(mutex); 
    Remove an item from the buffer; 
    V(mutex);     
    N; 
}

The statements K, L, M and N are respectively:
[Gate IT 2004]

P(full), V(empty), P(full), V(empty)
P(full), V(empty), P(empty), V(full)
P(empty), V(full), P(empty), V(full)
P(empty), V(full), P(full), V(empty)

Question 31

Consider the following two-process synchronization solution.

Process 0                             Process 1                          

Entry: loop while (turn == 1);        Entry: loop while (turn == 0);
       (critical section)                    (critical section)
       Exit: turn = 1;                       Exit turn = 0;

The shared variable turn is initialized to zero. Which one of the following is TRUE?
[Gate CS 2016]

This is a correct two-process synchronization solution.
This solution violates mutual exclusion requirement.
This solution violates progress requirement.
This solution violates bounded wait requirement.

Question 32

Consider a non-negative counting semaphore S. The operation P(S) decrements S, and V(S) increments S. During an execution, 20 P(S) operations and 12 V(S) operations are issued in some order. The largest initial value of S for which at least one P(S) operation will remain blocked is ________.
[Gate CS 2016]

7
8
9
10

Question 33

In the working-set strategy, which of the following is done by the operating system to prevent thrashing?

It initiates another process if there are enough extra frames.
It selects a process to suspend if the sum of the sizes of the working-sets exceeds the total number of available frames.

[Gate IT 2006]

I only
II only
Neither I nor II
Both I and II

Question 34

Processes P1 and P2 use critical_flag in the following routine to achieve mutual exclusion. Assume that critical_flag is initialized to FALSE in the main program.

get_exclusive_access ( ) { 
 if (critical _flag == FALSE) { 
   critical_flag = TRUE ; 
   critical_region () ; 
   critical_flag = FALSE; 
  } 
}

Consider the following statements.
i. It is possible for both P1 and P2 to access critical_region concurrently.
ii. This may lead to a deadlock.
Which of the following holds?
[Gate IT 2007]

(i) is false and (ii) is true
Both (i) and (ii) are false
(i) is true and (ii) is false
Both (i) and (ii) are true

Question 35

The following is a code with two threads, producer and consumer, that can run in parallel. Further, S and Q are binary semaphores equipped with the standard P and V operations.

semaphore S = 1, Q = 0; integer x; 
producer:                        consumer: 
while (true) do                    while (true) do 
P(S);                              P(Q); 
x = produce ();                    consume (x);
V(Q);                              V(S); 
done                               done 
Which of the following is TRUE about the program above?
Gate IT 2008

The process can deadlock
One of the threads can starve
Some of the items produced by the producer may be lost
Values generated and stored in 'x' by the producer will always be consumed before the producer can generate a new value

Question 36

An operating system implements a policy that requires a process to release all resources before making a request for another resource. Select the TRUE statement from the following:
Gate IT 2008

Both starvation and deadlock can occur
Starvation can occur but deadlock cannot occur
Starvation cannot occur but deadlock can occur
Neither starvation nor deadlock can occur

Question 37

If the time-slice used in the round-robin scheduling policy is more than the maximum time required to execute any process, then the policy will
Gate IT 2008

degenerate to shortest job first
degenerate to priority scheduling
degenerate to first come first serve
none of the above

Question 38

Consider the following C code for process P1 and P2.

a=4, b=0, c=0;
     P1                       P2
  if (a < 0)                b = 10;    
    c = b-a;                a = -3;
  else
    c = b+a;

If the processes P1 and P2 executes concurrently (shared variables a, b and c), which of the following cannot be the value of ‘c’ after both processes complete?
Gate 2017

4
7
10
13

Question 39

Which of the following actions is/are typically not performed by the operating system when switching context from process A to process B?

Saving current register values and restoring saved register values for process B.
Changing address translation tables.
Swapping out the memory image of process A to the disk.
Invalidating the translation look-aside buffer.

Question 40

In a computer system where the ‘best-fit’ algorithm is used for allocating ‘jobs’ to ‘memory partitions’, the following situation was encountered:

When will the 20K job complete?
Gate CS 1998]

18
19
11
20

Question 41

The process state transition diagram in below figure is representative of which type of system:

[Gate CS 1996]

a batch operating system
an operating system with a preemptive scheduler
an operating system with a non-preemptive scheduler
a uni-programmed operating system

Question 42

Which of the following option is False?
[Gate CS 2018]

An executing instance of a program is called a process while a thread is a subset of the process.
Threads have considerable overhead while processes have almost no overhead.
Execution of processes are independent while execution of threads are dependent.
New processes require duplication of the parent process while new threads are easily created.

Question 43

Which of the following is/are not shared by all the threads in a process?

Program Counter
Stack
Registers
Address space

[Gate CS 2018]

I and II only
II and III only
I, II and III only
IV Only

Question 44

Consider the set of processes with arrival time(in milliseconds), CPU burst time (in milliseconds), and priority(0 is the highest priority) shown below. None of the processes have I/O burst time.
Process Arrival Time Burst Time Priority
P1 0 11 2
P2 5 28 0
P3 12 2 3
P4 2 10 1
P5 9 16 4
The waiting time (in milliseconds) of process P1 using preemptive priority scheduling algorithm is ____.

26
49
38
29

Question 45

The following are some events that occur after a device controller issues an interrupt while process L is under execution.
(P) The processor pushes the process status of L onto the control stack.
(Q) The processor finishes the execution of the current instruction.
(R) The processor executes the interrupt service routine.
(S) The processor pops the process status of L from the control stack.
(T) The processor loads the new PC value based on the interrupt.
Which of the following is the correct order in the which the events above occur?
[Gate CS 2018]

QPTRS
PTRSQ
TRPQS
QTPRS

Question 46

Two atomic operations permissible on Semaphores are __________ and __________.
[NET CS Nov 2017]

wait, hold
wait, stop
hold,signal
wait, signal

Question 47

Consider three CPU intensive processes, which require 10, 20, 30 units and arrive at times 0, 2, 6 respectively. How many context switches are needed if shortest remaining time first process scheduling algorithm is implemented? Context switch at 0 is included but context switch at end is ignored.
ISRO 2017

1
2
3
4

Question 48

User level threads are threads that are visible to the programmer and are unknown to the kernel. The operating system kernel supports and manages kernel level threads. Three different types of models relate user and kernel level threads. Which of the following statements is/are true ?
(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
[NET Nov 2017]

(a) is true; (b) is false
(a) is false; (b) is true
Both (a) and (b) are true
Both (a) and (b) are flase

Question 49

The Bounded buffer problem is also known as __________.
[NET CS Nov 2017]

Producer Consumer problem
Reader Writer problem
Dinning Philosopher problem
Both (2) and (3)

Question 50

What is the output of the following program?

main( )
{
  int a = 10;
  if ((fork ( ) == 0))
   a++;
  printf (“%dn”, a );
} 
[ISRO 2017]

10 and 11
10
11
11 and 11

Question 51

Mutual exclusion problem occurs:
[ISRO 2017]

Between two disjoint processes that do not interact
Among processes that share resources
Among processes that do not use the same resource
Between two processes that uses different resources of different machine

Question 52

A critical region
[ISRO 2017]

is a piece of code which only one process executes at a time
is a region prone to deadlock
is a piece of code which only a finite number of processes execute
is found only in windows NT operating system

Question 53

At particular time, the value of a counting semaphore is 10, it will become 7 after:
(a) 3 V operations
(b) 3 P operations
(c) 5 V operations and 2 P operations
(d) 2 V operations and 5 P operations
Which of the following option is correct?
[ISRO 2017]

Only (b)
Only (d)
Both (b) and (d)
None of the above

Question 54

There are three processes P1, P2 and P3 sharing a semaphore for synchronizing a variable. Initial value of semaphore is one. Assume that negative value of semaphore tells us how many processes are waiting in queue. Processes access the semaphore in following order :
(a) P2 needs to access
(b) P1 needs to access
(c) P3 needs to access
(d) P2 exits critical section
(e) P1 exits critical section
The final value of semaphore will be :
[NET CS 2017]

0
1
-1
2

Question 55

At a particular time of computation the value of a counting semaphore is 7. Then 20 P operations and x V operations were completed on this semaphore. If the new value of semaphore is 5, x will be

18
22
15
13

Question 56

One of the disadvantages of user level threads compared to Kernel level threads is:
[NET CS 2017]

If a user level thread of a process executes a system call, all threads in that process are blocked.
Scheduling is application dependent.
Thread switching doesn’t require kernel mode privileges.
The library procedures invoked for thread management in user level threads are local procedures.

Question 57

Names of some of the Operating Systems are given below: (a) MS-DOS (b) XENIX (c) OS/2 In the above list, following operating systems didn’t provide multiuser facility.
[NET CS 2017]

(a)
(b) and (c)
(a) and (b)
(a), (b) and (c)

Question 58

In a lottery scheduler with 40 tickets, how we will distribute the tickets among 4 processes and such that each process gets 10%, 5%, 60% and 25% respectively?

     P1   P2   P3   P4
a)   12   4    70   30
b)   7    5    20   10
c)   4    2    24   10
d)   8    5    40   30

[ISRO 2015]

a
b
c
d

Question 59

Suppose a system contains n processes and system uses the round-robin algorithm for CPU scheduling then which data structure is best suited for ready queue of the process.

Stack
Queue
Circular Queue
Tree

Question 60

Consider a system with seven processes A through G and six resources R through W. Resource ownership is as follows : process A holds R and wants T process B holds nothing but wants T process C holds nothing but wants S process D holds U and wants S & T process E holds T and wants V process F holds W and wants S process G holds V and wants U Is the system deadlocked ? If yes, ______ processes are deadlocked.

No
Yes, A, B, C
Yes, D, E, G
Yes, A, B, F

Question 61

Consider a system having ‘m’ resources of the same type. These resources are shared by three processes P1, P2 and P3 which have peak demands of 2, 5 and 7 resources respectively. For what value of ‘m’ deadlock will not occur ?

14
13
16
11

Question 62

An Operating System (OS) crashes on the average once in 30 days, that is, the Mean Time Between Failures (MTBF) = 30 days. When this happens, it takes 10 minutes to recover the OS, that is, the Mean Time To Repair (MTTR) = 10 minutes. The availability of the OS with these reliability figures is approximately :
[NET 2016]

96.97%
97.97%
97.009%
99.97%

Question 63

Suppose there are four processes in execution with 12 instances of a Resource R in a system. The maximum need of each process and current allocation are given below:

Process	Max. Need	Allocation
P1	8	3
P2	9	4
P3	5	2
P4	3	1

With reference to current allocation, is system safe ? If so, what is the safe sequence ?

No
Yes, P1P2P3P4
Yes, P4P3P1P2
Yes, P2P1P3P4

Question 64

Consider the following set of processes, with arrival times and the required CPU-burst times given in milliseconds.

What is the sequence in which the processes are completed? Assume round robin scheduling with a time quantum of 2 milliseconds.
[ISRO 2013]

Process	Arrival Time	Burst Time
P1	0	4	P2	2	2
P3	3	1>/td>

P1, P2, P3
P2, P1, P3
P2, P3, P1
P3, P2, P1

Question 65

A CPU scheduling algorithm determines an order for the execution of its scheduled processes. Given ‘n’ processes to be scheduled on one processor, how many possible different schedules are there?
[ISRO 2013]

n
n2
n!
2n

Question 66

A starvation free job scheduling policy guarantees that no job indefinitely waits for a service. Which of the following job scheduling policies is starvation free?
[ISRO 2013]

Priority Queuing
Shortest Job First
Round Robin
Youngest Job First

Question 67

The state of a process after it encounters an I/O instruction is
[ISRO 2013]

Idle
Blocked
Ready
Running

Question 68

Which of the following strategy is employed for overcoming the priority inversion problem?
[ISRO 2013]

Temporarily raise the priority of lower priority level process
Have a fixed priority level scheme
Implement kernel preemption scheme
Allow lower priority process to complete its job

Question 69

System calls are usually invoked by using:
[NET CS 2015]

A privileged instruction
An Indirect Jump
A software interrupt
Polling

Question 70

A disk drive has 100 cylinders, numbered 0 to 99. Disk requests come to the disk driver for cylinders 12, 26, 24, 4, 42, 8 and 50 in that order. The driver is currently serving a request at cylinder 24. A seek takes 6 msec per cylinder moved. How much seek time is needed for shortest seek time first (SSTF) algorithm?
[NET 2015]

0.984 sec
0.396 sec
0.738 sec
0.42

Question 71

The following table shows the processes in the ready queue and time required for each process for completing its job.

Process	Time
P1	10
P2	5
P3	20
P4	8
P5	15

If round-robin scheduling with 5 ms is used what is the average waiting time of the processes in the queue?
[ISRO 2011]

27
26.2
27.2
27.5

Question 72

Consider a system with twelve magnetic tape drives and three processes P₁, P₂ and P₃. Process P₁ requires maximum ten tape drives, process P₂ may need as many as four tape drives and P3 may need upto nine tape drives. Suppose that at time t₁, process P₁ is holding five tape drives, process P₂ is holding two tape drives and process P₃ is holding three tape drives. At time t₁, system is in:

Safe state
Unsafe state
Deadlock state
Starvation state

Question 73

In an operating system, indivisibility of operation means:
[NET CS 2015]

Operation is interruptable
Race - condition may occur
Processor can not be preempted
All of the above

Question 74

There are three processes in the ready queue. When the currently running process requests for I/O how many process switches take place?
[ISRO 2011]

1
2
3
4

Question 75

Which is the correct definition of a valid process transition in an operating system?
[ISRO CS 2009]

Wake up: ready → running
Dispatch: ready → running
Block: ready → running
Timer runout: ready → running

Question 76

The correct matching of the following pairs is

(A) Disk check              (1) Roundrobin
(B) Batch processing        (2) Scan
(C) Time sharing            (3) LIFO
(D) Stack operation         (4) FIFO

A - 3, B - 4, C - 2, D - 1
A - 4, B - 3, C - 2, D - 1
A - 3, B - 4, C - 1, D - 2
A - 2, B - 4, C - 1, D - 3

Question 77

Consider three CPU-intensive processes, which require 10, 20 and 30 time units and arrive at times 0, 2 and 6, respectively. How many context switches are needed if the operating system implements a shortest remaining time first scheduling algorithm? Do not count the context switches at time zero and at the end.
[ISRO 2009]

1
2
3
4

Question 78

Consider a set of 5 processes whose arrival time, CPU time needed and the priority are given below:

Process       Arrival Time   CPU Time Needed     Priority
              (in ms)
P1              0             10                 5
P2              0             5                  2
P3              2             3                  1
P4              5             20                 4
P5              10            2                  3

(smaller the number, higher the priority) If the CPU scheduling policy is priority scheduling without preemption, the average waiting time will be
[ISRO CS 2009]

12.8
11.8
10.8
9.8

Question 79

Process is:
[ISRO CS 2009]

A program in high level language kept on disk
Contents of main memory
A program in execution
A job in secondary memory

Question 80

Four jobs to be executed on a single processor system arrive at time 0 in the order A, B, C, D . Their burst CPU time requirements are 4, 1, 8, 1 time units respectively. The completion time of A under round robin scheduling with time slice of one time unit is
[ISRO 2008]

10
4
8
9

Question 81

Which of the following need not necessarily be saved on a context switch between processes? [ISRO CS 2008]

General purpose registers
Translation look-aside buffer
Program Counter
All of the above

Question 82

With Round-Robin CPU scheduling in a time shared system – [ISRO CS 2008]

using very large time slices (quantas) degenerates into First Come First served (FCFS) algorithm.
using extremely small time slices improves performance
using very small time slices degenerates into Last-In First-Out (LIFO) algorithm.
using medium sized times slices leads to shortest Request time First (SRTF) algorithm

Question 83

What is the name of the operating system that reads and reacts in terms of operating system? [ISRO CS 2008]

Batch System
Quick response time
Real Time System
Time Sharing System

Question 84

Fork is: [ISRO CS 2008]

The creation of a new job
The dispatching of a task
Increasing the priority of a task
The creation of a new process

Question 85

The performance of Round Robin algorithm depends heavily on [ISRO CS 2008]

Size of the process
The I/O bursts of the process
The burst size of processes
The size of the time quantum

Question 86

Match the following:
List – I List – II
(a) Spooling (i) Allows several jobs in memory to improve CPU utilization
(b) Multiprogramming (ii) Access to shared resources among geographically dispersed computers in a transparent way
(c)Time sharing (iii) Overlapping I/O and computations
(d)Distributed computing (iv) Allows many users to share a computer simultaneously by switching processor frequently

codes:
(a) (b) (c) (d)
(1) (iii) (i) (ii) (iv)
(2) (iii) (i) (iv) (ii)
(3) (iv) (iii) (ii) (i)
(4) (ii) (iii) (iv) (i)

(1)
(2)
(3)
(4)

Question 87

Dining Philosopher’s problem is a: [UGC NET CS 2015 June – Paper III]

Producer - consumer problem
Classical IPC problem
Starvation problem
Synchronization primitive

Question 88

Consider a set of n tasks with known runtimes r₁, r₂….r_n to be run on a uniprocessor machine. Which of the following processor scheduling algorithms will result in the maximum throughput? [ISRO CS 2007]

Round Robin
Shortest Job First
Highest response ratio next
First Come First Serve

Question 89

Round Robin schedule is essentially the pre-emptive version of [ISRO CS 2007]

FIFO
Shortest Job First
Shortest Remaining Time
Longest Remaining Time

Question 90

A task in a blocked state: [ISRO CS 2007]

is executable
is running
must still be placed in the run queues
is waiting for some temporarily unavailable resources

Question 91

On a system using non-preemptive scheduling, processes with expected run times of 5, 18, 9 and 12 are in the ready queue. In what order should they be run to minimize wait time? [ISRO cs 2007]

5, 12, 9, 18
5, 9, 12, 18
12, 18, 9, 5
9, 12, 18, 5

Question 92

Feedback queues [ISRO CS 2007]

are very simple to implement
dispatch tasks according to execution characteristics
are used to favor real time tasks
require manual intervention to implement properly

Question 93

Which of the following conditions does not hold good for a solution to a critical section problem ? [UGC NET CS 2014 DEC II]

No assumptions may be made about speeds or the number of CPUs.
No two processes may be simultaneously inside their critical sections.
Processes running outside its critical section may block other processes.
Processes do not wait forever to enter its critical section.

Question 94

For switching from a CPU user mode to the supervisor mode following type of interrupt is most appropriate [UGC NET CS 2014 DEC III]

Internal interrupts
External interrupts
Software interrupts
None of the above

Question 95

In a dot matrix printer the time to print a character is 6 m.sec., time to space in between characters is 2 m.sec., and the number of characters in a line are 200. The printing speed of the dot matrix printer in characters per second and the time to print a character line are given by which of the following options? [UGC NET CS 2014 DEC III]

125 chars/second and 0.8 seconds
250 chars/second and 0.6 seconds
166 chars/second and 0.8 seconds
250 chars/second and 0.4 seconds
125 chars/second and 1.6 seconds

Question 96

Monitor is an Interprocess Communication (IPC) technique which can be described as [UGC NET 2014 CS DEC III]

It is higher level synchronization primitive and is a collection of procedures, variables, and data structures grouped together in a special package.
It is a non-negative integer which apart from initialization can be acted upon by wait and signal operations.
It uses two primitives, send and receive which are system calls rather than language constructs.
It consists of the IPC primitives implemented as system calls to block the process when they are not allowed to enter critical region to save CPU time.

Question 97

The following C program
main() { fork() ; fork() ; printf ("yes"); }
If we execute this core segment, how many times the string yes will be printed ? [ISRO CS 2018]

Only Once
2
4
6

Question 98

Here are the two concurrent process P1, P2 with respective codes: P1 code:
while (true) // infinite condition { A :____; printf("%d", 1); printf("%d", 1); B:____; }
P2 code:
while (true) // infinite condition { C:____; printf("%d", 0); printf("%d", 0); D:____; }
What should be the binary semaphore operation on A,B,C,D respectively and what must be the intial values of semaphore M,N inorder to get the output 110011001100….? Where P is down and V is up operation respectively.

A = P(N), B = V(M), C = P(M), D = V(N); M = 0, N = 1;
A = P(N), B = V(M), C = P(M), D = P(N); M = N = 1;
A = P(N), B = V(N), C = P(M), D = V(M); M = 1, N = 0;
A = P(N), B = V(N), C = P(M), D = V(M); M = N = 1;

Question 99

At a particular time of computation, the value of a counting semaphore is 10. Then 12 P operations and “x” V operations were performed on this semaphore. If the final value of semaphore is 7, x will be: [UGC NET CS 2018 JULY II]

8
9
10
11

User level thread	Kernel level thread
User thread are implemented by user processes.	kernel threads are implemented by OS.
OS doesn’t recognized user level threads.	Kernel threads are recognized by OS.
Implementation of User threads is easy.	Implementation of Kernel thread is complicated.
Context switch time is less.	Context switch time is more.
Context switch requires no hardware support.	Hardware support is needed.
If one user level thread perform blocking operation then entire process will be blocked.	If one kernel thread perform blocking operation then another thread can continue execution.
Example : Java thread, POSIX threads.	Example : Window Solaris.

User level thread	Kernel level thread
User thread are implemented by user processes.	kernel threads are implemented by OS.
OS doesn’t recognized user level threads.	Kernel threads are recognized by OS.
Implementation of User threads is easy.	Implementation of Kernel thread is complicated.
Context switch time is less.	Context switch time is more.
Context switch requires no hardware support.	Hardware support is needed.
If one user level thread perform blocking operation then entire process will be blocked.	If one kernel thread perform blocking operation then another thread can continue execution.
Example : Java thread, POSIX threads.	Example : Window Solaris.

Quiz – Process Management

Quiz-summary

Information

Results

Categories

Related

What do you think about the article? Cancel reply