Massey University 159.355: Concurrent Programming & Operating Systems
 
Computer Science
Institute of Information Sciences and Technology
Massey University
Palmerston North

Glossary

There's a lot of terminology used in concurrent programming. Here's a guide to some of the terms:

Atomic action

An indivisible step. On a uniprocessor, executing a single machine-code instruction appears to be an atomic action.

Concurrent programming

Designing and implementing code that comprises several threads/processes working together to accomplish a task.

Communication

The need that concurrent processes have to exchange data.

Conditional critical region

Condition synchronization

The procedure by which one process ensures it does not proceed until some condition(s) has been fulfilled.

Context switch

A context switch is where the CPU switches from running one executable process to running another executable process. The register set and state of the first process must be saved, and the register set and state of the second process restored.

Critical region

A programming language construct that makes the execution of a section of code conditional on the process being the only one wanting access to the section. As for semaphores, this method of achieving mutual exclusion is prone to errors and must be distributed throughout the program.

Critical section

A portion of code that must be executed by only one process/thread at a time, typically because it updates shared variables.

Executable

An executable process is one that is able to be executed, i.e. is either running or runnable. See also runnable, running.

Monitor

A programming language construct that localises all code for accessing shared variables to enable mutual exclusion to be achieved. The localisation helps maintenance, and makes monitors less error-prone than constructs such as semaphores. Monitors also enforce mutual exclusion, in the sense that programmers cannot access the variables without going through the monitor. Java uses monitors as the built-in primitive to support concurrent programming.

Mutual exclusion

A section of code that must execute under mutual exclusion must be executed as an atomic action, i.e. without the process/thread being interrupted.

Process

A sequential program that has its own register set and memory address space. Sometimes "process" is used in the same sense as thread.

Runnable

A runnable process is one that is capable of being executed immediately, but is waiting for the scheduler to assign it to a CPU.

Running

A running process is one that is currently executing on a CPU.

Semaphore

A programming language primitive that enables mutual exclusion to be achieved. Unlike monitors, the code to do this ends up distributed throughout a program making it difficult to maintain and prone to errors.

Shared variables

Data that lives in a memory location that can be updated by more than one process/thread at a time.

Suspended

A process is suspended if it has become non-executable, for example while waiting for an I/O request to be satisfied.

Synchronization

Thread

A "lightweight" process that has its own register set but may share a memory address space with other threads.


Go to the Computer Science Web Pages.   Contact the course lecturers.
Check the CSS on this page. This page was last built on a Macintosh with BBEdit 5.1.1 on Tuesday, 18 April 2000, and is maintained by Koryn Grant Check the HTML on this page.