Event Requests
Processes
CPU (single slot)
Ready
I/O
Terminated
No process data yet. Create a process and advance the clock to see state presence tracking.
Current State Summary
No active processes. Create a process to see state information.
State Transition History
No transitions recorded yet. Interact with the simulation to see history.
Learn about the different states a process can be in during its life cycle.
Objective:
Identify the different process states in the legend and understand their meanings
Instructions:
Observe the process visualization. Each process can be in one of four active states: Ready (blue, waiting for CPU), CPU (green, executing), I/O (yellow, waiting for I/O completion), or Terminated (dark gray). Processes start as Not Created (gray) before being initialized.
Hint:
Look at the legend in the controls panel to see all possible process states and their color coding
Event Requests
Processes
CPU (single slot)
Ready
I/O
Terminated
No process data yet. Create a process and advance the clock to see state presence tracking.
Current State Summary
No active processes. Create a process to see state information.
State Transition History
No transitions recorded yet. Interact with the simulation to see history.
Learn process life cycle management through interactive, step-by-step guided scenarios with immediate feedback and hints.
Move a single process through a valid life cycle: Ready → CPU → Ready → Terminated
Learning Objectives:
- Allocate CPU to a ready process
- Preempt the process back to Ready
- Terminate the process from Ready state using a terminate event
Only one process may occupy the CPU at a time. The second attempt is blocked.
Learning Objectives:
- Understand that the CPU is a single exclusive slot
- Observe the error when a second process tries to enter CPU
- Learn to free the CPU before dispatching another process
Complete the full I/O cycle: Ready → CPU → I/O → Ready → Terminated
Learning Objectives:
- Understand I/O as a blocking wait state
- Use io_needed to move a process from CPU to I/O
- Use io_done to return a process from I/O to Ready
- Complete the full life cycle with an I/O detour
Discover which transitions are invalid and understand why they are rejected.
Learning Objectives:
- Attempt Ready → I/O and observe the rejection
- Attempt I/O → CPU and observe the rejection
- Attempt CPU → Terminated and observe the rejection
- Understand the valid transition diagram
- Complete the process via the correct path
Manage three processes with independent life cycles and concurrent I/O.
Learning Objectives:
- Understand that I/O does not block other processes globally
- Interleave CPU and I/O across multiple processes
- Complete all three process life cycles
Events are state-dependent. Triggering an event on a process in the wrong state fails.
Learning Objectives:
- Understand that events are tied to specific process states
- Observe that I/O completion fails if the process is not in I/O
- Learn the correct event-to-state mapping
One process waits in Ready while another executes. Ready = waiting for CPU.
Learning Objectives:
- Understand that Ready means 'waiting for CPU allocation'
- Observe a process staying in Ready while another runs
- Terminate both processes sequentially
Two processes with different life cycle paths: one terminates early, the other uses I/O first.
Learning Objectives:
- Terminate one process from Ready after brief CPU execution (short life cycle)
- Move the other through I/O before terminating from Ready (long life cycle)
- Understand that processes can have varying life cycle lengths
Three processes in mixed states. Explore valid and invalid actions freely with minimal guidance.
Learning Objectives:
- Explore all valid transitions from various starting states
- Test invalid transitions to reinforce understanding
- Terminate all processes through valid paths
Comprehensive scenarios to evaluate your understanding of process states, valid transitions, and event-driven state changes.
Move a single process through a valid life cycle: Ready, CPU, Ready, Terminated.
Objectives:
- Allocate CPU to the ready process
- Preempt the process back to Ready
- Terminate the process from Ready state
Two processes compete for the CPU. Only one may execute at a time.
Objectives:
- Move the first process to CPU
- Observe that the second process is blocked from CPU
- Preempt or move the first process before dispatching the second
Move a process through the full I/O cycle: Ready, CPU, I/O, Ready, Terminated.
Objectives:
- Allocate CPU to the process
- Move the process to I/O when io_needed appears
- Complete I/O and return to Ready
- Terminate the process from Ready state
Explore which transitions are invalid and understand why they are rejected.
Objectives:
- Attempt to move a Ready process directly to I/O
- Attempt to terminate a process from CPU (invalid)
- Observe rejection messages for each invalid attempt
- Complete the process via the correct path (terminate from Ready)
Manage three processes with independent life cycles and concurrent I/O.
Objectives:
- Move one process to I/O while another uses CPU
- Demonstrate that I/O does not block other processes
- Complete life cycles for all three processes
Understand that events are state-dependent: triggering I/O completion while not in I/O is invalid.
Objectives:
- Observe that I/O completion only works for processes in I/O state
- Attempt to trigger events on processes in wrong states
- Complete the process via the correct event sequence
One process waits in Ready while the other executes on CPU.
Objectives:
- Move one process to CPU while the other remains in Ready
- Observe that Ready means waiting for CPU allocation
- Preempt the first process to Ready and terminate it, then dispatch the second
Two processes with different life cycle paths: one terminates early, the other performs I/O first.
Objectives:
- Terminate the first process from Ready state (after CPU execution)
- Move the second process through I/O before terminating
- Observe lifecycle variability between processes
Three processes in mixed initial states. Explore valid and invalid actions freely.
Objectives:
- Explore all valid transitions from various starting states
- Handle processes already in Ready, CPU, and I/O states
- Terminate all processes through valid paths