Stored instructions and static data
An executable is a passive file. It does not have a current instruction, CPU registers, scheduling state or open runtime resources merely because it exists on storage.
PART 1 • EXECUTION FOUNDATIONS
See a Running Program as a Managed Process
A process is more than program code. Trace its changing state, inspect the Process Control Block that preserves its identity, and see exactly what the OS saves during a context switch.
BY THE END, YOU CAN
Track execution precisely
- Distinguish program, process and processor.
- Justify every process-state transition.
- Explain each major PCB field.
- Separate mode switch from context switch.
- Describe creation, fork, exec, wait and termination.
A Program Is Passive; a Process Is Active
The same executable file can support several independent processes, each with its own execution state and resources.
▶
load + state
A program in execution
A process includes code plus a program counter, registers, address space, stack, heap, open objects, credentials and OS bookkeeping.
Program counter
Identifies the next instruction for this process when it receives CPU time.
Address space
Provides the process’s protected view of code, data, heap, stack and mapped regions.
Resources
Open files, communication endpoints, credentials, timers and limits are associated with the process.
Identity
A process identifier and relationships let the OS distinguish, control and account for executions.
Five-State Process Model
A state answers one immediate question: what must happen before this process can execute or continue?
| State | Meaning | What moves it onward? |
|---|---|---|
| New | The OS is creating the process and its management structures. | Admission into the ready population. |
| Ready | The process has what it needs except a CPU. | Scheduler dispatches it. |
| Running | Its instructions are currently executing on a CPU. | Preemption, blocking, or completion. |
| Waiting / blocked | It cannot proceed until an event such as I/O completion occurs. | The awaited event completes, making it ready. |
| Terminated | Execution has ended; the OS is reclaiming remaining state. | Final cleanup and parent acknowledgement where applicable. |
Drive a Process through Legal State Transitions
Use only the enabled events. The simulator prevents impossible moves and explains each valid transition.
PROCESS CREATED
New process is being initialized
The OS is assigning identity and constructing the process’s management state before it can compete for CPU time.
The PCB Is the OS Record That Makes a Process Manageable
Select each field in the simplified Process Control Block to see why the OS needs it.
PCB • PID 4217
Process state
Records whether the process is new, ready, running, waiting or terminated.
Why it matters: The scheduler and event handlers use this field to decide whether the process is eligible to run and which transition is legal.
Processes Wait in Different Scheduling Structures
Job / admission collection
New work waits for the OS to admit it according to resource and policy limits.
P4217
P4218
Ready queue
Eligible processes wait for a CPU. Scheduling policy decides their order; “queue” need not imply simple FIFO.
P102
P305
P88
Device / event wait
Blocked processes are grouped by the event or resource whose completion can wake them.
Disk: P54
Pipe: P73
Watch the CPU Switch from One Process to Another
A context switch preserves enough of Process A to resume it later, then restores Process B’s saved execution state.
COST TO REMEMBER
Useful application work pauses during save, schedule and restore.
STEP 1 OF 8
PROCESS A • RUNNING
PROCESS A PC
0x4012A0
PROCESS B PC
0x52F010 (saved)
Process Creation Builds Identity, Resources and an Initial Context
Assign identity
Create a PID and parent/ownership relationships.
Create PCB
Initialize state, scheduling and accounting fields.
Prepare address space
Map program code, data, stack and required libraries.
Become ready
Place the process where the scheduler can select it.
fork(): create a new process
In Unix-like systems, fork creates a child with a new PID and a logical copy of the parent’s execution environment. Modern systems commonly use copy-on-write rather than immediately duplicating every physical page.
exec(): replace the current program image
Exec loads a new program into the calling process. The PID can remain the same because exec transforms an existing process—it does not necessarily create another one.
wait(): coordinate with a child
A parent can wait for child completion and collect its termination status, allowing the OS to release the remaining process record.
Parent and child execute independently
After creation, scheduler decisions determine which runs first. Source-code order alone does not guarantee whether the parent or child prints first.
Termination Ends Execution, but Cleanup May Have Stages
| Situation | Meaning | Important distinction |
|---|---|---|
| Normal exit | The program finishes or explicitly returns an exit status. | The OS closes/reclaims resources and records the status. |
| Abnormal termination | An unhandled fault, protection violation or external termination ends it. | One process can be ended without stopping all processes. |
| Zombie | The child has finished, but a small record remains until its parent collects status. | It is terminated and does not continue executing. |
| Orphan | A parent ends while its child is still running. | The child is still alive and is adopted/managed by a system process. |
Ten Misconception-Specific Checks
Every choice explains the exact reasoning error or correct principle.
Answered correctly: 0 of 10
University and Placement Questions
- Define a process.
- What is a PCB?
- Differentiate ready and waiting.
- What is a zombie process?
- Define context switch.
- Explain the five-state process model.
- Describe major PCB fields.
- Trace a context switch.
- Explain process creation and termination.
- Compare program and process.
- Why is context switching overhead?
- Does every system call switch processes?
- Why does I/O completion move waiting to ready?
- fork versus exec—what changes?
- Zombie versus orphan?
Show a strong answer: “Explain a context switch”
- State the trigger: timer, blocking event or scheduling decision.
- The kernel saves the outgoing process’s program counter, registers and required execution state in its PCB.
- It updates state/queues and selects an eligible process according to scheduling policy.
- The kernel restores the selected process’s memory context and saved CPU state.
- Execution resumes at that process’s saved program counter.
- Finish with cost: save/restore and cache effects perform no direct application work.
Show a strong answer: “Ready versus waiting”
A ready process needs only a CPU and can be selected by the scheduler. A waiting process cannot progress even if a CPU is free because it awaits an event such as I/O completion. When that event occurs, it normally becomes ready; it does not automatically become running.
LEVEL 3 SUMMARY
You Can Now Track a Process throughout Its Lifetime
- A process combines a program with live CPU, memory, resource and identity state.
- New, ready, running, waiting and terminated describe different scheduling conditions.
- The PCB stores what the OS needs to stop, manage and later resume execution.
- A context switch saves one process, schedules, then restores another; it is not merely a privilege change.
- fork creates a child, exec replaces a program image, and wait collects completion status.
COURSE CHECKPOINT
Mark Level 3 after you can justify every transition and explain what the PCB saves.
Saved only in this browser.