bluuebunny/crossref_metadata_2025_split huggingface dataset:
Incrementalized pointer and escape analysis
Authors: Vivien Frédéric , Rinard Martin 
Published: November 2005

We present a new pointer and escape analysis. Instead of analyzing the whole program, the algorithm incrementally analyzes only those parts of the program that may deliver useful results. An analysis policy monitors the analysis results to direct the incremental investment of analysis resources to those parts of the program that offer the highest expected optimization return.
Our experimental results show that almost all of the objects are allocated at a small number of allocation sites and that an incremental analysis of a small region of the program surrounding each site can deliver almost all of the benefit of a whole-program analysis. Our analysis policy is usually able to deliver this benefit at a fraction of the whole-program analysis cost.
Heap profiling for space-efficient Java
Authors: Shaham Ran , Kolodner Elliot K. , Sagiv Mooly 
Published: November 2005

We present a heap-profiling tool for exploring the potential for space savings in Java programs. The output of the tool is used to direct rewriting of application source code in a way that allows more timely garbage collection (GC) of objects, thus saving space. The rewriting can also avoid allocating some objects that are never used.
The tool measures the difference between the actual collection time and the potential earliest collection time of objects for a Java application. This time difference indicates potential savings. Then the tool sorts the allocation sites in the application source code according to the accumulated potential space saving for the objects allocated at the sites. A programmer can investigate the source code surrounding the sites with the highest savings to find opportunities for code rewriting that could save space. Our experience shows that in many cases simple code rewriting leads to actual space savings and in some cases also to improvements in program runtime.
Experimental results using the tool and manually rewriting code show average space savings of 18% for the SPECjvm98 benchmark suite. Results for other benchmarks are also promising. We have also classified the program transformations that we have used and argue that in many cases improvements can be achieved by an optimizing compiler.
Efficient representations and abstractions for quantifying and exploiting data reference locality
Authors: Chilimbi Trishul M. 
Published: November 2005

With the growing processor-memory performance gap, understanding and optimizing a program's reference locality, and consequently, its cache performance, is becoming increasingly important. Unfortunately, current reference locality optimizations rely on heuristics and are fairly ad-hoc. In addition, while optimization technology for improving instruction cache performance is fairly mature (though heuristic-based), data cache optimizations are still at an early stage. We believe the primary reason for this imbalance is the lack of a suitable representation of a program's dynamic data reference behavior and a quantitative basis for understanding this behavior.
We address these issues by proposing a quantitative basis for understanding and optimizing reference locality, and by describing efficient data reference representations and an exploitable locality abstraction that support this framework. Our data reference representations (Whole Program Streams and Stream Flow Graphs) are compact—two to four orders of magnitude smaller than the program's data reference trace—and permit efficient analysis—on the order of seconds to a few minutes—even for complex applications. These representations can be used to efficiently compute our exploitable locality abstraction (hot data streams). We demonstrate that these representations and our hot data stream abstraction are useful for quantifying and exploiting data reference locality. We applied our framework to several SPECint 2000 benchmarks, a graphics program, and a commercial Microsoft database application. The results suggest significant opportunity for hot data stream-based locality optimizations.
Facile
Authors: Schnarr Eric C. , Hill Mark D. , Larus James R. 
Published: November 2005

Architectural simulators are essential tools for computer architecture and systems research and development. Simulators, however, are becoming frustratingly slow, because they must now model increasingly complex micro-architectures running realistic workloads. Previously, we developed a technique called fast-forwarding, which applied partial evaluation and mermoization to improve the performance of detailed architectural simulations by as much as an order of magnitude [14].
While writing a detailed processor simulator is difficult, implementing fast-forwarding is even more complex. This paper describes Facile, a domain-specific language for writing detailed, accurate micro-architecture simulators. Architectural descriptions written in Facile can be compiled, using partial evaluation techniques, into fast-forwarding simulators that achieve significant performance improvements with far less programmer effort. Facile and its compiler make this performance-enhancing technique accessible to computer architects.
Generating Decision Trees for Decoding Binaries
Authors: Theiling Henrik 
Published: November 2005

Tools reading binary code, like analysers, debuggers, disassemblers, etc., need to decode the target's machine code. A decision tree is often used to represent the decoding function.
Manually writing a decoder is a lengthy and error-prone task. It is desirable to be able to use the vendor's instruction code manual and to easily transform the documentation into a specification that a tool can use to generate a decoder.
This paper presents a novel algorithm that computes a decision tree from machine code bit patterns alone. Neither the bit fields of the machine code, nor the width of the machine command, nor the order in which the bits should be decoded need to be specified. The decoding algorithm accesses any significant bit exactly once during decoding.
Dealing with Hardware in Embedded Software
Authors: Mérillion Fabrice , Muller Gilles 
Published: November 2005

Writing code that talks to hardware is a crucial part of any embedded project. Both productivity and quality are needed, but some flaws in the traditional development process make these requirements difficult to meet.
We have recently introduced a new approach of dealing with hardware, based on the Devil language. Devil allows to write a high-level, formal definition of the programming interface of a peripheral circuit. A compiler automatically checks the consistency of a Devil specification, from which it generates the low-level, hardware-operating code.
In our original framework, the generated code is dependent of the host architecture (CPU, buses, and bridges). Consequently, any variation in the hardware environment requires a specific tuning of the compiler. Considering the variability of embedded architectures, this is a serious drawback. In addition, this prevents from mixing different buses in the same circuit interface.
In this paper, we remove those limitations by improving our framework in two ways. (i) We propose a better isolation between the Devil compiler and the host architecture. (ii) We introduce Trident, a language extension aimed at mapping one or several buses to each peripheral circuit.
The Trellis programming environment
Authors: O'Brien Patrick D. , Halbert Daniel C. , Kilian Michael F. 
Published: November 2005

The Trellis programming environment supports programming in Trellis/Owl, an object-based language with multiple inheritance and compile-time type-checking. Trellis is composed of a number of integrated tools that share a common programming environment database. It is a highly interactive, easy-to-use programming environment, providing various programming aids, incremental compilation, and good debugging support. Trellis is both integrated and open-ended.
Trellis was specifically designed to support the object-oriented programming methodology. Thus it provides tools to manage the use of types and inheritance. Trellis takes advantage of the strong-typing features of the Trellis/Owl language to provide more support for the programmer by keeping track of cross-references and inconsistencies in code.
CLAM- an open system for graphical user interfaces
Authors: Call Lisa A. , Cohrs David L. , Miller Barton P. 
Published: November 2005

CLAM is an object-oriented system designed to support the building of extensible graphical user interfaces. CLAM provides a basic windowing environment with the ability to extend its functions using dynamically loaded C++ classes. The dynamically loaded classes allow for performance tuning (by transparently loading the class in either the client or the CLAM server) and for sharing of new functions.
In addition to the traditionally layering of output abstractions, CLAM allows the programmer to easily layer input abstractions. The input functions include providing distributed upward calls through the layers, an light weight processes to support asynchronous input.
CLAM is currently running under 4.3BSD UNIX on a MicroVax-II workstation.
The Poe language-based editor project
Authors: Fischer C. N. , Johnson Gregory F. , Mauney Jon , Pal Anil , Stock Daniel L. 
Published: November 2005

Editor Allan Poe (Pascal Oriented Editor) is a full-screen language-based editor (LBE) that knows the syntactic and semantic rules of Pascal. It is the first step in development of a comprehensive Pascal program development environment.
Poe's design began in 1979; version 1 is currently operational on Vax 11s under Berkeley Unix and on HP 9800-series personal workstations. Poe is written in Pascal, and is designed to be readily transportable to new machines. An editor-generating system called Poegen is operational, and much of the language-specific character of Poe is table-driven and retargetable.
The Darwin software-evolution environment
Authors: Minsky N. , Borgida A. 
Published: November 2005

The main goal of the Darwin software development environment is to establish a rigorous authorization-based discipline which can be used to impose constraints on the structure and operations of software systems as well as on their process of development Such constraints might be desirable to serve the following needs:
• The need to provide support and enforcement for such software engineering techniques as informationhiding, data abstraction and modularization, even when these techniques are not offered by the programming language itself.
•The need to support rules which govern the real enterprise being served by the system, and which must be invariant of the evolutionary behaviou of the system.
• The need to enforce managerial policies concerning the process of system development itself.
Document structure and modularity in mentor
Authors: Donzeau-Gouge V. , Kahn G. , Lang B. , Mélèse B. 
Published: November 2005

Mentor is a structured document manipulation system. It has been used for several years as a program development and maintenance environment.
Its main characteristics are:
it is both interactive and programmable,
it is parameterized by the language to be manipulated,
it can manipulate several languages at the same time, as well as multi-lingual documents.
it is open to and from the outer system,
it is extensible.
The current development of Mentor reflects our belief that a major component of programming is the maintenance of large documents of a varied nature: specifications, programs, manuals, progress reports, documentation, etc... In addition, information of various kinds, and in different languages, is often mixed in a single document, and one may have to extract this information selectively upon request (e.g. text, examples and formal specification in a manual, or instructions, comments and assertions in a program).
Preliminary experience with a configuration control system for modular programs
Authors: Estublier J. , Ghoul S. , Krakowiak S. 
Published: November 2005

This paper describes some preliminary experience gathered during the implementation and early use of a program composition and version control system. This system has been designed and implemented as a part of the Adele research project, a programming environment for the production of modular programs (Estublier 83). This project has four main components: a) a program editor, interpreter and debugger; b) a parameterized code generator; c) a user interface; d) a program base, the subject of this paper. The current version of this environment has been developed on a Multics system.
The program base, including the system composition and version control mechanisms, has been used for six months, notably for its own development and maintenance.
Global common subexpression elimination
Authors: Cocke John 
Published: November 2005

When considering compiler optimization, there are two questions that immediately come to mind; one, why and to what extent is optimization necessary and two, to what extent is it possible.
When considering the second question, one might immediately become discouraged since it is well known that the program equivalency problem is recursively unsolvable. It is, of course, clear from this that there will never be techniques for generating a completely optimum program. These unsolvability results, however, do not preclude the possibility of ad hoc techniques for program improvement or even a partial theory which produces a class of equivalent programs optimized in varying degrees.
The reasons why optimization is required seem to me to fall in two major categories. The first I will call “local” and the second “global”.
Report of session on semantics
Authors: Dennis Jack B. 
Published: November 2005

This session was devoted to consideration of the potential value of ideas in formal semantics for application to the specification and implementation of operating systems, and the benefits and issues that would arise from such use.
Jack Dennis introduced the session by noting that formal definitions of programming languages, such as the definition of PL/I in the Vienna Definition Language, are intended to serve two major practical objectives: 1) to ensure consistent interpretation of language constructs between computer systems so programs may be readily transferred; 2) to provide a standard with respect to which the correctness of implementations may be tested and verified. In contemporary systems user or application programs usually depend, for correct operation, on system facilities for file manipulation, communication, concurrent processing, and controlled access to data and procedures, as well as the linguistic constructs of conventional programming languages. Thus the same practical objectives for application of formal definition techniques hold for operating systems as for programming languages.
Abstract machines and software design
Authors: King J. C. 
Published: November 2005

A recent trend in operating system design [1,2,6,7] is to consider the design as a hierarchy of abstract machines. The problem is viewed as constructing a “users' machine” from a given hardware machine by means of software. Rather than do this in one large step, a progression of abstract machines are defined starting at the hardware machine and ending with the users' machine. Each new machine is “built from” the earlier machines, adding to their capabilities.
This approach appears to be a strong positive step toward bringing more discipline to the software development process. Liskov [6, 7] carefully documents the advantages. She also tries to establish formal rules to guide the process and relates this approach to structured programming [3, 8].
A Kernel System for information system development, evolution, and operation
Authors: Mills Harlan D. , Wilson Max L. 
Published: November 2005

We believe that the current boundaries and distinctions between operating systems, data base management systems (both “host language” and “self-contained”), programming language processors (both interpretive and compiled), programming support systems (library management, testing, and integration services), instructional systems, and certain other generalized data processing services, can and should be eliminated. That is, we believe that all these seemingly separate functions, which are currently separate for historical reasons as much as any other, can and should be addressed by a single integrated (but subsettable) “Kernel System”.
We also believe that with the proper system architecture and implementation techniques (e.g., top-down and structured programming) and with the wholesale elimination of duplicated functions, a Kernel System can be built that would address the sum total of these functions and, at the same time, remain comparable in size and complexity to a typical self-contained data base management system alone. Further, such a structured Kernel System would be much better able to support the development, continued evolution, and operation of both itself and its applications.
Programming by semantic refinement
Authors: Morris James B. 
Published: November 2005

It is becoming increasingly evident that human programmers are not capable of efficiently producing reliable programs if they must be concerned initially with every detail of the final program. The approach described here is one of “semantic levels of programming”, which involves a graduated approach to the production of programs.
A common but fallacious belief of some software implementors today is that the efficient execution of software systems should be a major concern in the initial system version. In fact, the primary concern in the initial version should be the reliable operation of the system, which is closely connected with the existence of a sound, overall system design. Assuming that we recognize that there is some reasonable time from the initiation of a software system implementation project to the availability of an initial version, the philosophy of semantic refinement is based on the belief that: “If a major concern in the implementation of the initial version of a software system is efficiency, then the initial version will be unreliable.” Many systems which are initially unreliable have a way of remaining unreliable for a discouragingly long period of time.
Procedural encapsulation
Authors: Zilles Stephen N. 
Published: November 2005

System reliability is an important aspect of operating system construction. Because of this, a number of researchers have proposed design methodologies [e. g., 1, 2, 3] which are intended to produce more reliable software. Although the methodologies differ, there seem to be some important properties that they have in common.
One property is the decomposition of the system into components or modules which make as few assumptions as possible about the other components. We will call this the “minimal assumptions” property. Minimizing the assumptions one component makes about another component means that subsequent maintenance and extensions can be done with a smaller probability of introducing errors. A programmer is less likely to overlook critical, obscure interconnections if such interconnections are severely restricted.
Array processing on an array processor
Authors: Erickson David B. 
Published: November 2005

Central memory is distributed across several processing elements on the ILLIAC-IV and similar array processors. This causes memory to appear two dimensional and raises special problems in the handling of arrays. Assignment of arrays to storage, and development of efficient array mapping functions and accessing techniques are all much more difficult than on conventional machines with “linear” memories. This paper discusses these problems as they relate to IVTRAN, a Fortran-like compiler for the ILLIAC-IV. Alternate solutions, useful in a different environment, are also explored.
We shall start by giving a brief overview of the pertinent features of the ILLIAC-IV. The paper then describes IVTRAN constructs which may be used in expressing parallelism and the implications that these constructs have for array storage. Next, array mapping formulas are developed and the array packing problem is treated. Finally, argument passage and Fortran COMMON and EQUIVALENCE statements are discussed.
DMAP-a COBOL extension for associative array processors
Authors: Resnick Harold K. , Larson Arvid G. 
Published: November 2005

This paper defines a high-level programming language for a generalized associative array processor (AP). In particular, a data management language for APs, known as DMAP, is developed for use with a representative AP model. This development model, containing both an associative processing section and a sequential processing section, which may operate concurrently, follows current AP design technology[1]. DMAP fully exploits the capabilities available in current AP technology by extending ANSI COBOL [2,3] to support data management functions in an AP environment.
There exists general agreement that the use of a high-level language can significantly facilitate the AP programming process in many applications [4,5]. However, a search of the literature suggests that few attempts at high-level language implementation, or even definition, have been made to date [6,7]. The several additional and unique difficulties associated with application-oriented programming of parallel processors in general, and APs in particular, mandates a high-level language capability to produce cost-effective utilization of their processing resources. This paper considers one approach, a first step, toward this development of a high-level language capability to provide some alleviation of immediate programming difficulties as well as provide a tool for further exploration of AP technology.
Program optimization - theory and practice
Authors: Loveman David B. , Faneuf Ross A. 
Published: November 2005

The conventional program optimization techniques employed by the ILLIAC FORTRAN compiler are general purpose, effective, and efficient. The underlying theory is applicable to FORTRAN and to other high level languages. A unique approach to the gathering of global set and use information about variables as well as careful software engineering of the algorithms has led to the construction of an effective source-to-source optimizer which performs constant propagation, constant computation, common subexpression elimination, reduction in strength, and invariant code motion.
We will first consider the type of information which must be gathered about a program, and how this information is used to perform optimization. Then we shall state the algorithm for globally computing the set and use information for program variables. Having discussed the science of optimization we shall turn to the engineering aspects and consider such topics as representation of programs, order of optimization transformations, and efficient computation of global use and set information.
A parallel approach to code generation for Fortran like compilers
Authors: Krohn Howard E. 
Published: November 2005

It has been shown by Lincoln and others that vector operations can be used to perform lexical analysis of FORTRAN source code. This paper presents techniques for code generation using parallel programming methods developed on the CDC STAR-100.
Methods are presented for handling arithmetic assignment statements, DO loops, IF statements, and parenthetical expressions. A CO-NO table syntactical analysis is performed using the numeric vector from lexical analysis to produce output code for arithmetic expressions. Code for DO loops and IF statements is then merged into the object code vector.