GATE CSE 2011 | Question: 6, UGCNET-June2013-III: 62

Question

Let the time taken to switch from user mode to kernel mode of execution be $T1$ while time taken to switch between two user processes be $T2$. Which of the following is correct?

• A. $T1 > T2$
• B. $T1 = T2$
• C. $T1 < T2$
• D. Nothing can be said about the relation between $T1$ and $T2$

Comments

context switch from P1 to P2 including follwing things happpen

 1.p1 user mode to kernal mode (because p1 saved pCB in kenral reason is PCB info is very sensitive so ..put it in privillaged area)

2.p2 kernal mode to User mode (P2 goes to kernal because its PCB info in Kernal so restore it and come to user continue excution)

  so we clearly observe t1 is subset of t2

---

If it were thread switching, would the kernel-to-user mode transition time be less?

---

The correct option is C. T1 < T2.

---

💡Trap in this question is confusing a mode switch with a context switch (process 1 to process 2 switch).

• T1 is a Mode Switch: The CPU changes its privilege level from user mode to kernel mode (e.g., during a system call). The process running on the CPU stays exactly the same. No heavy memory or cache flushes are required. This is incredibly fast.
• T2 is a Context Switch: The CPU must completely stop running the current process, save its entire state (registers, program counter, memory maps), and load the state of a completely different user process. This requires flushing CPU caches, altering TLB mappings, and executing scheduler code. This is significantly slower.

Because a process context switch (T2) includes a mode switch plus a massive amount of state-saving and memory management overhead, T2 will always take longer than T1.

Answer 1

Time taken to switch two processes is very large as compared to time taken to switch between kernel and user mode of execution because :

When you switch processes, you have to do a context switch, save the PCB of previous process (note that the PCB of a process in Linux has over $95$ entries), then save registers and then load the PCB of new process and load its registers etc. 

When you switch between kernel and user mode of execution, OS has to just change a single bit at hardware level which is very fast operation.

So, answer is: (C).

Comments

T2 is a superset of T1. 

$T1$ : User (save the process state. Then make a system call and switch to) → Kernel Mode

$ T2$: User Process (All of $T1$ (now in kernel mode) + Schedule $P2$ (load context from PCB) + Change mode bit and move to ) → User Process

Therefore Option $C) \ T1<T2$

---

Switching between kernel and user mode is  much faster  than a full context switch between processes, but it involves more than just flipping a bit.

---

@rohith1001
Brother, you said so well. Also related an old PYQ. Very nice comment

Answer 2

Context switches can occur only in kernel mode. So, to do context switch first switch from user mode to kernel mode and then do context switch (save the PCB of the previous process and load the PCB of new process)

Context switch = user - kernel switch + save/load PCB + kernel-user switch

C is answer.

Comments

Mode switch doesnot involve a context switch whereas a context switch definitely needs a mode switch as context switch is done by the dispatcher which is a portion of OS code ... And as we know OS code can run only in kernel mode so we need a mode change while doing a context switch ...

---

pefect answer for the question

---

if context switch is only done in kernel mode then why context switching between user level threads is faster than context switching between kernel level threads?

---

Even when CPU switches from user mode to kernal mode then also we need to save the context of current executing process? correct me if i am wrong!!!!!!

---

And Mode Switch only has to flip Mode bit.

In Case of Context Switch in a Virtual Memory system with TLB,

TLB might need to be flushed, Memory Map of MMU needs to be changed, along with context save of preempted process and context restore of the process being resumed.

---

Kernel-level context switch involves changing a large set of processor registers, security level(privilege) and cache of processor,

User-level context switch involves a procedure call for small amount of bookkeeping within one kernel thread or process.

---

reply to @Manish11102 
User-level threads are "fast" because they do not require a kernel call. However, they have a major drawback: if one user-level thread performs a blocking system call, the entire process (including all its other threads) blocks because the kernel only sees one single process.
- GALVIN 
BUT THE MAIN THING HERE IS why ULT are faster than KLT?   One of the reasons is ---

During KLT switch, since the kernel manages these threads, any switch between them requires a mode switch to kernel mode.
User-Level Threads (ULT): These are managed by a thread library in user space. The kernel is unaware of them. When one ULT switches to another, the library simply saves the current thread's registers and restores the registers of the next thread—all within user mode. No trap to the kernel is required, and no mode switch (changing the bit from 1 to 0) occurs.

---

@Sunirmal_Shaw,

Just got a notification on Gmail regarding your reply to my comment after 8 years. Hahaha!

I just want to say thanks for the reply. Even after 8 years, I can still say that GateOverflow is one of the biggest reasons behind my very good rank in GATE.

Thanks to GateOverflow for creating such a platform where anyone can resolve their doubts through meaningful discussions.

Answer 3

Context switching can be described in slightly more detail as the kernel (i.e., the core of the operating system) performing the following activities with regard to processes (including threads) on the CPU: (1) suspending the progression of one process and storing the CPU's state (i.e., the context) for that process somewhere in memory, (2) retrieving the context of the next process from memory and restoring it in the CPU's registers and (3) returning to the location indicated by the program counter (i.e., returning to the line of code at which the process was interrupted) in order to resume the process.

Context switches can occur only in kernel mode. Kernel mode is a privileged mode of the CPU in which only the kernel runs and which provides access to all memory locations and all other system resources. Other programs, including applications, initially operate in user mode, but they can run portions of the kernel code via system calls.

http://www.linfo.org/context_switch.html

Answer 4

The simple answer with a easy approach. 🕺

Answer 5

Switching from user mode to kernel mode ($T1$) is known as a mode switch, which happens during system calls, interrupts, or exceptions.

In a mode switch ($T1$), the execution shifts to kernel space within the context of the same process, meaning the memory mapping, page tables, and TLB remain completely unchanged.

Switching between two separate user processes ($T2$) is a full process context switch, which is a much more complex operation managed entirely by the operating system scheduler.

A process context switch ($T2$) requires saving the registers of the old process, loading the registers of the new process, switching the control of memory by changing address translation tables (page tables), and dealing with TLB invalidation.

Since a process context switch ($T2$) includes a change in memory management structures along with multiple mode switches to execute the scheduler code, it inherently takes significantly more overhead and time than a simple mode switch ($T1$).

Therefore, the time taken for a mode switch is strictly less than the time taken for a process context switch:

$$T1 < T2$$

Correct Option: C

Answer 6

c As cs between processes involve loading processor state cpu registers into ram.