1. The context is everything that can affect, or be affected by, the process: code, particular data values, open files, etc.

2. The execution stream is a sequence of instructions performed using that context.

Process States

Figure 3.4 goes here.

The Dispatcher

The Dispatcher is the inner-most portion of the O/S; it selects and runs processes:

1. Run a process for a while.

2. Save the process state.

3. Load state of another process.

4. Run it ...

The two-state model is not realistic. Not all processes are always ready to execute. Some processes in the Not-Running state are ready to run; others are blocked while waiting for an I/O to complete.

Do we want to keep all these processes on a single queue? No. The Dispatcher would have to scan the Not-Running queue looking for a process that is not blocked. We'd rather have the Dispatcher just take the first process on the queue. Less overhead.

It's more natural to separate the Not-Running state into two states: Ready and Blocked.

The Five-State Model A process is in one of five states:

• Running: Currently being executed on the CPU.

• Ready: Prepared to execute when given the opportunity.

• Blocked: Cannot execute again until some event occurs, e.g. completion of an I/O operation.

• New: Created but not yet added to the pool of executable processes.

• Exited: Released by the O/S from the pool of executable processes: halted, aborted, etc.

Figure 3.6 goes here.

Process Control

• How can several processes share one CPU? O/S must make sure that processes don't interfere with each other. This means:

• Making sure each gets a chance to run (fair scheduling).

• Making sure they don't modify each other's state (protection).

First, the O/S has to keep track of all the processes. For each process, the process control block (PCB) holds:

• Process identification information.

• Processor state information.

• Process control information

• Identity of the process.

• Identity of the parent process.

• Identity of the user.

• User-visible registers.

• Control and status registers.

• Stack pointers.

• Scheduling and state information: process state, priority, amount of time process has been waiting, event being waited for (if any), etc.

• Data structuring: links to other processes in system data structures (like ready queue), links to parent and children.

• Interprocess communication: information about flags, signals, messages used for communication with other processes (may not all be kept in PCB).

• Process privileges.

• Memory management: pointers to segment and/or page tables.

• Resource ownership and utilization: open files, amount of CPU time consumed so far and/or other accounting information.

CPU can only be doing one thing at a time: if user process is executing, Dispatcher isn't: O/S has lost control! How does O/S regain control of processor?

• Internal events (things occurring within user process). These are also called traps. They all cause a state switch into the O/S.
  • System call;

  • Error (illegal instruction, addressing violation, etc.);

  • Page fault.

• External events (things occurring outside the control of the user process). These are usually called interrupts. They all cause a state switch into the O/S.
  • Character typed at terminal;

  • Completion of disk operation (controller is ready for more work);

  • Timer: to make sure O/S eventually gets control.

When a process isn't running, its state must be saved in its PCB. What gets saved? Everything that next process could damage:

• Program counter;

• Processor status word (condition codes, etc.);

• General purpose registers;

• Floating-point registers;

• Entire address space?

Mode Switching

What does the CPU do when a trap or interrupt occurs?

1. Save the current processor state.

2. Set the program counter to the beginning of an interrupt handler routine.

3. Switch from user mode to kernel (supervisor, privileged) mode. Why? Interrupt handler may include privileged instructions.

4. Begin processing interrupt handler routine.

What does the interrupt handler do? It depends.

• External interrupt (character typed, completion of I/O, etc.): process interrupt, restore state of interrupted process, switch to user mode, resume interrupted process.

• Page fault: Call memory manager to fetch new page, restore state of interrupted process, switch to user mode, resume interrupted process.

• I/O request: Start I/O, call Dispatcher.

• Timer interrupt: call Dispatcher.

  Context Switching

  When the Dispatcher must select a new process to run on the CPU (timer interrupt, current process halts, current process blocked for I/O), a context switch occurs. Since the current process will not resume at the end of interrupt processing, the Dispatcher must do more:

  1. Save the processor state in PCB.

  2. Update PCB (state of process, accounting information).

  3. Move PCB to appropriate queue.

  4. Select another process to run (more about this later in the semester).

  5. Update the PCB of the selected process.

  6. Update memory-management data structures (more about this in about a month).

  7. Restore the previous context of selected process (program counter, PSW, registers).

  8. Resume execution of selected process.

  ---

  Creating Processes

  New Processes

  What must the O/S do to create a new process from scratch?

  1. Assign a unique process identifier (PID) to new process;

  2. Allocate space for the process:

  3. Load code and data into memory;

  4. Create an (empty) call stack;

  5. Create and initialize process control block.

  6. Make process known to Dispatcher.

  The Unix Fork

  The Unix fork makes a new copy of an existing process. For example, the shell makes a copy of itself for each command. One waits around; the other goes off and executes the command.

  1. Make sure process to be copied isn't running and has all state saved.

  2. Make a copy of code, data, stack.

  3. Copy PCB of source into new process.

  4. Make process known to Dispatcher.