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

**fact** (n.) in the context of logic programming, a fact is a *Horn clause* with a head but no body.

**fairness** (n.) A property of a concurrent system. If a system is fair, then in the long run all processes are served equally. No process has preferential access to *semaphores* and in particular no process can *livelock*. See also *deadlock*.

**fast Fourier transform** (n.) See *FFT*

**fast packet** (n.) Fast packet is a general term for various streamlined packet technologies including *frame relay*, *BISDN* and *ATM*. Compared to X.25 packet switching, fast packet contains a much reduced functionality, but with the lower overhead, fast packet systems can operate at higher rates at the same processing cost.

**FastPacketTM** (n.) StrataCom Corporation's trademarked term for their proprietary switching technique, which uses 192 bit packets.

**FDDI** (n.) Fast digital data interface; a standard for fibre optic communications systems. See also *ethernet*.

**fetch-and-add** (n.) a computer synchronization instruction that updates a word in memory, returns the value before the update, and produces a set of results as if the processors executed in some arbitrary order. See also *prefetch*.

**FFT** (n.) The fast Fourier transform is a technique for the rapid calculation of discrete Fourier transform of a function specified discretely at regular intervals. The technique makes use of a *butterfly* data structure.

**FIFO** (n.) First in, first out, a queue.

**file server** (n.) A process running on a computer that provides access to files for remote user systems.

**file system** (n.) The hardware used for nonvolatile data storage; the system software that controls this hardware; the *architecture* of this hardware and software. A parallel file system is one that can be read or written to by many processors simultaneously. See also *RAID*.

**fine grain** (adj.) See *granularity*

**finite difference method** (n.) A *direct method* for the approximate solution of partial differential equations on a discrete grid, by approximating derivatives of the unknown quantities on the grid by linear differences. *Array processors* lend themselves very well to the efficient implementation to this sort of application. See also *finite element method*.

**finite element method** (n.) An approximate method for solving partial differential equations by replacing continuous functions by piecewise approximations defined on polygons, which are referred to as elements. Usually polynomial approximations are used. The finite element method reduces the problem of finding the solution at the vertices of the polygons to that of solving a set of linear equations. This task may then be accomplished by a number of methods, including *Gaussian elimination*, the *conjugate gradient method* and the *multigrid method*. See also *finite difference method*.

**flit** (n.) A flow control unit - the basic unit of information sent through a *message passing* system that uses *virtual cut-through* or *wormhole routing*.

**FLOPS** (n.) Floating point operations per second; a measure of memory access performance, equal to the rat eat which a machine can perform single-precision floating-point calculations. See also *WARPS*.

**Flynn's Taxonomy** (n.) A classification system for *architectures* that has two axes: the number of instructions streams executing concurrently, and the number of data sets to which those instructions are being applied. The scheme was proposed by Flynn in 1966. See also *SPMD*, *MIMD*, *SIMD*, *SISD*.

**forall** (n.) A programming construct that specifies a set of loop iterations and further specifies that these iterations can be done in any order. *data parallel* and *shared variable* programs are often expressed using forall loops.

**fork** (v.) To create a new process that is a copy of its immediate parent. See also: *join*, *spawn>*.

**forward reduction** (n.) See *LU decomposition*.

**FPU** (n.) Floating point unit; either a separate chip or an area of silicon on the *CPU* specialised to accelerate floating point arithmetic.

**FRAD** (n.) Frame relay assembler/disassembler, used to interface a *LAN* with a *frame relay* *WAN*.

**frame relay** (n.) A packet interface data transmission protocol used for connecting LANs via a WAN topology at rates from 56Kbps to *T1*/*E1*.

**frame slip** (n.) Also called just slip, is any shift of the timing on a circuit.

**FT-1** (n.) Fractional digital service hierachy level 1 with service in multiples of 56/64Kbps 2 channels (112/128Kbps) or above, and up to 23 channels. 256/512/768/1024Kbps are common rates for this type of service. Also called fractional *T1*.

**FT-3** (n.) Fractional digital service hierachy level 3 with service in multiples of 1.544Mbps. Also called fractional *T3*.

**FTP** (n.) file transfer protocol is the *TCP/IP* standard for remote file transfer. FTP uses *telnet* and *TCP* protocols.

**full matrix** (n.) A full matrix is one in which the number of zero elements is small (in some sense) compared to the total number of elements. See also *sparse matrix*.

**functional decomposition** (n.) See *decomposition*.

**functional unit** (n.) functionally independent part of the ALU each of which performs a specific function, for example: address calculation; floating-point add or floating-point multiply.

**futures** (n.) A programming construct specifying that the value of some computation will be needed at some later point, but allowing the system to schedule that computation to run at any arbitrary time. Futures are one way to present *lazy evaluation* in *shared variable* programming. See also *eager evaluation*.

**fuzzy barrier**(n.) A pair of points in a program such that no process may pass the second point before all processes have reached the first. Fuzzy barriers are often used inside loop iterations to ensure that no changes are made during an iteration before all values needed in the previous iteration have been read. See also *barrier*, *barrier synchronization*, *dependence*.