Shortest Job First (SJF) Visualizer

Shortest Job First (SJF) Visualizer

An interactive way to understand the SJF CPU Scheduling Algorithm.

Controls & Processes

Arrival Time

Burst Time

Process Queue

Simulation Speed

Slower Faster

Live Visualization

Current Time: 0

CPU Status

IDLE

Ready Queue

CPU

Gantt Chart

Simulation Log

Results

Process ID	Arrival	Burst	Completion	Turnaround	Waiting

SJF Algorithm Explained

A Clear Guide to the Shortest Job First Algorithm

• Definition: A scheduling policy that selects the waiting process with the smallest execution time to execute next.
• Significance: Provably optimal for providing the minimum average waiting time for a given set of processes.

• Origins: Rooted in early batch processing systems of the 1950s and 60s.
• Evolution: Began as a manual process where human operators would sort punch cards to run shorter jobs first, improving system throughput. This evolved into the automated algorithm used today.

• Fundamental Principle: The processor is allocated to the process with the shortest CPU burst (execution time).
• Non-Preemptive SJF: Once a process starts, it runs to completion without interruption. The scheduler only picks a new process when the current one finishes.
• Preemptive SJF (SRTF): Also known as Shortest Remaining Time First. If a new process arrives with a burst time shorter than the remaining time of the current process, the current process is preempted (paused) and the new, shorter job runs.

• Batch Job Processing: In scientific computing, systems use estimates to prioritize shorter computational tasks.
• Disk Scheduling: The Shortest Seek Time First (SSTF) algorithm is a direct analogue, prioritizing disk reads that require the shortest physical movement of the disk head.
• Network Packet Routing: Priority queues in routers often fast-track small control packets over large data packets, a concept similar to SRTF.

• Benefits: Optimal average waiting time, high throughput, and conceptually simple.
• Limitations:
  • Prediction Problem: Requires knowing the future (CPU burst time), which is impossible for most interactive systems.
  • Starvation: Long processes may never get to run if there is a continuous stream of short processes.

• vs. FCFS: SJF is far more efficient than First-Come, First-Served, avoiding the "convoy effect" where short processes get stuck behind long ones.
• vs. Priority Scheduling: SJF is a specific type of priority scheduling where the priority is the inverse of the burst time. General priority scheduling is more flexible but also suffers from potential starvation.

Non-Preemptive SJF:

function NonPreemptiveSJF(processList):
  currentTime = 0
  while processes remain:
    add arrived processes to readyQueue
    if readyQueue is not empty:
      sort readyQueue by burstTime
      currentProcess = shortest job in queue
      execute currentProcess to completion
      currentTime += currentProcess.burstTime
    else:
      currentTime++

Preemptive SJF (SRTF):

function PreemptiveSJF_SRTF(processList):
  currentTime = 0
  while processes remain:
    add arrived processes to readyQueue
    if readyQueue is not empty:
      sort readyQueue by remainingTime
      currentProcess = job with shortest remaining time
      execute currentProcess for 1 time unit
      currentTime++
      if currentProcess is finished:
        remove from system
    else:
      currentTime++