Solution

The pages required to allocate 72,766 bytes = 72,766 bytes/2KB = 35.53. (36 pages)

So, the last page will lead to internal fragmentation = 36*2KB-72766 = 962 bytes.

Solution

A thread has no data segment or heap of its own. There can be more than one thread in a process. Each thread has its own stack.

Solution

Every process has its own unique PID in the system, and hence parent and child will have different PID. However, as the child gets an exact copy of the parent’s file descriptor table, the fd will be the same.

Solution

A wait-for graph can be constructed from a resource-allocation graph by eliminating the resources and collapsing the associated edges, as shown in the figure below.

If each resource category has a single instance, then we can use a variation of the resource-allocation graph known as a wait-for graph to detect deadlocks and, cycles in the wait-for graph indicate deadlocks.

Solution

Long term scheduler controls the degree of Multiprogramming.

Solution

Each bit in bit maps represents a block. So no.of blocks = 1GB/1KB = 2^30/2^10 = 2^20 = 1M blocks. Each block takes 1 bit for representation so 1Mb of space is required.

Solution

A system with R identical resources, P processes competing for them and N is the maximum need of each process, then the minimum number of resources required, so that deadlock will never occur is R >= P * (N - 1) + 1 => R >= 3*1+1 >= 4. So, the minimum is 4.

Solution

Compaction is a technique for overcoming external fragmentation

Solution

A dirty bit (or) modified bit is a bit that is associated with a block of computer memory and indicates whether or not the corresponding block of memory has been modified. The dirty bit is set when the processor writes to (modifies) this memory.

Solution

Working set(t,k) of a process at time t to be the collection of information referenced by the process during the process time interval (t-k,t).

Solution

Solution

FALSE: Starvation is not a condition for deadlock. It should be no preemption.

TRUE: Multilevel page tables use memory more efficiently for sparse address spaces than single level tables

FALSE: A system may exit from starvation, but not from deadlock (without external intervention).

FALSE: It is not implemented because it is impossible to predict the future.

Solution

Initial value of Semaphore is 10, then after 12 P operation value will be -2 now at this stage when 10 V operations will be performed then the value of Semaphore will be 8.

Solution

The above implementation uses test-and-set synchronization mechanism. Test-and-set instruction provides mutual exclusion and synchronization can be achieved. Test-and-set instruction provides mutual exclusion even when there are context switches within the critical region, because test-and-set instructions are executed atomically.

Solution

The sequence of access along seek time is given below

C (0.2), B (2.5), A (0.6), D (5.8), E (0.7), F (2.6) = 12.4 ms.

Solution

Since block pointers are 32 bits, total size = 2^(32) × 4096 = 2^(44) bytes maximum.

An inode has 13 + 4 + 1 + 1 = 19 pointers = 19×32bits = 76 bytes.

Hence, the number of inodes per block = ⌊4096/76⌋ = 53.

Solution

Solution

Solution

Solution

Solution

Solution

The number of page table entries = VAS/Page size = 2^36/2^10 = 2^26 entries.

Since, the physical address space is 32 bits, the page table entry is therefore 32 bits = 4 bytes long. So, the entire page table takes 2^26*4 bytes = 256MB.

The number of frames required to store this page table is thus, 256MB/1KB = 2^18

Solution

The number of pages in the virtual memory = 2^36/2^12 = 2^24 pages. But the level 3 page table has only 2^8 entries, so, one page table of level 3 can point to 2^8 pages only. So, we need 2^16 level-3 page tables.

Level 2: we need 2^16 entries in Level-2. But the level 2 page table has only 2^8 entries, so, one page table of level 2 can only point to 2^8 page tables of level-3, So, we need 2 level-2 page tables.

Level 1: We need 1 Level-1 page table to point to level-2 page tables.

So the total number of pages for storing all three levels page tables = (level-1 page tables) + (level-2 page tables) + (level-3 page tables) = 1+2+2^16 = 65539

Solution

In the given code, we have 4000 integers each of size 4 bytes. Page size is 4KB. Therefore, a frame can hold 4KB/4 bytes = 1024 integers. Therefore,

Page 0: holds 1024 integers A[0-1023].

Page 1: holds 1024 integers A[1024-2047]

Page 2: holds 1024 integers A[2048-3071]

Page 4: holds the last 928 elements A[3072-3999]

The above three frames are initially empty, so it causes 3 page faults. Using FIFO page replacement the frame containing Page 0 is replaced to contain Page 4, hence one more page fault. Hence, a total of 4 page faults.

Solution

The executable accesses the libraries at run time; therefore, multiple programs can access

the same library at the same time (saves memory), and hence the executable is smaller. When the library is changed, the code that references it does not usually need to be recompiled. However, in static linking every loaded program contains a duplicate copy of library routines.

Solution

Threads in a process can execute different parts of the program code at the same time. They can also execute the same parts of the code at the same time, but with different execution state:

i) They have independent current instructions; that is, they have (or appear to have) independent program counters.

ii) They are working with different data; that is, they are (or appear to be) working with independent registers.

Processes start out with a single main thread. The main thread can create new threads using a system call. The new threads can also use this system call to create more threads. Consequently, a thread not only belongs to a process; it also has a parent thread - the thread that created it.

Solution

Paging

i) eliminates the problem of external fragmentation and therefore the need for compaction.

ii) allows sharing of code pages among processes, reducing overall memory requirements.

iii) enables processes to run when they are only partially loaded in main memory (on demand paging)

iv) Translating from a virtual address to a physical address (memory access overhead) is more time consuming.

Solution

Priority inversion may occur from resource synchronization among processes of different priorities in a preemptive priority scheduling. Priority inversion may lead to starvation of a high priority process. Example of synchronization mechanism that may suffer from this issues is TSL.

Solution

Mutual exclusion is satisfied as one mutex is common between any two processes. Deadlock involves all three resources and three resources.

Solution

Solution

EMAT = h*(t+Tc) + (1-h)*(t+K*M+(1-P)*Tc)+P*(PFST)), where Tc = a*C + (1-a)*M

EMAT=186.35 ns

Solution

Lock variable : Mutual exclusion is not satisfied.

Strict alternation: Satisfies bounded waiting but no progress.

Peterson’s solution: Is correct implementation, which satisfies all the necessary properties.

Test-and-Set lock synchronization mechanism may suffer from livelock but no deadlock.

Solution

Given count=0, n=10.

Let us assume the assembly code for count=count+1 as

Read R0,count

Add R0,1

Write R0,Count

Note: The registers are local to each process. During context switch (preemption) the register contents are saved and reloaded. So, race condition on registers os not possible.

Process P1: Read R0,count

Add R0,1 // Preempt. So R0 contains 0.

Process P2: execute loop 10 times, end. Count value in memory is 10. [Complete]

Process P3: execute loop 10 times, end. Count value in memory is 20. [Complete]

Process P4: execute loop 9 times. Count value in memory is 29. Preempted.

Process P1: Write R0,Count, so count value in memory becomes 1. Preempted.

Process P4: Enters last iteration execute Read R0,count, so R0 has value 1. Preempted.

Process P1: execute loop 9 times. Count value in memory is 10.[Complete]

Process P4: execute Add R0,1 and Write R0,Count. So, the Count value in memory is 2. [Complete].