This research investigates how much useful information about the structure of software systems can be obtained using existing software tools to analyze compiled programs. This research arose from the observation that the compiled object units for a software system must necessarily contain enough structural information so that the object units can be successfully linked into a complete executable program. We developed a suite of tools that extract this structural information directly from the object units.

Abstract This paper describes the issues involved in sharing data among processes executing co‐operatively in a heterogeneous computing environment. In a heterogeneous environment, the physical representation of a data object may need to be transformed when the object is moved from one type of processor to another. As a part of a larger project to build a heterogeneous distributed shared memory system we developed an automated tool for generating the conversion routines that are used to implement representation conversion for data objects. We developed a novel method for processing source programs that allowed us to extract detailed information about the physical representation of data objects without access to the source code of the compilers that were generating those representations. A performance comparison with the more general XDR heterogeneous data conversion package shows that the customized conversion routines that we generate are 4 to 8 times faster.

In this paper we describe a collection of techniques for the design and implementation of concurrent compilers. We begin by describing a technique for dividing a source program into many streams so that each stream can be compiled concurrently. We discuss several compiler design issues unique to concurrent compilers including source program partitioning, symbol table management, compiler task scheduling and information flow constraints. The application of our techniques is illustrated by a complete design for a concurrent Modula-2+ compiler. After describing the structure of this compiler's performance that demonstrates that significant improvements in compilation time can be achieved through the use of concurrency.

The design, implementation, and performance of heterogeneous distributed shared memory (HDSM) are studied. A prototype HDSM system that integrates very different types of hosts has been developed, and a number of applications of this system are reported. Experience shows that despite a number of difficulties in data conversion, HDSM is implementable with minimal loss in functional and performance transparency when compared to homogeneous DSM systems.>

Abstract Concurrency is an attractive method for reducing the execution time of compilers. By dividing source programs into segments which can be compiled concurrently, the task of compiling programs can be accelerated. Many of the difficult problems which arise when constructing a concurrent compiler occur in the implementation of the semantic analyser. This paper investigates the problems involved in designing the semantic analyser for a concurrent compiler for a modern, block‐structured language. Several approaches to solving the problems which arise are presented. These solutions are then implemented as part of a concurrent Modula‐2 + compiler, running on a shared memory multiprocessor. A performance evaluation of these semantic analysers is presented.

Traditional compilers are usually sequential programs that serially process source programs through lexical analysis, syntax analysis, semantic analysis and code generation. The availability of multiprocessor computers has made it feasible to consider alternatives to this serial compilation process. The authors are currently engaged in a project to devise ways of structuring compilers so that they can take advantage of modern multiprocessor hardware. This paper is about the most difficult aspect of concurrent compilation: concurrent semantic analysis.

This paper describes some simple programming language facilities for raising and handling exceptions, and demonstrates, with a number of examples, their effectiveness in a scientific computing environment. Only a small number of predefined exceptions need to be introduced into the language, but any number of user-defined exceptions can he introduced by the programmer. A key feature is that handlers are attached to operators that can raise exceptions (including user-defined functions and procedures, as well as built-in operators), rather than to expressions or statements. The programmer has a great deal of freedom in specifying what action is to be taken in case an exception arises. The implementation and the applications are mainly concerned with scientific computing, but we believe the facilities are applicable in other areas as well.

The "software hut" is a course project that is used in conjunction with a graduate-level course in software engineering. The purpose of this project is to give the students some "real world" experience with the design and implementation of software. This paper describes the author's experience in using such a project and presents some suggestions on how a project should be organized.

S/SL (Syntax/Semantic Language) is a language that was developed for implementing compilers.A subset called SL (Syntax Language) has the same recognition power as do LR(k) parsers.Complete S/SL includes invocation of semantic operations implemented in another language such as PASCAL.S/SL implies a top-down programming methodology.First, a data-free algorithm is developed in S/SL.The algorithm invokes operations on "semantic mechanisms."A semantic mechanism is an abstract object, specified, from the point of view of the S/SL, only by the effect of operations upon the object.Later, the mechanisms are implemented apart from the S/SL program.The separation of the algorithm from the data and the division of data into mechanisms reduce the effort needed to understand and maintain the resulting software.S/SL has been used to construct compilers for SPECKLE (a PL/I subset), PT (a PASCAL subset), Toronto EUCLID, and Concurrent EUCLID.It has been used to implement scanners, parsers, semantic analyzers, and code generators.S/SL programs are implemented by translating them into tables of integers.A "table walker" program executes the S/SL program by interpreting this table.The translation of S/SL programs into tables is performed by a program called the S/SL processor.This processor serves a function analogous to that served by an LR(k) parser generator.The implementation of S/SL is simple and portable.It is available in a small subset of PASCAL that can easily be transliterated into other high-level languages.

article Free Access Share on A Model for Implementing EUCLID Modules and Prototypes Authors: Richard C. Holt Computer Systems Research Group, University of Toronto, Toronto, Ontario, Canada M5S 1A1 Computer Systems Research Group, University of Toronto, Toronto, Ontario, Canada M5S 1A1View Profile , David B. Wortman Computer Systems Research Group, University of Toronto, Toronto, Ontario, Canada M5S 1A1 Computer Systems Research Group, University of Toronto, Toronto, Ontario, Canada M5S 1A1View Profile Authors Info & Claims ACM Transactions on Programming Languages and SystemsVolume 4Issue 4Oct. 1982 pp 552–562https://doi.org/10.1145/69622.357183Published:01 October 1982Publication History 5citation236DownloadsMetricsTotal Citations5Total Downloads236Last 12 Months6Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my Alerts New Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

The design of the programming language Euclid requires that a compiler for the language produce legality assertions to aid in verification of programs written in the language. This paper analyzes the legality assertions that must be produced and discusses the impact that this requirement has on the implementation of the language.

The Software Hut (a small software house) is a course project designed for a graduate-level course in computer program engineering. This paper describes the Software Hut project and discusses the authors' experience using it in graduate courses at the University of Toronto. Suggestions for improvements in the project are given.

Abstract This paper describes an experimental evaluation of the execution speed of object programs produced by six PL/I compilers. A set of 139 representative PL/I statements were compiled and executed under the PL/I Optimizing, PL/I(F), PL/C, PL/I Checkout, SP/k and PLUTO compilers. An analysis is made of the relative speed of the object code produced by each compiler and also of the relative execution speed of each statement.

This correspondence describes an experimental comparison of timing information provided by a large multiprogramming operating system (OS/360 MVT) with timing information derived directly from a high-resolution hardware clock. The hardware clock was found to be a superior source of timing information.

This paper gives a brief introduction to a sequence of subsets of the PL/I language that has been designed for the purpose of teaching introductory computer, programming.The six subsets, called SP/I, SP/2, ..., SP/6, restrict PL/I to language features which the authors feel encourage good programming habits.Each subset introduces new language features while retaining features introduced in earlier subsets.