Context Switch

• Whenever an interrupt arrives, the CPU must do a state-save of the currently running process, then switch into kernel mode to handle the interrupt, and then do a state-restore of the interrupted process.
• Similarly, a context switch occurs when the time slice for one process has expired and a new process is to be loaded from the ready queue. This will be instigated by a timer interrupt, which will then cause the current process's state to be saved and the new process's state to be restored.
• Saving and restoring states involves saving and restoring all of the registers and program counter(s), as well as the process control blocks described above.
• Context switching happens VERY VERY frequently, and the overhead of doing the switching is just lost CPU time, so context switches ( state saves & restores ) need to be as fast as possible. Some hardware has special provisions for speeding this up, such as a single machine instruction for saving or restoring all registers at once.
• Some Sun hardware actually has multiple sets of registers, so the context switching can be speeded up by merely switching which set of registers are currently in use. Obviously there is a limit as to how many processes can be switched between in this manner, making it attractive to implement the medium-term scheduler to swap some processes out as shown in Figure 3.8 above.

1. It's address space, 
2. stack space, 
3. virtual address space,
4.  register set image (e.g. Program Counter (PC), 
5. Stack Pointer (SP), 
6. Instruction Register (IR), Program Status Word (PSW) 
7. other general processor registers), 
8. updating profiling or accounting information, 
9. making a snapshot image of its associated kernel data structures
10. updating the current state of the process (waiting, ready, etc).

address space,

stack space,

 virtual address space, 

register set image (e.g. Program Counter (PC),

 Stack Pointer (SP),

 Instruction Register (IR), 

Program Status Word (PSW)

 other general processor registers), 

updating profiling or accounting information,

 making a snapshot image of its associated kernel data structures 

 updating the current state of the process (waiting, ready, etc).