The Process Abstraction

hiding undesirable properties,

adding new capabilities, and

organizing information.

Disks are slow!

Chunks of storage are actually distributed all over the disk.

Disk storage may fail!

Growth and shrinking.

Organization into directories.

Ownership and permissions.

Access time, modification time, type, etc.

Threads abstract the CPU.

Address spaces abstract memory.

Files abstract the disk.

We will return to these abstractions. We are starting with an organizing principle.

Processes organize information about other abstractions and represent a single thing that the computer is "doing."

You know processes as app(lication)s.

one or more threads,

an address space, and

zero or more open file handles representing files.

What you do in your own process is your own business but it shouldn’t be able to crash the machine or effect other processes—or at least processes started by other users.

Thus: safe intra-process communication is your problem; safe inter-process communication is an operating system problem.

Communication between multiple threads in a process is usually accomplished using shared memory.

Threads within a process also share open file handles and both static and dynamically-allocated global variables.

Thread stacks and thus thread local variables are typically private.

Sharing data requires synchronization mechanisms to ensure consistency.

We will return to this later.

A variety of mechanism exist to enable inter-process communication (IPC), including shared files or sockets, exit codes, signals, pipes and shared memory.

All require coordination between the communicating processes.

Most have semantics limiting the degree to which processes can interfere with each other.

Simplest and most-limited form of IPC.

Allows processes to return a single int to the process that created them.

0 typically indicates success; non-0, failure.

Analogous to older computers that would transform a set of punch cards into a "result."

bash exposes return codes as $?:

Pipes create a producer-consumer buffer between two processes.

Allows the output from one process to be used as the input to another.

The operating system manages a queue for each pipe to accommodate different input and output rates.

Facilitates the canonical chaining together of small UNIX utilities to do more sophisticated processing.

Signals are a limited form of asynchronous communication between processes.

Processes can register a signal handler to run when a signal is received.

Users can send signals to processes owned by them; the super-user can send a signal to any process.

Processes can ignore most signals.

return codes — we will discuss again when we learn about wait() and _exit().

pipes — we will discuss again when we learn about fork().

signals — are difficult to use and implement and not something we will return to.

shared memory — we will discuss again when we learn about address spaces and virtual memory.

Potential confusing due to overlapping terminology—​we can describe both a process and a thread as running.

Terminology can be helpful for remembering the distinction:

Processes contain threads; threads belong to a process.

A process is considered to be running when one or more of its threads are running.

Different operating systems use different terminology, but share common ideas.

Let’s do this for real using standard Linux system utilities.

ps aux gives me all process, then grep for the one I’m after.

…​or, do it all in one shot using pgrep.

…​or, if I know it’s running in my current session a bare ps will do.

UID: user the process is running as.

PID: process ID.

PPID: parent process ID.

PRI: scheduling priority.

SZ: size of the core image of the process (kB).

WCHAN: if the process is not running, description of what it is waiting on.

RSS: total amount of resident memory is use by the process (kB).

TIME: measure of the amount of time that the process has spent running.

If bash had multiple threads running this view would show them, so bash does not have multiple threads.

I wish we could see a process with multiple threads…​