Architectural support for, and parallel execution of, programs constructed from reusable software components

General-purpose reusable software components have a well deserved reputation for being inefficient. The thesis of this work is that this problem is not inherent in generic software, i.e., reusable software can execute efficiently. Furthermore, it is claimed that architectural support and parallel processing can be used to achieve this goal. Due to the differences between RESOLVE and existing programming languages, the issues of hardware and software support are explored anew. The approach is to develop a virtual machine with an instruction set suited to the efficient execution of the kinds of components typically written in RESOLVE. A sequential implementation of the virtual machine is then used as a processing element in a distributed memory parallel computer that realizes the same virtual machine. This work makes several contributions to knowledge. The potential inefficiencies of class of reusable software components are identified and addressed. A virtual machine architecture suited to RESOLVE programs and to the RESOLVE run-time system is introduced. A virtual machine architecture (ARC) suited to all of RESOLVE is designed using RISC principles. Previously, RISC architectures were designed to accommodate all programs written in particular language. A different approach is taken here by designing an architecture suited to programs that are not only written in a particular language, but that are also designed according to a specific set of guidelines. ARC provides an instruction set useful to all of RESOLVE. Novel instructions are developed to support code sharing among instances, control functions, and variable initialization and finalization. The virtual machine is formally specified in RESOLVE. The specification does not describe a particular implementation. Using the specification, code can be generated without knowledge of how the architecture is realized, and formal verification of a RESOLVE compiler is (in principle) possible. A model of parallel execution suitable for RESOLVE reusable components is also developed. The model not only supports faster execution of RESOLVE programs, but encourages the development of layered software by increasing parallelism in correspondence to increases in layering. A distributed memory implementation of the virtual machine is designed to support the model of parallel execution. The implementation supports automatic parameter restoration and has a simple technique for the automatic synchronization of data accesses. Several other new features are found in the distributed memory implementation. It provides simple techniques for achieving dynamic scheduling and dynamic data distribution, and for associating variables with facility clones. This research is useful for other programming languages if programmers adhere to the style of programming described here. Programs written in Ada and C++, for example, can benefit from the implementation techniques described here.