The data blocks of a very large file in the Unix file system are alloc

1.	The data blocks of a very large file in the Unix file system are allocated using
A.	contiguous allocation
B.	linked allocation
C.	indexed allocation
D.	an extension of indexed allocation
Answer» E.

Discussion

No Comment Found

Related MCQs

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 ?
Consider the following two phase locking protocol. Suppose a transaction T accesses (for read or write operations), a certain set of objects {O1; ...,Ok}. This is done in the following manner: Step 1. T acquires exclusive locks to O1,..., Ok in increasing order of their addresses. Step 2. The required operations are performed. Step 3. All locks are released. This protocol will
Consider the following proposed solution for the critical section problem. There are n processes: P0 ...Pn - 1. In the code, function pmax returns an integer not smaller than any of its arguments. For all i, t[i] is initialized to zero. Code for Pi: do { c[i] = 1; t[i] = pmax (t[0],..., t[n 1]) + 1; c[i] = 0; for every j i in{0,..., n 1} { while(c[j]); while(t[j] != 0 && t[j]
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-sex (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 : 1. The above solution to CS problem is deadlock-free. 2. The solution is starvation-free. 3. The processes enter CS in FIFO order. 4. More than one processes can enter CS at the same time.Which of the above statements is true?
The P and V operations on counting semaphores, where s is a counting semaphore, and defined as follows P(s): s = s 1; if s < 0 then wait; V(s): s = s + 1; if s < = 0 then we ke up a process waiting on s; Assume that Pb and Vb the wait and signal operations on binary semaphores are provided. Two binary semaphores Xb and Yb are used to implement the semaphore operations P(s) and V(s) as follows P(s): Pb (Xb); s = s 1; if (s < 0) { Vb (Xb); Pb (Yb); } else Vb (Xb); V(s): Pb (Yb); s = s + 1; if (s < = 0) Vb (Yb); Vb (Xb); The initial values of Xb and Yb are respectively
Two processes X and Y need to access a critical section. Consider the following synchronization construct used by both the processes Process X /* other code for process X */while (true) { varP = true; while (varQ == true) { /* critical section */ varP = false; } } /* other code for process X */ Process Y /* other code for process Y */ while (true) { varQ = true; while (varP == true) { /* critical section */ varQ = false; } } /* other code for process Y */ Here, varP and varQ are shared variables and both are initialized to false. Which one of the following statements is true?
Consider the intermediate code given below. (1) i = 1 (2) j = 1 (3) t1 = 5 * i (4) t2 = t1 + j (5) t3 = 4 * t2 (6) t4 = t3 (7) a[t4] = 1 (8) j = j + 1 (9) if j < = 5 goto (3) (10) i = i + 1 (11) if i < 5 goto (2)The number of nodes and edges in the control-flow-graph constructed for the above code, respectively, are
Which of the following will ensure that the output string never contains a substring of the form 01n 0 or 10n1 where n is odd?
Two processes P1 and P2, need to access a critical section of code. Consider the following synchronization construct used by the processes :/* P1 *//* P2 */while (true) { while (true){ wants1 = true; wants2 = true; while while (wants 1 = = true); (wants2 = = true); /* Critical /* Critical Section */ Section */ wants2 = false; wants1 = false; } /* Remainder section */ } (/* Remainder Section) Here, wants1 and wants2 are shared variables, which are initialized to false, Which one of the following statements is true about the above construct?
Consider the following policies for preventing deadlock in a system with mutually exclusive resources.i. Processes should acquire all their resources at the beginning of execution. If any resource is not available, all resources acquired so far are released. ii. The resources are numbered uniquely, and processes are allowed to request for resources only in increasing resource numbers iii. The resources are numbered uniquely, and processes are allowed to request for resources only in decreasing resource numbers iv. The resources are numbered uniquely. A process is allowed to request only for a resource with resource number larger than its currently held resources Which of the above policies can be used for preventing deadlock?

The data blocks of a very large file in the Unix file system are allocated using

Discussion

No Comment Found

Related MCQs

Reply to Comment