Design and construction of a virtual machine resource binding language
Scott Davidson · 1980
The resource binding problem is defined as the problem of recognizing similarities between constructs used in a source program and constructs of a target virtual machine, and the problem of binding these source constructs to the appropriate target constructs. This dissertation describes a machine independent solution of the resource binding problem, a high level language incorporating this solution, the implementation of this language, and experiments conducted with the language. The Virtual Machine Resource Binding Language (MARBLE), is one of many possible languages that can solve the resource binding problem. The implementation of MARBLE described in this dissertation is designed for the class of microprogrammable architectures. Other architectures can serve as the target of other implementations of resource binding languages. The solution to the resource binding problem described in this dissertation consists of modelling target virtual machine resources by machine independent source language constructs. In MARBLE target data resources are modelled by type definitions, and target functional resources are modelled by procedure and function definitions. These models can be bound to the appropriate target resource through the use of a source language construct. Models must be constructed from machine independent language components, therefore if a model is left unbound, it is still a legal sequence of machine independent MARBLE code. Therefore all MARBLE programs are machine independent. MARBLE is a Pascal-based language. It was designed to be high level, and to support systematic programming. The MARBLE compiler was designed in four phases. The first phase performed lexical, syntactic, and semantic analyses on the source MARBLE program, and translated the MARBLE program into a High Level Intermediate Language, IL1. The second phase of the MARBLE compiler translated those parts of the IL1 program that were to be bound to target constructs into Low Level Intermediate Language code, which resembled the target microcode. The third phase of the compiler translated the unbound portion of the IL1 program into code for an Intermediate Language, IML. The fourth phase of the compiler translates the IML code into code for the target machine and merges this code with the code produced from the bound parts of the MARBLE program. In order to test this solution to the resource binding problem two MARBLE programs were written and compiled. The first was a program for the Prime 300 computer, which was compiled into microcode for the Microdata 3200. The successful compilation of this program, which used specific Prime 300 target data and functional resources, demonstrated that MARBLE programs are portable. The second program, for the Microdata 3200, was compiled with models of target resouces bound to the resources, and with the models unbound. When the models were unbound, they compiled into a subset of Microdata 3200 resources that could implement the semantics of MARBLE. A comparison of the code produced by these compilations indicates that the microcode produced with binding on was 30% of the size of the microcode produced with binding off. No optimization or compaction was done on this code. These results, and the implementation of the MARBLE compiler, indicate that resource binding through modelling is a valid solution of the resource binding problem.