Glossary

A

architecture

particular hardware (processor) interface. Examples architectures include "linux", "sgin32", "sgi64", and "sun".

Array

a POOMA container generalizing C arrays and mapping indices to values. Constant-time access to values is supported, ignoring the time to compute the values if applicable. Arrays are first-class objects. DynamicArrays and Fields generalize Array.

See Also: container, DynamicArray, Field.

B

Brick Engine

an Engine explicitly storing each of its values. Its space requirements are at least the size of the Engine's domain.

See Also: engine.

C

cell

a domain element of a Field. Both Array and Field domain elements are denoted by indices, but a cell exists in space. For example, it might be a rectangle or rectangular parallelepiped.

See Also: cell size, Field, mesh.

cell size

specifies a Field cell's dimensions e.g., its width, height, and depth, in ℜd. This is frequently used to specify a mesh.

See Also: cell, mesh, corner position.

communication library

software library passing information among contexts, usually using messages.

See Also: distributed computing environment.

compilation time

See: compile time

compile time

in the process from writing a program to executing it, the time when the program is compiled by a compiler. This is also called compilation time.

See Also: programming time, run time.

computing environment

computer. More precisely, a computer with its arrangement of processors and associated memory, possibly shared among processors.

See Also: sequential computing environment, distributed computing environment.

conformable containers

containers with conformable domains.

See Also: conformable domains, data parallel.

conformable domains

domains with the "same shape" so that corresponding dimensions have the same number of elements. Scalars, deemed conformable with any domain, get "expanded" to the domain's shape. Assignment can operate on containers with conformable domains.

See Also: conformable containers, data parallel.

container

an object that stores other objects, controlling their allocation, deallocation, and access. Similar to C++ containers, the most important POOMA containers are Arrays and Fields.

See Also: Array, DynamicArray, Field, Tensor, TinyMatrix, Vector.

container value

object stored within a container and usually addressable via an index. Synonyms include "element" and "value".

context

a collection of shared memory and processors that can execute a program or a portion of a program. It can have one or more processors, but all these processors must access the same shared memory. Usually the computer and its operating system, not the programmer, determine the available contexts.

See Also: distributed computing environment, layout.

context mapper

indicates how a container's patches are mapped to processors and shared memory. Two common choices are distribution among the various processors and replication.

See Also: context, patch.

corner position

specifies the ℜd point corresponding to a Field domain's lower, left corner.

See Also: mesh, cell size.

D

data parallel

describes an expression involving a (non-singleton) subset of a container's values. For example, sin(C) is an expression indicating that the sin is applied to each value in container C.

See Also: element wise, relation, stencil.

distributed computing environment

computing environment with one or more processors each having associated memory, possibly shared. In some contexts, it refers to strictly multiprocessor computation.

See Also: computing environment, sequential computing environment.

domain

a set of points on which a container can define values. For example, a set of discrete integral n-tuples in n-dimensional space frequently serve as container domains.

See Also: container, interval, stride, range.

domain triplet notation

notation [begin:end:stride] representing the mathematical set {begin, begin + stride, begin + 2stride, …, end}. end is in the set only if it equals begin plus some integral multiple of stride. This notation can abbreviate many domains. It is extended to multiple dimensions by separating the dimensions' sets with commas: [begin0:end0:stride0,begin1:end1:stride1].

See Also: domain.

DynamicArray

a POOMA container generalizing one-dimensional Arrays by supporting domain resizing at run-time. It maps indices to values in constant time, ignoring the time to compute the values if applicable. DynamicArrays are first-class objects.

See Also: container, Array, Field.

E

element

See: container value

element wise

describes accesses to individual values within a container. For example, C(-4,3) represents one particular value in the container C.

See Also: data parallel, relation, stencil.

engine

stores or computes a container's values. These can be specialized, e.g., to minimize storage when a domain has few distinct values. Separating a container and its storage also permits views of a container.

See Also: Brick Engine, container, view of a container.

enumeration

C++ integral type with named constants. These are frequently used in template programming because they can be used as template arguments.

execution time

See: run time

external guard layer

guard layer surrounding a container's domain used to ease computation along the domain's edges by permitting the same computations as for more internal computations. It is an optimization, not required for program correctness.

See Also: guard layer, internal guard layer, patch.

F

Field

a POOMA container representing an Array with spatial extent. It also supports multiple values and multiple materials having the same index. It maps indices to values in constant time, ignoring the time to compute the values if applicable. It also supports geometric computations such as the distance between two cells and normals to a cell. Fields are first-class objects.

See Also: container, cell, mesh, Array, DynamicArray.

first-class type

a type of object with all the capabilities of the built-in type having the most capabilities. For example, char and int are first-class types in C++ because they may be declared anywhere, stored in automatic variables, accessed anywhere, copied, and passed by both value and reference. POOMA Array and Field are first-class types.

function object

object that can behave as a function. The object can store values that the function uses. If its function is called operator(), the object can be invoked as a function.

function template

a definition of an unbounded set of related functions, all having the same name but whose types can depend on template parameters. They are particularly useful when overloading operator functions to accept parameters that themselves depend on templates.

G

guard layer

domain surrounding each patch of a container's domain. It contains read-only values. External guard layers ease programming, while internal guard layers permit each patch's computation to be occur without copying values from adjacent patches. They are optimizations, not required for program correctness.

See Also: external guard layer, internal guard layer, partition, patch, domain.

I

index

a position in a domain usually denoted by an ordered tuple. More than one index are called indices.

See Also: domain.

instantiation

See: template instantiation

indices

More than one index.

See Also: index.

internal guard layer

guard layer containing copies of adjacent patches' values. These copies can permit an individual patch's computation to occur without asking adjacent patches for values. This can speed computation but are not required for program correctness.

See Also: guard layer, external guard layer, patch.

interval

a set of integral points between two endpoints. This domain is frequently represented using mathematical interval notation [a,b] even though it contains only the integral points, e.g., a, a+1, a+2, …, b. It is also generalized to an n-dimensional interval as the direct product of one-dimensional intervals. Many containers' domains consist of these sets of ordered tuples.

See Also: domain, stride, range.

L

layout

a map from an index to processor(s) and memory used to compute the container's associated value. For a uniprocessor implementation, a container's layout always consists of its domain, the processor, and its memory. For a multiprocessor implementation, the layout maps portions of the domain to (possibly different) processors and memory.

See Also: container, domain.

M

matrix

See: TinyMatrix

mesh

a Field's map from indices to geometric values such as cell size, edge length, and cell normals. In other words, it specifies a Field's "spatial extent".

See Also: Field, cell, cell size, corner position, layout.

O

operator function

function defining a function invoked using a C++ operator. For example, the operator+ function defines the result of using the +.

P

partition

a specification how to divide a container's domain into patches for distributed computation. It can be independent of the domain's size. For example, it divide each domain into halves, yielding a total of eight patches in three dimensions. See Figure 3-4 for an illustration.

See Also: guard layer, patch, domain.

patch

subset of a container's domain with values computed by a particular context. A partition splits a domain into patches. It may be surrounded by external and internal guard layers.

See Also: partition, guard layer, domain.

point

a location in multidimensional space ℜd. In contrast, indices specify positions in container domains.

See Also: Field, mesh, index.

programming time

in the process from writing a program to executing it, the time when the program is being written by a programmer.

See Also: compile time, run time.

R

range

a set of integral points between two endpoints and separated by a stride. This domain, frequently represented by domain triplets [b:e:s], can also be represented mathematically as an integral interval [b,e] with stride s, i.e., {a, a+s, a+2s, …, b}. It is generalized to an n-dimensional range as the direct product of one-dimensional ranges.

See Also: stride, interval, domain.

reference semantics

a copy of an object o refers to the object o such that changing either one also changes the other. This is the opposite of value semantics.

relation

dependence between a dependent container and one or more independent containers and an associated function. If a dependent container's values are needed and one or more of the independent containers' values have changed, the dependent container's values are computed using the function and the independent containers' values. Relations implement "lazy evaluation".

See Also: data parallel, element wise, stencil.

run time

in the process from writing a program to executing it, the time when the program is executed. This is also called execution time.

See Also: compile time, programming time.

S

sequential computing environment

a computing environment with one processor and associated memory. Only one processor executes a program even if the computer itself has multiple processors.

See Also: computing environment, distributed computing environment.

stencil

set of values neighboring a container index and a function using those values to compute it. For example, the stencil in a two-dimensional Conway game of life consists of an index's eight neighbors and a function that sets its value to "live" if it is already live and it has two neighbors or it has exactly three live neighbors.

See Also: data parallel, element wise, relation.

stride

spacing between regularly-spaced points in a domain. For example, the set of points a, a+2, a+4, …, b-2, b is specified by [a,b] with stride 2. It is a domain.

See Also: range, interval, domain.

suite name

an arbitrary string denoting a particular toolkit configuration. For example, the string "SUNKCC-debug" might indicate a configuration for the SunSolaris operating system and the KCC C++ compiler with debugging support. By default, the suite name it is equal to the configuration's architecture name.

T

template

class or function definition having template parameters. These parameters' values are used at compile time, not run time, so they may include types and other compile-time values.

See Also: template instantiation, template specialization.

template instantiation

applying a template class to template parameter arguments to create a type. For example, foo<double,3> instantiates template <typename T, int n> class foo with the type double and the constant integer 3. Template instantiation is analogous to applying a function to function arguments.

See Also: template.

template specialization

class or function definition for a particular (special) subset of template arguments.

See Also: template.

Tensor

a POOMA container implementing multidimensional mathematical tensors as first-class objects.

See Also: TinyMatrix, Vector.

TinyMatrix

a POOMA container implementing two-dimensional mathematical matrices as first-class objects.

See Also: Tensor, Vector.

trait

a characteristic of a type.

See Also: traits class.

traits class

a class containing one or more traits all describing a particular type's characteristics.

See Also: trait.

Turing complete

describes a language that can compute anything that can be computed. That is, the language for computation is as powerful as it can be. Most wide-spread programming languages are Turing-complete, including C++, C, and Fortran.

V

value

See: container value

Vector

a POOMA container implementing multidimensional mathematical vectors, i.e., an ordered tuple of components, as first-class objects.

See Also: Tensor, TinyMatrix.

view of a container

a container derived from another. The view's domain is a subset of the latter's, but, where the domains intersect, accessing a value through the view is the same as accessing it through the original container. In Fortran 90, these are called array sections. Only Arrays, DynamicArrays, and Fields support views.

See Also: container.