Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
skip to main content
10.1145/53990acmconferencesBook PagePublication PagespldiConference Proceedingsconference-collections
PLDI '88: Proceedings of the ACM SIGPLAN 1988 conference on Programming language design and implementation
ACM1988 Proceeding
Publisher:
  • Association for Computing Machinery
  • New York
  • NY
  • United States
Conference:
PLDI88: SIGPLAN 88 Atlanta Georgia USA June 20 - 24, 1988
ISBN:
978-0-89791-269-3
Published:
01 June 1988
Sponsors:

Reflects downloads up to 12 Nov 2024Bibliometrics
Abstract

No abstract available.

Article
Free
Safety consideration for storage allocation optimizations
Article
Free
Real-time concurrent collection on stock multiprocessors

We've designed and implemented a copying garbage-collection algorithm that is efficient, real-time, concurrent, runs on commercial uniprocessors and shared-memory multiprocessors, and requires no change to compilers. The algorithm uses standard virtual-...

Article
Free
Detecting conflicts between structure accesses

Two references to a record structure conflict if they access the same field and at least one modifies the location. Because structures can be connected by pointers, deciding if two statements conflict requires knowledge of the possible aliases for the ...

Article
Free
Interprocedural slicing using dependence graphs

A slice of a program with respect to a program point p and variable x consists of all statements of the program that might affect the value of x at point p. This paper concerns the problem of interprocedural slicing — generating a slice of an entire ...

Article
Free
Article
Free
Interprocedural side-effect analysis in linear time

We present a new method for solving Banning's alias-free flow-insensitive side-effect analysis problem. The algorithm employs a new data structure, called the binding multi-graph, along with depth-first search to achieve a running time that is linear in ...

Article
Free
Register windows vs. register allocation

A large register set can be exploited by keeping variables and constants in registers instead of in memory. Hardware register windows and compile-time or link-time global register allocation are ways to do this. A measure of the effectiveness of any of ...

Article
Free
Article
Free
Minimizing register usage penalty at procedure calls

Inter-procedural register allocation can minimize the register usage penalty at procedure calls by reducing the saving and restoring of registers at procedure boundaries. A one-pass inter-procedural register allocation scheme based on processing the ...

Article
Free
Anatomy of a hardware compiler

Programming-language compilers generate code targeted to machines with fixed architectures, either parallel or serial. Compiler techniques can also be used to generate the hardware on which these programming languages are executed. In this paper we ...

Article
Free
Design and implementation of the UW Illustrated compiler

We have implemented an illustrated compiler for a simple block structured language. The compiler graphically displays its control and data structures, and so gives its viewers an intuitive understanding of compiler organization and operation. The ...

Article
Free
INC: a language for incremental computations
Article
Free
DOC: a practical approach to source-level debugging of globally optimized code

As optimizing compilers become more sophisticated, the problem of debugging the source code of an application becomes more difficult. In order to investigate this problem, we implemented DOC, a prototype solution for Debugging Optimized Code. DOC is a ...

Article
Free
A mechanism for efficient debugging of parallel programs

This paper addresses the design and implementation of an integrated debugging system for parallel programs running on shared memory multi-processors (SMMP). We describe the use of flowback analysis to provide information on causal relationships between ...

Article
Free
Debugging concurrent processes: a case study

We present a case study that illustrates a method of debugging concurrent processes in a parallel programming environment. It uses a new approach called speculative replay to reconstruct the behavior of a program from the histories of its individual ...

Article
Free
An efficient approach to data flow analysis in a multiple pass global optimizer

Data flow analysis is a time-consuming part of the optimization process. As transformations are made in a multiple pass global optimizer, the data flow information must be updated to reflect these changes. Various approaches have been used, including ...

Article
Free
Control flow analysis in scheme

Traditional flow analysis techniques, such as the ones typically employed by optimizing Fortran compilers, do not work for Scheme-like languages. This paper presents a flow analysis technique — control flow analysis — which is applicable to Scheme-like ...

Article
Free
An optimizer for Ada - design, experiences and results

In this paper we describe the design of a global machine independent low level optimizer for the Karlsruhe Ada Compiler. We give a short overview on the optimizations and data structures used in the optimizer as well as some experiences with the ...

Article
Free
Grammatical abstraction and incremental syntax analysis in a language-based editor

Processors for programming languages and other formal languages typically use a concrete syntax to describe the user's view of a program and an abstract syntax to represent language structures internally. Grammatical abstraction is defined as a ...

Article
Free
Higher-order abstract syntax

We describe motivation, design, use, and implementation of higher-order abstract syntax as a central representation for programs, formulas, rules, and other syntactic objects in program manipulation and other formal systems where matching and ...

Article
Free
An automatically generated, realistic compiler for imperative programming language

We describe the automatic generation of a complete, realistic compiler from formal specifications of the syntax and semantics of Sol/C, a nontrivial imperative language “sort of like C.” The compiler exhibits a three pass structure, is efficient, and ...

Article
Free
Semantic analysis in a concurrent compiler

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 ...

Article
Free
Compiling C for vectorization, parallelization, and inline expansion

Practical implementations of real languages are often an excellent way of testing the applicability of theoretical principles. Many stresses and strains arise from fitting practicalities, such as performance and standard compatibility, to theoretical ...

    Article
    Free
    Synchronous operations as first-class values

    Synchronous message passing via channels is an interprocess communication (IPC) mechanism found in several concurrent languages, such as CSP, occam, and Amber. Such languages provide a powerful selective I/O operation, which plays a vital role in ...

    Article
    Free
    Promises: linguistic support for efficient asynchronous procedure calls in distributed systems

    This paper deals with the integration of an efficient asynchronous remote procedure call mechanism into a programming language. It describes a new data type called a promise that was designed to support asynchronous calls. Promises allow a caller to run ...

    Article
    Free
    Multiprocessor Smalltalk: a case study of a multiprocessor-based programming environment

    We have adapted an interactive programming system (Smalltalk) to a multiprocessor (the Firefly). The task was not as difficult as might be expected, thanks to the application of three basic strategies: serialization, replication, and reorganization. ...

    Article
    Free
    A piggy-back compiler for Prolog
    Article
    Free
    Unfold/fold transformations and loop optimization of logic programs

    Programs typically spend much of their execution time in loops. This makes the generation of efficient code for loops essential for good performance. Loop optimization of logic programming languages is complicated by the fact that such languages lack ...

    Contributors

    Index Terms

    1. Proceedings of the ACM SIGPLAN 1988 conference on Programming language design and implementation

        Recommendations

        Acceptance Rates

        Overall Acceptance Rate 406 of 2,067 submissions, 20%
        YearSubmittedAcceptedRate
        PLDI '142875218%
        PLDI '132674617%
        PLDI '122554819%
        PLDI '031312821%
        PLDI '021692817%
        PLDI '011443021%
        PLDI '001733017%
        PLDI '991302620%
        PLDI '981363123%
        PLDI '971583120%
        PLDI '961122825%
        PLDI '951052827%
        Overall2,06740620%