A significant part of the material of this glossary was adapted from material originally written by Gregory V. Wilson which appeared as "A Glossary of Parallel Computing Terminology" (IEEE Parallel & Distributed Technology, February 1993), and is being re-printed in the same author's "Practical Parallel Programming" (MIT Press, 1995). Several people have contributed additions to this glossary, especially Jack Dongarra, Geoffrey Fox and many of my colleagues at Edinburgh and Syracuse.

Original version is from NPAC at <URL:http://nhse.npac.syr.edu/hpccgloss/>

Original author:See also the index of all letters and the full list of entries (very large)

Sections:
A
B
C
D
E
F
**G**
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z

**GaAs** (n.) Gallium arsenide; an relatively new semiconductor material, still not yet fully mastered by chip manufacturers. GaAs components can run much faster than silicon-based components. See also *CMOS*.

**game tree** (n.) the state space tree representation of a game position.

**Gantt chart** (n.) a diagram used to illustrate a deterministic schedule.

**gather/scatter** (n.) the operations related to large sparse data structures. A full vector with relatively few nonzeroes is transformed into a vector with only those nonzeroes by using a gather operation. The full vector, or one with the same structure, is built from the inverse operation or scatter. The process is accomplished with an index vector, which is usually the length of the number of nonzeroes, with each component being the relative location in the full vector. See also *compress/index*.

**Gauss-Seidel method** (n.) An iterative method for solving partial differential equations on a grid. When updating a grid point the new value depends on the current values at the neighbouring grid points, some of which are from the previous iteration and some, which have already been updated, are from the current iteration. So updates are performed by sweeping through the grid in some user-chosen fashion. The key feature of this algorithm is that it makes use of new information (updated grid point values) as soon as they become available.

**Gaussian elimination** (n.) A method for solving sets of simultaneous linear equations by eliminating variables from the successive equations. The original equation in the form Ax=b (A is a matrix, b the vector of known values, and x the unknown solution vector) is reduced to Ux=c, where U is an upper triangular matrix. The solution vector x can then be found by *back substitution*. This method is usually formulated as *LU decomposition*.

**GAXPY** (n.) a generalised *SAXPY* operation, taking linear combinations of a set of columns and accumulating the columns in a vector, as in a matrix-vector product.

**generative communication**(n.) A model of parallel computing in which processes that have been *spawned* dynamically turn into data upon completion, and data may be stored in *tuples* in one or more shared *tuple spaces*. A process may add tuples to a tuple space, or remove then by matching against their contents. See also *associative memory*, *shared variables*, *virtual shared memory*.

**geometric decomposition** (n.) See *decomposition*.

**GGP** (n.) gateway to gateway protocol is the protocol used by core gateways to exchange routing information.

**GKS** (n.) the Graphics Kernel Standard; a graphics standard developed for pen plotters and now supported on a wide variety of pixel based devices.

**global addressing** (n.) A frame relay addressing scheme which uses the *DLCI* to identify a specific end across device somewhere else in the frame relay network. In a global addressing scheme, the DLCI is a unique identifier for each *IPX* port in the network.

**grain** (n.) See *granularity*

**granularity** (n.) The size of operations done by a process between communications events. A fine grained process may perform only a few arithmetic operations between processing one message and the next, whereas a coarse grained process may perform millions. See also *computation-to-communication ratio*.

**graph** (n.) an entity consisting of a set of vertices and a set of edges between pairs of vertices.

**Gray code** (n.) A *mapping* which labels the lattice points on an n-dimensional grid with the integers 0,1,2,...2^d-1, so that the labels at adjacent grid points differ in precisely one bit in their integer representation.

**Grosch's Law** (n.) an empirical rule that the cost of computer systems increases as the square root of the computational power of the systems.

**guard** (n.) A logical condition that controls whether a communication operation can take place. Guards are usually defined as part of the syntax and semantics of *CSP*-based langauges.

**guard ring** (n.) Parallel algorithms operating on a two dimensional grid generally store grid values in a two dimensional array, *geometrically decomposed* across the *nodes* of the *parallel computer*. The guard ring is the additional storage allocated around the edges of the array to hold the values at the grid points lying along the adjacent boundaries of neighbouring nodes. These values are obtained by communication between nodes.

**Gustafson's Law**(n.) A rule stating that if the size of most problems is scaled up sufficiently, then any required *efficiency* can be achieved on any number of processors, as stated by Gustafson in 1988. See also *Amdahl's Law*, *efficiency*.