POOMA: A C++ Toolkit for High-Performance Parallel Scientific Computing | ||
---|---|---|
Prev |
particular hardware (processor) interface. Examples architectures include "linux", "sgin32", "sgi64", and "sun".
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.
an Engine explicitly storing each of its values. Its space requirements are at least the size of the Engine's domain.
See Also: engine.
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.
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.
software library passing information among contexts, usually using messages.
See Also: distributed computing environment.
See: 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.
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.
containers with conformable domains.
See Also: conformable domains, data parallel.
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.
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.
object stored within a container and usually addressable via an index. Synonyms include "element" and "value".
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.
indicates how a container's patches are mapped to processors and shared memory. Two common choices are distribution among the various processors and replication.
specifies the ℜd point corresponding to a Field domain's lower, left corner.
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.
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.
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.
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.
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: container value
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.
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.
C++ integral type with named constants. These are frequently used in template programming because they can be used as template arguments.
See: run time
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.
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.
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.
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.
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.
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.
a position in a domain usually denoted by an ordered tuple. More than one index are called indices.
See Also: domain.
More than one index.
See Also: index.
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.
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.
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: TinyMatrix
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.
function defining a function invoked using a C++ operator. For example, the operator+ function defines the result of using the +.
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.
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.
a location in multidimensional space ℜd. In contrast, indices specify positions in container domains.
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.
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.
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.
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.
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.
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.
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.
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.
an arbitrary string denoting a particular toolkit configuration. For example, the string "SUNKCC-debug" might indicate a configuration for the Sun™ Solaris operating system and the KCC C++ compiler with debugging support. By default, the suite name it is equal to the configuration's architecture name.
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.
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.
class or function definition for a particular (special) subset of template arguments.
See Also: template.
a POOMA container implementing multidimensional mathematical tensors as first-class objects.
See Also: TinyMatrix, Vector.
a POOMA container implementing two-dimensional mathematical matrices as first-class objects.
a characteristic of a type.
See Also: traits class.
a class containing one or more traits all describing a particular type's characteristics.
See Also: trait.
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.
See: container value
a POOMA container implementing multidimensional mathematical vectors, i.e., an ordered tuple of components, as first-class objects.
See Also: Tensor, TinyMatrix.
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.