MUSS—a portable operating system

This paper describes a technique for producing a machine-independent operating system with a high level of performance. The technique is based on the definition of a hypothetical ideal machine, which acts as the target computer for the operating system. The characteristics of this ideal machine are described in detail.     

A pascal compiler for ICL 1900 series computers

The transport of a PASCAL compiler from a CDC 6000 series computer to an ICL 1900 series computer is reported, with some comments on the method used.     

Quick compilers using peephole optimization

Abstract machine modelling is a popular technique for developing portable compilers. A compiler can be quickly realized by translating the abstract machine operations to target machine operations. The problem with these compilers is that they trade execution efficiency for portability. Typically, the code emitted by these compilers runs two to three times slower than the code generated by compilers that employ sophisticated code generators. This paper describes a C compiler that uses abstract machine modelling to achieve portability. The emitted target machine code is improved by a simple, classical rule-directed peephole optimizer. Our experiments with this compiler on four machines show that a small number of very general handwritten patterns (under 40) yields code that is comparable to the code from compilers that use more sophisticated code generators. As an added bonus, compilation time on some machines is reduced by 10 to 20 per cent.     

Abstract machine modelling to produce portable software—a review and evaluation

This paper discusses the use of abstract machine modelling as a technique for producing portable software, i.e. software which can be moved readily from one computer to another. An overview of the principles involved is presented and a critical examination made of three existing abstract machines which were used respectively to implement a macro processor, a text editor and a BASIC compiler.     

Code generation using an orthogonal model

This paper describes a new systematic approach to code generation. The approach is based on an orthogonal model, in which implementation of language-level operators (‘operators’) and addressing operators (‘operands’) is achieved by two independent subtasks. Each of these phases is specified using a set of decision trees that encode the set of possible implementation templates for each language feature and the set of constraints under which each can be applied. Code selection in each phase is achieved by interpreting these trees using a single comprehensive selection algorithm. The method easily extends to machine independence across a large class of target computers by abstracting the implementation templates into machine-independent implementation strategies. The selection algorithm is then modified to select between implementation strategies based on a machine capability ‘menu’ that describes each target machine in terms of the subset of implementation strategies for which it has corresponding instruction sequences. The method has been used to implement a prototype machine-independent code generator for the Concurrent Euclid programming language whose generated code density is consistently within four per cent of production machine-dependent code generators across its entire target class of five modern computers.     

A portable virtual machine for Ada

A portable compiler can be constructed by letting it generate code for a virtual machine, which is then implemented on the real target machines. The design of a virtual machine which is especially suitable as a target machine for compiled Ada programs is described. The main design goals, implementability on mini-computers and portability, are discussed and the resulting design is described in some detail. Some implementation strategies for the machine are proposed and the feasibility of the virtual machine approach is discussed.     

CHEF: A versatile portable text editor

CHEF is an interactive text editor for use with both printing and display terminals. Its prime field of application is computer source program editing but it has some word processing capabilities that make it useful for documentation and general text editing work. There is a comprehensive set of whole-line operations, including block moves and the insertion of text from external files, together with substring replacement and line segmentation based on a flexible pattern-matching algorithm. There is a set of one-line buffers for temporary storage of lines or command strings and complex command sequences can be built up by macro substitution. Considerable effort has been made to design a command syntax that is flexible and consistent and, at the same time, minimizes effort during the editing process. CHEF copies the user's file into an internal work-space so that the original is not disturbed until the user is satisfied with the results of the editing session. A virtual memory technique is used to provide a work-space that can be almost any desired size, with random access to any part and efficient editing operations. CHEF is written in BCPL and has already been implemented on four different machines.     

A pascal compiler for PDP 11 minicomputers

In this paper the development of a cross-compiler running on the central computing facility is described. The compiler transforms PASCAL source code into object code for the PDP 11 family. The arguments for higher level languages on minicomputers and the choice made for PASCAL are discussed. It is shown that only a minor effort in terms of manpower is required if such a development is based on an existing compiler that is suited to the purpose of adaptation. Even without large amounts of optimization the code produced is both compact and efficient. Some attention is paid to requirements that should be fulfilled in portable compilers. The paper ends with a discussion of some strong points and weak points of the PDP 11 architecture.     

Code generation with a recursive optimizer

This paper describes a general purpose optimizer used to construct a new code generator for an existing Coral 66 compiler. The optimizer is recursive and gives the one pass code generator some of the advantages of a multiple pass scheme by ‘pipelining’ short sequences of linear intermediate code at each activation level.     

Interpretation and code generation based on intermediate languages

The possibility of supporting high level languages through intermediate languages to be used for direct interpretation and as intermediate forms in compilers is investigated. An accomplished project in the construction of an interpreter and a code generator using one common intermediate form is evaluated. The subject is analysed in general, and a proposal for an improved design scheme is given.     

A portable trace for the Pascal heap

Debugging aids for high-level languages supporting structured data types should provide diagnostic information in a form terminologically as close as possible to that of the original source code. In addition, it is desirable that such software be portable. The package HEAPTRACE satisfies both the above criteria. It is a precompiler for Pascal programs which enables the user to trace the heap, selectively dumping dynamically-created records in a high-level format. It is portable as it is written entirely in Pascal; furthermore, since it is implemented as additions and modifications to a well-known compiler, its principles may easily be built into any Pascal compiler or diagnostics system. However, there is a small price to pay for achieving portability in that three possibly desirable features cannot be satisfactorily implemented in a machine-independent manner.     

A portable file directory system

A portable file directory system that provides a machine-independent method for specifying files is described. The portable directory system, or PDS, facilitates uniform usage of portable software by supplying a standard for file specification. The PDS supports a hierarchical directory structure, similar to that in UNIX and Multics, and a set of primitives for manipulating the structure and preparing files for input/output. While the PDS participates in file specification, it does not participate in the actual i/o; it has no impact on i/o efficiency. The implementation, which is easily extended to include additional capabilities, is described. Experience in using the PDS as a part of command interpreters and preprocessors is also discussed.     

A portable diagnostic facility for SNOBOL4

In programming systems based on abstract machine modelling concepts, the underlying structure of the abstract machine can be made available to the software implemented on it. The result is an unusual facility for diagnosis and exploration of software structure. Such a facility has been added to the macro implemention of SNOBOL4. This paper describes the nature of the facility, illustrates its use, and presents some results of using it for language implementation and development.     

A Case Study on Compiler Optimizations for the Intel® CoreTM 2 Duo Processor

The complexity of modern processors poses increasingly more difficult challenges to software optimization. Modern optimizing compilers have become essential tools for leveraging the power of recent processors by means of high-level optimizations to exploit multi-core platforms and single-instruction-multiple-data (SIMD) instructions, as well as advanced code generation to deal with microarchitectural performance aspects. Using the Intel^® Core^TM 2 Duo processor and Intel Fortran/C++ compiler as a case study, this paper gives a detailed account of the sort of optimizations required to obtain high performance on modern processors.     

A portable language for system development

The design and implementation of a system development language which is economical to implement is described. Both macro processing and compiling techniques are used to translate it. The advantages and disadvantages of using such a language are discussed together with the main problems met in its implementation.     

Implementation of concurrent Pascal on LSI—11

This paper considers the moving of the implementation of Concurrent Pascal for the PDP-11/45 computer to the LSI-11 computer. The resulting implementation for the LSI-11 computer is also discussed and described.     

The construction of a portable editor

The paper describes the implementation of an editor designed and constructed with portability in mind. We give first a brief introduction to the editor from the user's point of view, then we discuss the methods used to ease the problems of portability, and finally we explain some data structures used in its implementation, structures which, we believe, are interesting in their own right.