previous | contents | next

Section 7

Language-Based Computers

A system designer can place the architectural boundary (i.e., the boundary of the machine as seen by the programmer) at any number of places in the digital system's hierarchy described in Chap. 2. Placing the architectural boundary higher up (as for higher-level-language machines) provides flexibility in exploiting new technology but may constrain the languages or generality of the computer. On the other hand, placing the architectural boundary lower (as for microcoded machines) yields greater flexibility in supporting new languages and programming styles but may restrict the use of new technology. Traditionally, the architectural boundary has been placed at the ISP level. This section explores computer structures that have moved the boundary up to the high-level-language interface, where the programmer is provided with a single high-level-language environment.

Machines that directly execute higher-level languages have been proposed for over 15 years, and several have been implemented. When functions are implemented in hardware to support higher-level languages, intermediate levels of abstraction (e.g., the machine-code and perhaps even the microcode levels) can be eliminated. Elimination of levels of abstraction implies a potential performance improvement, since no time is lost interpreting the intermediate levels.

Early attempts at high-level-language machines used microprogramming to bypass the machine-code level of abstraction. Microprogrammed operators directly manipulate complex data structures (e.g., symbol tables and reverse Polish strings). One example is the implementation of an interpreter for an ALGOL- like language, EULER [Wirth and Weber, 1966a, b], for the IBM System/360 Model 30 [Weber, 1967].

Some general-purpose machines that have writable control stores have added special instructions that assist or boost the performance of specific language constructs. Yet another approach is to provide machine language instructions that map one for one to high-level-language constructs. These instructions can be added to the ISP of general-purpose machines once the most frequently used constructs among the compiler languages have been identified (e.g., three-address operations for common arithmetic statements and the case and loop instructions in the VAX-11/780, Chap. 42).

Chu and Cannont [1976] proposed a taxonomy of high-level-language systems (Table 1) based on user-perceived functionality. Type 1(a) represents the traditional compiler-based systems typified by creation of a source program with an interactive editor, syntax checking via compilation, linking of object programs for

Table 1 Types of High-Level-Language Systems

Interactive compilation systems

Type 1(a) Editing, compiling, executing the entire source code

Type 1(b) Editing, syntax checking, compiling, and executing the entire source code

Type 1(c) Editing/syntax checking each line, compiling and executing the entire source code

Interactive interpretation systems

Type 2(a) Editing, syntax checking, and interpreting the entire source code

Type 2(b) Editing, syntax checking, and interpreting each line of source code

Interactive direct-execution systems

Type 3 Editing, syntax checking, and executing each symbol of source code

execution, and debugging by iterating the editing/compiling/linking/execution cycle. Type 1(b) separates the syntax checking and compiling phases in order to speed up program development. Type 1(c) provides incremental syntax checking in dedicated language systems such as interactive BASIC.

Type 2 systems interpret source code directly by bypassing the machine-code level of abstraction (the levels usually bridged by compilers). Type 2(b) systems differ by being incremental interpreters.

Type 3 systems operate on a symbol-by-symbol basis.

This section contains three examples of machines based on, and dedicated to, a single high-level language, SYMBOL, the HP 9845A, and the IBM System/3S. It is interesting to note that all three machines are implemented from multiple processors where each processor is personalized to a set of subtasks (e.g., text editing, language translation, or I/O).


SYMBOL was an experimental machine that provided hardware support for Type 1(a) interactive compilation. SYMBOL was built by Fairchild during the 1964-1970 period. The SYMBOL language [Rice and Smith, 1971] featured decimal arithmetic, dynamically variable fields, and string manipulation and format ting.

SYMBOL consists of eight dedicated processors. One processor translates the input string into an internal form to be executed by another processor. The fundamental unit of memory is a variable-length string maintained via linked lists in the memory controller. Scheduling and I/O algorithms are also hardwired.

The SYMBOL paper (Chap. 30) concludes with a performance and cost analysis, including an informative cost breakdown of operating expenses for a large, central computer.


previous | contents | next