Nothing Special   »   [go: up one dir, main page]

skip to main content
10.1145/378795acmconferencesBook PagePublication PagespldiConference Proceedingsconference-collections
PLDI '01: Proceedings of the ACM SIGPLAN 2001 conference on Programming language design and implementation
ACM2001 Proceeding
Publisher:
  • Association for Computing Machinery
  • New York
  • NY
  • United States
Conference:
PLDI01: ACM SIGPLAN 2001 Conference on Programming Language Design and Implementation Snowbird Utah USA
ISBN:
978-1-58113-414-8
Published:
20 June 2001
Sponsors:

Reflects downloads up to 12 Nov 2024Bibliometrics
Abstract

No abstract available.

Skip Table Of Content Section
Article
Design and implementation of generics for the .NET Common language runtime

The Microsoft.NET Common Language Runtime provides a shared type system, intermediate language and dynamic execution environment for the implementation and inter-operation of multiple source languages. In this paper we extend it with direct support for ...

Article
Dynamic software updating

Many important applications must run continuously and without interruption, yet must be changed to fix bugs or upgrade functionality. No prior general-purpose methodology for dynamic updating achieves a practical balance between flexibility, robustness, ...

Article
Demand-driven pointer analysis

Known algorithms for pointer analysis are “global” in the sense that they perform an exhaustive analysis of a program or program component. In this paper we introduce a demand-driven approach for pointer analysis. Specifically, we describe a demand-...

Article
Incrementalized pointer and escape analysis

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

Article
On the importance of points-to analysis and other memory disambiguation methods for C programs

In this paper, we evaluate the benefits achievable from pointer analysis and other memory disambiguation techniques for C/C++ programs, using the framework of the production compiler for the Intel® Itanium™ processor. Most of the prior work on memory ...

Article
Enforcing high-level protocols in low-level software
Article
Language support for regions

Region-based memory management systems structure memory by grouping objects in regions under program control. Memory is reclaimed by deleting regions, freeing all objects stored therein. Our compiler for C with regions, RC, prevents unsafe region ...

Article
Principled scavenging

Proof-carrying code and typed assembly languages aim to minimize the trusted computing base by directly certifying the actual machine code. Unfortunately, these systems cannot get rid of the dependency on a trusted garbage collector. Indeed, ...

Article
Java without the coffee breaks: a nonintrusive multiprocessor garbage collector

The deployment of Java as a concurrent programming language has created a critical need for high-performance, concurrent, and incremental multiprocessor garbage collection. We present the Recycler, a fully concurrent pure reference counting garbage ...

Article
Heap profiling for space-efficient Java

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

Article
Composing high-performance memory allocators
Article
A parallel, real-time garbage collector

We describe a parallel, real-time garbage collector and present experimental results that demonstrate good scalability and good real-time bounds. The collector is designed for shared-memory multiprocessors and is based on an earlier collector algorithm [...

Article
Bytecode compression via profiled grammar rewriting

This paper describes the design and implementation of a method for producing compact, bytecoded instruction sets and interpreters for them. It accepts a grammar for programs written using a simple bytecoded stack-based instruction set, as well as a ...

Article
Using annotations to reduce dynamic optimization time

Dynamic compilation and optimization are widely used in heterogenous computing environments, in which an intermediate form of the code is compiled to native code during execution. An important trade off exists between the amount of time spent ...

Article
A framework for reducing the cost of instrumented code

Instrumenting code to collect profiling information can cause substantial execution overhead. This overhead makes instrumentation difficult to perform at runtime, often preventing many known offline feedback-directed optimizations from being used in ...

Article
Timestamped whole program path representation and its applications

A whole program path (WPP) is a complete control flow trace of a program's execution. Recently Larus [18] showed that although WPP is expected to be very large (100's of MBytes), it can be greatly compressed (to 10's of MBytes) and therefore saved for ...

Article
Efficient representations and abstractions for quantifying and exploiting data reference locality

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

Article
Automatic predicate abstraction of C programs

Model checking has been widely successful in validating and debugging designs in the hardware and protocol domains. However, state-space explosion limits the applicability of model checking tools, so model checkers typically operate on abstractions of ...

Article
Related field analysis

We present an extension of field analysis (sec [4]) called related field analysis which is a general technique for proving relationships between two or more fields of an object. We demonstrate the feasibility and applicability of related field analysis ...

Article
The pointer assertion logic engine

We present a new framework for verifying partial specifications of programs in order to catch type and memory errors and check data structure invariants. Our technique can verify a large class of data structures, namely all those that can be expressed ...

Article
A unified framework for schedule and storage optimization

We present a unified mathematical framework for analyzing the tradeoffs between parallelism and storage allocation within a parallelizing compiler. Using this framework, we show how to find a good storage mapping for a given schedule, a good schedule ...

Article
Optimal spilling for CISC machines with few registers

Many graph-coloring register-allocation algorithms don't work well for machines with few registers. Heuristics for live-range splitting are complex or suboptimal; heuristics for register assignment rarely factor the presence of fancy addressing modes; ...

Article
Ultra-fast aliasing analysis using CLA: a million lines of C code in a second

We describe the design and implementation of a system for very fast points-to analysis. On code bases of about million lines of unpreprocessed C code, our system performs field-based Andersen-style points-to analysis in less than a second and uses less ...

Article
Dynamic variables

Most programming languages use static scope rules for associating uses of identifiers with their declarations. Static scope helps catch errors at compile time, and it can be implemented efficiently. Some popular languages—Perl, Tel, TeX, and Postscript—...

Article
Asynchronous exceptions in Haskell

Asynchronous exceptions, such as timeouts are important for robust, modular programs, but are extremely difficult to program with — so much so that most programming languages either heavily restrict them or ban them altogether. We extend our earlier ...

Article
Exact analysis of the cache behavior of nested loops

We develop from first principles an exact model of the behavior of loop nests executing in a memory hicrarchy, by using a nontraditional classification of misses that has the key property of composability. We use Presburger formulas to express various ...

Article
SPL: a language and compiler for DSP algorithms

We discuss the design and implementation of a compiler that translates formulas representing signal processing transforms into efficient C or Fortran programs. The formulas are represented in a language that we call SPL, an acronym from Signal ...

Article
ESP: a language for programmable devices

This paper presents the design and implementation of Event-driven State-machines Programming (ESP)—a language for programmable devices. In traditional languages, like C, using event-driven state-machine forces a tradeoff that requires giving up ease of ...

Article
Facile: a language and compiler for high-performance processor simulators

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

Contributors
  • Rice University
  • University of Virginia

Index Terms

  1. Proceedings of the ACM SIGPLAN 2001 conference on Programming language design and implementation
    Please enable JavaScript to view thecomments powered by Disqus.

    Recommendations

    Acceptance Rates

    PLDI '01 Paper Acceptance Rate 30 of 144 submissions, 21%;
    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%