Appendix 1

Glossary

Vector processor

A technique that is mainly run to accelerate frequently used loop structures in numerical calculation programs. Using large registers, vector processors analyze source programs using a compiler and accelerate the program by running multiple iterations simultaneously. This technique was used to accelerate the supercomputers developed in the 1980s and 1990s, and is currently adopted in supercomputers such as the NEC SX series.

Scalar processor

In contrast to the vector processor, a scalar processor faithfully runs the loop structure by running each iteration described in the program in a series. This is equivalent to the running of conventional general-purpose processors.

Loop parallel

A parallel that occurs in loop processing. Generally refers to a parallel in the processing time of each iteration of the loop body.

Data transfer overhead

Processing cost (time) to transfer data between processors. In serial processing (processing that does not include parallel processing), this cost is the cost of other processing that is unable to take place. The key to acceleration using parallel processing is to achieve elimination or reduction in overhead that is not possible with serial processing.

Grain

Size of the processing unit allocated to a computer or processor in parallel processing. Also called task size.

Fine grain

Indicates a small unit of processing, such as an instruction or instructions, allocated to a computer or processor in parallel processing.

Coarse grain

Indicates a large unit of processing, such as a subroutine, loop or basic block (set of multiple statements), allocated to a processor or processor group in parallel processing.

Scheduling

Allocation of parallel processing units such as instructions and tasks to computers or processors and determination of a sequence for running those units

Speculative running

Program running is subject to two restrictions: Data-sensitive processing, in which calculation cannot be run without data, and control- sensitive processing, in which calculation cannot be run without control. Speculative running is a technology that ignores these restrictions and runs calculations anyway, accelerating calculation.

Benchmark

A set of programs used to evaluate computer performance is called a benchmark or test. SPEC CPU is a well-known test for single processors. In scientific and technical calculation, Perfect Benchmarks is a commonly used tool. To calculate performance (measured in number of instructions per second), the number of instructions run by the program is compared with total run time. These benchmarks are furnished with a program for measuring run time, so the performance result can be obtained simply by running the target program. Also, to ensure that bugs in the program do not cause errors in calculation results, generally an automatic verification program is also included.

OpenMP

Standard programming parallel interface for shared-memory multiprocessors (SMPs). Another standard interface, used in distributed-memory multiprocessors, is High Performance Fortran (HPF). HPF is installed in most such computers but is rarely used. OpenMP began to rise rapidly in popularity in 1997, and looks set to become the de facto standard programming interface for SMPs in the near future.

Tuning Technology

Technology that enables user support to improve the performance of a program during running. This technology indicates such information as which portions of the program contain inefficient parallelization and, based on feedback from the user on that information, improves performance by supplying additional analytical information about the compiler.

SMP

Stands for Shared Memory Multiprocessor. Generic term for multiprocessor systems that transfer data between system processors through shared memory.

Single-grain

Indicates an event or action within or pertaining to the same grain (processing task allocated to processors or groups of processors in parallel processing), regardless of the size of the grain. The grain may be coarse-grain (large), including subroutines, loops and basic blocks (sets of multiple statements); or hey may be fine (small), including instructions or multiple instructions.