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 affect 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.