What's the difference between a context switch, a process switch and a thread switch in Linux?

Context switching is the fundamental mechanism that allows a multitasking operating system to share a single CPU among multiple processes and threads. It involves storing the current execution state so that it can be restored later, enabling seamless resumption from the same point.

Types of Context Switches

There are three main types of context switches in Linux, each with different overhead costs and complexity levels.

Context Switch (General)

A context switch is the general term for saving the current execution state (registers, program counter, stack pointer) of a running task and loading the state of another task. This enables the CPU to alternate between multiple tasks, creating the illusion of concurrent execution.

Process Switch

A process switch occurs when the operating system changes from executing one process to another. This involves:

• Saving all register values and processor state

• Storing the process's kernel state and memory management information

• Switching the virtual memory address space

• Invalidating the Translation Lookaside Buffer (TLB) cache

• Loading the new process's complete execution context

Thread Switch

A thread switch involves changing from one thread to another within the same process. Since threads share the same virtual address space, this operation is significantly lighter:

• Only thread-specific registers and stack pointer need saving/loading

• Virtual memory address space remains unchanged

• TLB cache entries remain valid

• Shared memory and file descriptors stay accessible

Performance Comparison

Key Differences

Conclusion

Process switches involve complete memory context changes and TLB invalidation, making them expensive operations. Thread switches within the same process are much faster since they preserve the virtual address space and cache state, requiring only basic register management.