Lecture Notes for Operating Systems Concepts

21 September 2004 - Process Management

Outline

Process management.
The hardware process.
The abstract machine.
The process abstraction.

Computations and Processes

A computation is an abstraction of a user.
- This is not the only useful user abstraction.
  - Security level, service class, ...
A process is an abstraction of a computation.
- An abstraction implemented by the OS.

Hardware Abstraction

To the hardware, a user looks like a process.
What does the hardware look like to the user and process?
A virtual machine is the OS abstraction of hardware.

Virtual Machines

A process executes in a virtual machine.
- Each process has a virtual machine, or
- processes share a virtual machine.
- It depends on what the OS implements.
Think of a virtual machine as a custom hardware system.
- "Custom" comes from abstraction.
- For example, hide or reveal multiple CPUs.

The System-Call Interface

What does a virtual machine look like?
A virtual machine presents a system-call interface to processes (and users).
A system-call interface is a set of procedure-like prototypes.
```
ssize_t read(int, void *, size_t);
```
- Each prototype is a system call.
Different system-call interfaces are different virtual machines.

Process vs. Process

My world has processes and threads.
Other worlds have heavyweight processes, lightweight processes and threads.
- Nutt's world has classic processes, modern processes and threads.
My world has problems with threadless OSs (FreeBSD).
- But its simpler, consistent, and becoming truer.

The Process Abstraction

What does a process look like?
A process is the set of (almost) all resources needed by a computation.
- The missing resource is the CPU.

Process Managers

The process manager is the part of the OS responsible for implementing processes.

The Abstract Machine

The virtual (or abstract) machine is defined by what the hardware provides and the way the OS abstracts it.
- The OS can ignore features that exist or simulate features that don't.
The end result is the system-call interface.
- Different OSs provide different system-call interfaces.
- The same OS may provide different system-call interfaces.

The System Call

A system call may look like a procedure, but it's not.
A system call transfers control from the user's process to the OS.
- Regular procedures stay in the the user's process (or at least out of the OS).
The control transfer is provided by hardware.

Process Implementation

A process is a bag of resources. How's it implemented?
A stuct of fields, each field representing a particular resource.
- A struct instance is called a process descriptor (or process control block or task control block or ...).
There are alternate implementations.

The Process Table

Process descriptors are usually stored in an array called the process table.
A Process ID is an index into the process table.
There are alternate implementations here too.
- Usually a level of indirection between the table and the entries.

The Thread Abstraction

A computation has active and passive parts.
A process is a resource set; it's passive.
A thread is the active part of a computation.
A computation is one or more threads in a process.

Threads and Processes

A thead executes, a process doesn't. Why the split?
A thread is an abstraction of the CPU, which is handy.
- A single CPU but many threads.
Multiple threads running in the same process.

Thread Resources

What resources does a thread need to execute?
- The CPU. What else?
Execution state: program counter, registers, run-time stack.
Process information: the host process, other threads in the host process.
General information: run-time statistics, signal masks, and so on.

Thread Descriptors

Thread resources cannot be shared among threads.
Thread resources are stored in a thread descriptor.
Each thread gets its own thread descriptor.
A computation needs thread descriptors to run.
- Thread descriptors are stored in the computation's process.

Thread Management

Thread management consists of
- Creating and deleting threads.
- Managing thread resources and descriptors.
- Migrating threads among processes.
- Moving threads into and out of the CPU.
This is mainly the scheduler's job.

The Thread-Process Split

Managing processes is much harder than managing threads.
- The complexity of the data involved.
- The complexity of the operations involved.
- Just the size of the descriptors.
Avoid managing process in favor of threads.
- The origin of heavyweight vs. lightweight processes.

Computation State

A computation's (thread + process) life:
A computation can be in one of three states.
- Unexecuted, executing, or done executing.
A computation's state characterizes
- What the computation is currently doing.
- What the computation could be doing.

Process State

A computation's state is called the process state.
- Even though the process is passive.
The OS designer determines the
- set of possible process states and
- the way process in one state can go to another state.
Process states and state changes are a useful way to understand an OS.

State Transitions

A change in process state is called a process-state transition.
Process-state transitions are caused by
- actions taken by the process or
- actions internal to the OS.
Process actions include system calls and illegal-address (seg-fault) exceptions.
OS internal actions include timer exipry or power-off interrupts.

Process-State Diagrams

An OS's process states and transitions can be modeled as a directed, labeled graph called a process-state diagram.
- The nodes are the process states.
- The edges are the transitions.
- The edge labels are the actions causing the transition.
The unexecuted and done executing states are usually omitted.

State-Diagram Example

Consider the first programming assignment.
A process can be either executing or ready to execute.
A process can be execed to readiness, or can it can yield to ready, or the scheduler can make it ready.
- Except for the initial process.
The scheduler makes a process running.
A process exits into oblivion.

Assignment 1 State Diagram

The corresponding process state diagram is
The put_slot() and get_slot() system calls don't change process state.

Inter-Process Relations

What's the relation between two processes executing in a system?
Security says "none"; each is isolated from the other, as it should be.
That answer may be too strict.
- Groups of processes may want to cooperate.
- Other structure (hierarchies) may simplify process management.

Process Hierarchy

One processes running another leads to a tree hierarchy.
- The parent creates the children.
An OS can maintain this hierarchy using pointers to process descriptors.

Hierarchy Management

Processes can share control and data along hierarchy lines.
- Control sharing occurs through the process's lifetime.
- Data sharing is usually done only at child-create time.
The OS can off-load to the parent some management responsibilities.

Hierarchy Problems

Sharing along indirect or non-existent lines is hard.
- Two siblings sharing with each other.
Establishing dynamic sharing patterns is hard.
- An on-going role-playing game.

hierarchy problems

This page last modified on 14 November 2004.