Computer scientists used three related terms to describe the general area of low-level machine organization. Computer architecture is the study of the components that make up computer systems and how they are interconnected. Computer organization is concerned with the implementation of a computer architecture. As an example of the difference between architecture and implementation, consider the vector supercomputers from Cray Research. These machines have very similar architectures from a programmer's point of view: processors in these systems have the same number of internal registers (temporary storage) for both vector and scalar data, they have the same basic instruction set, and operands in main memory have the same formats. The systems have very different organizations, however, since they may have a different number of processors, memory sizes may vary, operands are transferred from memory to the processor in different ways, and the time to execute an instruction varies from one system to another. Computer engineering refers to the actual construction of a system: lengths of wires, sizes of circuits, cooling and electrical requirements, etc. Programmers often use knowledge of a system's architecture, and sometimes organization, to optimize performance of their programs, but rarely, if ever, are they concerned with engineering aspects.
The goal of this chapter is to introduce the basic concepts of computer architecture and organization in order to allow computational scientists to recognize when programs are not as efficient as they could be and to transform them so they make better use of the underlying machine. We cannot hope to present a comprehensive collection of performance tips for languages and systems likely to be used in computational science. Rather we aim to give enough background information on common structures such as vector processors and cache memories so you will be able to (a) recognize when your program is not performing near the capacity of your system, (b) understand performance improvement techniques recommended by the compiler writers and/or system architects of your system, and (c) decide whether the benefits of increased performance are worth sacrificing abstraction and portability.