The Interpreter

``The Interpreter'' is a micro-architecture that is intended for a variety of uses including emulation of existing or hypothetical machines and program profiling. An emulator is written in microcode and instructions executed from the microinstructions that are executed from the microstore give both parallelism and fast execution.

Categories:

• Purpose: instruction set simulation, other tracing
• Input representation: exe
• Detail: User (system-mode execution was not discussed).
• Multiple protection domains: ??
• Multiple processors: N
• Signals and execptions: Yes
• SMC OK: Yes
• Simulation technology: ddi, emu
• Tool is robust in the face of application bugs: Yes
• Status: ??

More detailed review:

• A brief (1,000 word) history of microprogramming.
• (pg. 715) Suggested applications: emulation of existing or hypothetical machines; direct execution of high-level languages; tuning the instruction set to the application (by iterative profiling and instruction-set change).
• (pg. 715) ``Emulation is defined in this paper as the ability to execute machine language programs intended for one machine (the mulated machine) on another machine (the host machine). Within this broad definition, any machine with certain basic cpabilities can emulate any other machine; however, a measure of the efficiency of operation is generally implied when the term emulation is used. For example, ... a conventional computer [has poor] emulation efficiency ... since for each machine language instruction of the emulated machine there corresponds a sequence of machine instructions to be executed on the host machine ... (called simulation ... [Husson 70] and [Tucker 65]) turns out to be significanly more efficent on micorprogrammable computers. In a microprogrammed machine, the controls for performing the fetching and execution fo the machine instructions of the mulated machine consist of a sequence of microinstructions which allows the increased efficiency.'' In short, as Deutsch and Schiffman point out, you get hardware support for instruction fetch and decode, which are typically multi-instruction operations in decode-and-dispatch interpreters.
• (pg. 717) Description of Interpreter features that help it emulate a variety of machine architectures and instruction encodings.
• (pg. 719) ``The basic items necessary to define a machine and hence emulate it are:
  • Memory structure (registers, stacks, etc.),,
  • Machine language format (0, 1, 2, 3 address) including effective operand address calculation, and
  • Operation codes and their functional m eaning (instructions for arithmetic, branching, etc.).''
  Note that you also need e.g. data formats, an exception model, a device or other I/O model, ...
• (pg. 719) ``The process of writing an emulation therefore, involves the following analysis and the microprogramming of these basic items:
  • Mapping the registers (stacks, etc.) from the emulated machine onto the host machine.
  • Analysis of the machine language format and addressing structure.
  • Analysis of each operation code defined i the machine language.
• (pg. 719-720) ``All of the registers of the emulated machine must be mapped onto the host machine; that is, each register must have a corresponding register on the host machine. The most frequently used registers are mapped onto the registers within the Interpreter Logic Unit (e.g., registers A1, A2, A3). The remaining registers are stored either in the main system memory or in special high speed registers depending on the desired emulatin speed [[Which, I assume, means ``do you want R5 fast and R6 slow or R6 fast and R5 slow; it doesn't make sense to me that they'd offer you slower emulation as a feature --pardo]]. The machine language format may be 0, 1, 2, 3 address or variable length for increased code density, and may involve indexing, indirection, relative addressing, stacks and complex address conversions. Figure 14 shows the general micrporogram requirements (MPM Map) and operating procesures for the exmulation task.
• Summary: You're probably already familiar with the concepts in this paper. The paper describes the overall structure of a classic decode-and-dispatch interpreter; this one happens to use microcode, but many of the same features are the same when using normal machine code. The opportunity with microcode (which tends to be poorly stated in all of these papers) is that writable microcode allows the use of a machine with a very fast and very flexible but very space-consuming instruction set; microcode makes such an instruction set useful by providing a fast mechanism for mapping that instruction set to a denser representation (the one stored in primary memory). In the particular case of emulation, much of the interpreter can be written directly in the low-density machine code and can take advantage of that code's flexibility and performance without being hurt by the low encoding density.
• See also: [Rosin 69] and Deutsch's ST-80 VM, written (largely) in Xerox Dorado microcode.

See:

• bib cite

This review/summary by Pardo.