Group 2

Name Matric No.

ALARAN AL AMEEN ISHOLA S122202013
KAZEEM OKIKIOLA EL FAYYD S122202014
LATEEF PELUMI AYOMIDE S122202015
ODUNSI IBRAHIM AYOMIDE S122202016
FAVOUR FOLORUNSO S122202017
YUSUPH MUHAMMED AWWAL T S122202018
AKANJI FAHEEDAT FOLAKE S122202019
YUSUF HAWAWU MORENIKEJI S122202021
OLALEYE ADIJAT S122202020
AGORO OLUWAFERANMI ABDULAZIM S122202043

Topic: Context Switching

Course Code: Cps 303
Lecturer In-charge: Mrs Shodunke
 Context Switching
Introduction to Context Switching
In modern computing systems, the ability to handle multiple processes or threads
simultaneously is essential for efficiency and responsiveness. This is where context switching
comes into play. Context switching is the process by which a CPU transitions from executing one
task to another by saving the state (or context) of the current task and restoring the state of the
next task. This allows the operating system to share CPU time among multiple processes,
enabling multitasking and ensuring that high-priority tasks receive attention without delaying
others.
While context switching is crucial for managing system resources, it comes with
challenges, such as performance overhead. Understanding how context switching works, its
types, and best practices for minimizing it is key to optimizing system performance and
maintaining smooth operations in both traditional and real-time environments.

Definition of Context Switching

Context switching is saving the state of a currently running process or thread and loading
the state of another process or thread so the CPU can switch between them.
Context switching in real-time systems refers to the process of saving the state of a
currently running task (or thread) so that another task can be executed. This is a critical operation
in multitasking environments, particularly in real-time systems where meeting deadlines is
crucial.
Process Scheduling
Definition: Process scheduling is the activity of selecting a process from the ready queue
to be executed by the CPU.
 Goals:
 Maximize CPU utilization.
 Ensure fairness among processes.
 Minimize waiting time, turnaround time, and response time.
 Types:
 Pre-emptive Scheduling: The running process can be interrupted and
moved back to the ready queue if a higher-priority process arrives (e.g.,
Round Robin, Priority Scheduling).
 Non-Pre-emptive Scheduling: The running process is allowed to
complete its CPU burst before the scheduler selects another process (e.g.,
First Come First Serve, Shortest Job Next).
Relationship between Scheduling and Context Switching

 Trigger: A context switch occurs when the process scheduler selects a different process
to run.
 Overhead: Context switching involves a performance overhead since saving and loading
process states take time (CPU cycles).
 Scheduling Criteria: The efficiency of scheduling impacts how often context switches
occur. For example:
o In a round-robin scheduler, frequent context switches are common due to time
slicing.
o In Priority Scheduling, context switches occur only when a higher-priority process
arrives.

Efficiency Factors

 Switching Time: Shorter context switch times are crucial to minimize CPU idle periods.
 Scheduling Algorithm: Choosing an algorithm that balances process fairness and context
switch overhead is key.
 Process Characteristics: CPU-bound processes result in fewer context switches than
I/O-bound processes.

By balancing process scheduling and minimizing the cost of context switching, an operating
system ensures smooth multitasking and optimal resource utilization.

Types of Context Switching

 Process to Process Switching: Switching between two different methods.
 Thread to Thread Switching: Switching between threads within the same process.

Importance of Context Switching in Multitasking Environments

Context switching plays a crucial role in multitasking environments, particularly in
computer systems, where it allows multiple processes or threads to be managed simultaneously
by a single CPU. Here’s why it's important:

 Resource Efficiency: By enabling the CPU to rapidly switch between tasks, context
switching allows multiple processes to share system resources, such as memory and CPU
time, efficiently. This ensures that the system can handle several tasks at once, even if
there is only one processor.
  Responsiveness: In environments where real-time processing is important (e.g.,
interactive applications or operating systems), context switching ensures that the system
can quickly respond to user inputs or external events by pausing one task and
immediately shifting to a higher-priority task.
 Task Isolation: Context switching helps maintain separation between processes,
ensuring that one task doesn’t interfere with or corrupt the state of another. Each process
or thread has its context (e.g., registers, program counter), allowing the system to switch
between them without interference.

 Load Balancing: In a multitasking environment, context switching allows the operating

system to balance the load across tasks. This helps avoid overloading any single process
or thread, improving overall system performance and stability.

 Multithreading and Parallelism: While true parallelism requires multiple processors,

context switching allows for the illusion of parallelism in a single-core processor. It
enables the system to handle multiple threads or processes concurrently, improving
throughput.

 Fairness: In a time-sharing system, context switching ensures that all processes receive a
fair share of CPU time. The operating system can allocate CPU time slices to each
process in turn, preventing any single task from monopolizing the system. However,
while context switching is essential for multitasking, it comes with some costs.

Switching between tasks involves saving and restoring process states, which can introduce
overhead and reduce overall system performance, especially when switches occur frequently.

Overhead and Performance Implications of Context Switching

 State Saving and Loading: During a context switch, the CPU saves the current process’s
state (e.g., registers, program counter, stack pointer) and loads the new process’s state.
This requires time and resources, delaying task execution.
  Memory and Cache Effects: Switching between processes may lead to invalidated CPU
caches (e.g., L1, L2 caches). The new process might not find its data in the cache,
causing cache misses and additional memory fetches, slowing execution.

 Kernel Mode Switch: A context switch usually requires transitioning into kernel mode,
where the operating system’s scheduler decides the next task to run. This switch incurs
additional latency.

Performance Implications
 Increased Latency: Context switching introduces delays, particularly in real-time or
interactive systems where frequent switches reduce responsiveness.

 Reduced CPU Efficiency: Time spent on saving/loading states and cache reloading is
time not spent executing processes, reducing effective CPU throughput.

 Higher Power Consumption: Frequent context switching prevents the CPU from
entering low-power states, increasing energy use in mobile and embedded systems.

 System Scalability Issues: Excessive context switching, often termed thrashing, can
overwhelm the CPU, especially in systems with numerous processes or threads,
degrading performance.

Best Practices for Minimizing Context Switching:

 Optimize the number of threads and processes to reduce unnecessary switches:
Imagine you’re cooking a meal. If you try to juggle too many dishes at once, you might
burn the food or make mistakes. Similarly, by limiting the number of active threads or
processes in a computer, you can ensure each task gets the attention it needs without
unnecessary delays or errors.
 Use efficient scheduling algorithms:
Think of this as creating a well-organized daily schedule. If you allocate specific times
for specific tasks, you can focus better and accomplish more. In computing, efficient
 scheduling algorithms help the system decide which task to run next, reducing the time
spent switching between tasks.
 Group similar tasks together to limit switching:
Picture cleaning your house. If you clean the kitchen, then the living room, and finally the
kitchen again, you waste time switching. Instead, group all kitchen tasks together to
finish one area before moving to the next. Similarly, in computing, grouping similar tasks
together minimizes the need for frequent switching, making processes more efficient.

Context Switching in Operating Systems

Context switching in operating systems refers to the process where the CPU changes
from executing one process to executing another. This involves saving the current state (context)
of the running process so it can be resumed later and loading the saved state of the new process
to be executed. This allows the operating system to manage multiple processes efficiently, giving
the appearance that they are running simultaneously.
Context Switching in Real-time Systems
Real-time systems prioritize tasks based on strict timing requirements. Context switching
must be minimal and quick to avoid missing deadlines.

Impact of Context Switching on System Resources

Context switching can impact system resources in several ways, including:
 CPU cycles
o Context switching consumes CPU cycles by saving and restoring process states,
such as register values, program counters, and stack pointers.
 Resource contention
o Context switching can lead to resource contention, especially in multi-core
systems. This can reduce the efficiency of resource utilization.
 Cache thrashing
o Context switching can cause cache thrashing, where the CPU spends more time
switching between processes than executing.
 Interrupt handling
o Context switches often occur in response to interrupts or system calls, which
require additional processing overhead.
 System slowdown
Excessive context switching can slow down the system and even lead to unresponsiveness.
Context Switching in Virtualized Environments
In virtualized systems, context switching occurs between virtual machines (VMs) and
processes within them. This adds extra overhead, as the hypervisor handles switching.