This directory is created automatically and some papers may be mislabeled. Only document within the CiteSeer database are listed. The directory is intended to provide entry points for browsing the database and is not intended to be authoritative. Papers may not appear in all relevant categories. For example, papers in a sub-category may not appear in higher level categories.
534 Active Messages: a Mechanism for Integrated Communication and.. - von Eicken, Culler, Goldstein.. (1992)(Correct)
The design challenge for large-scale multiprocessors is (1) to minimize communication overhead, (2) allow communication to overlap computation, and (3) coordinate the two without sacrificing processor... / latency tolerance becomes a programming compiling concern. Hardware br models where the programmer and compiler respectively have control over
362 Aspect-Oriented Programming - Kiczales, Irwin, Lamping, Loingtier, .. (1997)(Correct)
this paper, we present an overview of our recent research on programming language expressivity.
The goal of this work is to make it possible for programs to clearly capture all of the
important aspect... / Aspect-Oriented Programming Gregor K Iczales John br then compiled using a traditional compiler. The woven code for this example
270 Proof-Carrying Code - Necula (1997)(Correct)
This paper describes proof-carrying code (PCC), a mechanism by which a host system can determine with certainty that it is safe to execute a program supplied (possibly in binary form) by an untrusted ... / For this to be possible the compiler designer defines the safety policy br Introduction High-level programming languages are designed and
258 Parallel Programming in Split-C - Culler (1993)(Correct)
We introduce the Split-C language, a parallel extension
of C intended for high performance programming
on distributed memory multiprocessors, and demonstrate
the use of the language in optimizing para... / Parallel Programming in Split-C David E. Culler br the programmer specifies the compiler takes care of addressing and
238 The essence of functional programming - Wadler (1992)(Correct)
This paper explores the use monads to structure functional programs. No prior knowledge of monads or category theory is required. Monads increase the ease with which programs may be modified. They can... / The essence of functional programming Philip Wadler University of br sketches how monads are used in a compiler for Haskell that is written in
232 Tempest and Typhoon: User-Level Shared Memory - Reinhardt, Larus, Wood (1994)(Correct)
Future parallel computers must efficiently execute not
only hand-coded applications but also programs written in
high-level, parallel programming languages. Today's
machines limit these programs to a ... / written in high-level parallel programming languages. Today's machines br mechanisms so programmers and compilers can customize policies for a
223 Revised^4 Report on the Algorithmic Language Scheme - Clinger, (ed.), Rees, (ed.).. (1991)(Correct)
Programming languages should be designed not by piling feature on top of feature, but by removing the weaknesses and restrictions that make additional features appear necessary. Scheme demonstrates th... / a defining description of the programming language Scheme. Scheme is a br upgraded to support an innovative compiler Three distinct projects
200 Uniprocessor Garbage Collection Techniques - Wilson (1992)(Correct)
We survey basic garbage collection algorithms, and variations such as incremental and generational collection. The basic algorithms include reference counting, mark-sweep, mark-compact, copying, and t... / App While in many systems programmers must explicitly reclaim heap br abstractions. For example many compilers fail when faced with
183 The Oz Programming Model - Smolka (1995)(Correct)
The Oz Programming Model (OPM) is a concurrent programming model subsuming higher- order functional and object-oriented programming as facets of a general model. This is particularly interesting for c... / The Oz Programming Model Gert Smolka br features an incremental compiler and a run-time system with an
181 The Amber System: Parallel Programming on a Network of Multiprocessors - Chase (1989)(Correct)
Microprocessor-based shared-memory multiprocessors are becoming widely available and
promise to provide cost-effective high-performance computing.
This paper describes a programming system called Ambe... / The Amber System Parallel Programming on a Network of br and eliminating the need for a compiler. ffl The concurrency model of
179 Munin: Distributed Shared Memory Based on Type-Specific Memory.. - Bennett, Carter, Zwaenepoel (1990)(Correct)
We are developing Munin, a system that allows programs written for shared memory multiprocessors to be executed efficiently on distributed memory machines. Munin attempts to overcome the architectural... / advantages in terms of ease of programming. Our system is unique in its br hints from the user or the compiler to determine the coherence
179 Orca: A Language For Parallel Programming Of Distributed Systems - Bal, Kaashoek, Tanenbaum (1992)(Correct)
Orca is a language for implementing parallel applications on loosely coupled distributed
systems. Unlike most languages for distributed programming, it allows processes on
different machines to share ... / Orca Alanguage For Parallel Programming Of Distributed Systems Henri br be achieved through an optimizing compiler. Language designers frequently
174 APRIL: A Processor Architecture for Multiprocessing - Agarwal (1990)(Correct)
Processors in large-scale multiprocessors must be able to tolerate large communication latencies and synchronization delays. This paper describes the architecture of a rapid-context-switching processo... / system architecture and the programming model. The architecture of br only the processor but also the compiler and run-time system we were
170 Imperative functional programming - Jones, Wadler (1993)(Correct)
We present a new model, based on monads, for performing input/output in a non-strict, purely functional language. It is composable, extensible, efficient, requires no extensions to the type system, an... / Imperative functional programming Simon L Peyton Jones Philip br ffl It is efficient. Our Haskell compiler has C as its target code. Given
170 KIDS: A Semi-Automatic Program Development System - Smith (1990)(Correct)
The Kestrel Interactive Development System (KIDS) provides automated support for the development of correct and efficient programs from formal specifications. The system has components for performing ... / economical to use for routine programming. To illustrate the use of KIDS br executable form by a conventional compiler. The initial algorithm that KIDS
162 Performance of Various Computers Using Standard Linear Equations.. - Dongarra (1995)(Correct)
This report compares the performance of different computer systems in solving dense systems of linear equations. The comparison involves approximately a hundred computers, ranging from a Cray Y-MP to ... / the effects of typical Fortran programming and the results that can be br or multiple processors. The compilers on some machines may of
161 The MIT Alewife Machine: A Large-Scale Distributed-Memory.. - Agarwal, Chaiken, Johnson, Kranz.. (1991)(Correct)
The Alewife multiprocessor project focuses on the architecture and design of a large-scale parallel machine. The machine uses a low dimension direct interconnection network to provide scalable communi... / allows efficient shared memory programming through a multilayered br and latency tolerance. The compiler runtime system and hardware
157 Pizza into Java: Translating theory into practice - Odersky (1997)(Correct)
Pizza is a strict superset of Java that incorporates three ideas from the academic community: parametric polymorphism, higher-order functions, and algebraic data types. Pizza is defined by translation... / These eliminate some sources of programming errors and enhance the br size for speed by adjusting their compilers rather than by rewriting their
157 The MIT Alewife Machine: Architecture and Performance - Agarwal, Bianchini, Chaiken, al (1995)(Correct)
Alewife is a multiprocessor architecture that supports up to 512 processing nodes connected over a scalable and cost-effective mesh network at a constant cost per node. The MIT Alewife machine, a prot... / system can be both scalable and programmable. Four mechanisms combine to br integrated message passing allows compiler and operating system designers
155 The Omega Test: a fast and practical integer programming algorithm.. - Pugh (1993)(Correct)
The Omega test is an integer programming algorithm that can determine whether a dependence exists
between two array references, and if so, under what conditions. Conventional wisdom holds that integer... / a fast and practical integer programming algorithm for dependence br suitable for use in production compilers. Experiments suggest that for
153 Points-to analysis in almost linear time - Steensgaard (1996)(Correct)
We present an interprocedural points-to analysis based on type inference that has an almost linear time cost complexity. To our knowledge, this is the fastest points-to analysis algorithm yet describe... / is borrowed from the C programming language KR All variables br subsequent program analyses in a compiler including a more precise
151 Lazy Task Creation: A Technique for Increasing the Granularity of.. - Mohr, Kranz, Halstead, Jr. (1990)(Correct)
Many parallel algorithms are naturally expressed at a fine level of granularity, often finer than a MIMD parallel system can exploit efficiently. Most builders of parallel systems have looked to eithe... / systems have looked to either the programmer or a parallelizing compiler to br the programmer or a parallelizing compiler to increase the granularity of
145 The Network Architecture of the Connection Machine CM-5 - Leiserson, Abuhamdeh, Douglas.. (1994)(Correct)
The Connection Machine Model CM-5 Supercomputer is a massively parallel computer system designed to offer performance in
the range of 1 teraflops (10
12
floating-point operations per second). The CM... / while offering ease of programming flexibility and reliability. br To access the network a user or compiler reads from or writes to
138 A Survey of Program Slicing Techniques - Tip (1995)(Correct)
A program slice consists of the parts of a program that (potentially) affect the
values computed at some point of interest, referred to as a slicing criterion. The task
of computing program slices is ... / D. . Software engineering Programming environments D. . Software br are investigated. We discuss how compiler-optimization techniques can be
134 Efficient Context-Sensitive Pointer Analysis for C Programs - Wilson, Lam (1995)(Correct)
This paper proposes an efficient technique for contextsensitive
pointer analysis that is applicable to real C programs.
For efficiency, we summarize the effects of procedures
using partial transfer fu... / The Acm Sigplan' Conference On Programminglanguage Design And br our algorithm in the SUIF compiler system and we show that it runs
133 Nesl: A Nested Data-Parallel Language - Blelloch (1990)(Correct)
This report describes Nesl, a strongly-typed, applicative, data-parallel language. Nesl is
intended to be used as a portable interface for programming a variety of parallel and vector
supercomputers, ... / used as a portable interface for programming a variety of parallel and br Sabot implemented an experimental compiler that supported nested-parallelism
131 Shoring Up Persistent Applications - Carey, DeWitt, Franklin, Hall.. (1994)(Correct)
SHORE (Scalable Heterogeneous Object REpository) is a persistent object system under development at the University of Wisconsin. SHORE represents a merger of objectoriented database and file system te... / most current OODBs application programmers face an either or br Restricting type support to the compiler locks users into single-language
126 Value Locality and Load Value Prediction - Lipasti, al. (1996)(Correct)
Since the introduction of virtual memory demand-paging
and cache memories, computer systems have been exploiting
spatial and temporal locality to reduce the average latency of a
memory reference. In t... / on Architectural Support for Programming Languages and Operating br by modern state-of-the-art compilers exhibits these tendencies. We
123 The Nexus Approach to Integrating Multithreading and Communication - Foster (1996)(Correct)
Lightweight threads have an important role to play in parallel systems: they can be used to exploit shared-memory parallelism, to mask communication and I/O latencies, to implement remote memory acces... / In these situations the programmer can reasonably be assumed to br called Nexus that is used as a compiler target for parallel languages and
118 Programming In Vienna Fortran - Chapman, Mehrotra, Zima (1992)(Correct)
Exploiting the full performance potential of distributed memory machines requires
a careful distribution of data across the processors. Vienna Fortran is a language
extension of Fortran which provides... / For Publication In Scientific Programming Vol. Programming In br not only for Fortran and current compiler research is aimed at
118 Standard ML of New Jersey - Appel, MacQueen (1991)(Correct)
The Standard ML of New Jersey compiler has been under development for five years now. We have developed a robust and complete environment for Standard ML that supports the implementation of large soft... / Lang. Implementation and Logic Programming Springer-Verlag LNCS pp. br The Standard ML of New Jersey compiler has been under development for
116 TIL: A Type-Directed Optimizing Compiler for ML - Tarditi, Morrisett, Cheng (1995)(Correct)
We describe a new compiler for Standard ML called TIL, that is based on four technologies: intensional
polymorphism, tag-free garbage collection, conventional functional language optimization,
and loo... / The Acm Sigplan ' Conference On Programming Language Design And br TIL A Type-Directed Optimizing Compiler for ML David Tarditi Greg
114 Pict: A Programming Language Based on the Pi-Calculus - Pierce, Turner (1997)(Correct)
The π-calculus offers an attractive basis for concurrent programming. It is small, elegant, and well studied, and supports (via simple encodings) a wide range of high-level constructs including dat... / Pict A Programming Language Based on the br applications a calculus compiler must implement process creation
114 Fine-grain Parallelism with Minimal Hardware Support: A.. - Culler, Sah, Schauser, von Eicken.. (1991)(Correct)
In this paper, we present a relatively primitive execution model for fine-grain parallelism, in which all synchronization, scheduling, and storage management is explicit and under compiler control. Th... / support certain modern parallel programming languages such as Id br with Minimal Hardware Support A Compiler-Controlled Threaded Abstract
112 A Short Cut to Deforestation - Gill, Launchbury, Jones (1993)(Correct)
Lists are often used as "glue" to connect separate parts of a program together. We propose an automatic technique for improving the efficiency of such programs, by removing many of these intermediate ... / This compositional style of programming is one reason why lists tend br the method in the Glasgow Haskell compiler. Introduction Functional
109 Implementing lazy functional languages on stock hardware: the.. - Jones (1992)(Correct)
The Spineless Tagless G-machine is an abstract machine designed to support nonstrict higher-order functional languages. This presentation of the machine falls into three parts. Firstly, we give a gene... / in the Journal of Functional Programming. Changes in Version . br is the C language treating the C compiler as a portable assembler. This
109 Shared Memory Consistency Models: A Tutorial - Adve, Gharachorloo (1995)(Correct)
Parallel systems that support the shared memory abstraction are becoming
widely accepted in many areas of computing. Writing correct and efficient
programs for such systems requires a formal specifica... / by uniprocessor hardware and compiler designers thereby reducing the br also briefly discuss an alternate programmer-centric view that describes the
108 Compiling Polymorphism Using Intensional Type Analysis - Harper, Morrisett (1995)(Correct)
Types have been used to describe the size and shape of data structures at compile time. In polymorphic languages or languages with abstract types, this is not possible since the types of some objects ... / of the structure. This allows the programmer to gain considerable control br is assured. This means that a compiler may always open code
103 Object-Oriented Type Inference - Palsberg, Schwartzbach (1991)(Correct)
We present a new approach to inferring types in untyped
object-oriented programs with inheritance,
assignments, and late binding. It guarantees that
all messages are understood, annotates the program
... / Conference on Object-Oriented Programming Systems Languages and br as the basis of an optimizing compiler. Types are finite sets of classes
101 Fine-grain Access Control for Distributed Shared Memory - Schoinas (1994)(Correct)
This paper discusses implementations of fine-grain memory
access control, which selectively restricts reads and
writes to cache-block-sized memory regions. Fine-grain
access control forms the basis of... / at every bus request. FLASH's programmable processor in the memory br two instructions. Either a compiler or a program executable editing
99 On The Acceptability Of Arguments And Its Fundamental Role In.. - Dung (1995)(Correct)
The purpose of this paper is to study the fundamental mechanism, humans use in argumentation, and to explore ways to implement this mechanism on computers. We do so by first developing a theory for ar... / In Nonmonotonic Reasoning Logic Programming And N-Persons Games Phan br a method very much similar to the compiler-compiler idea in conventional
95 The Glasgow Haskell compiler: a technical overview - Jones, Hall, Hammond, Partain, Wadler (1992)(Correct)
We give an overview of the Glasgow Haskell compiler, focusing especially on way in which we have been able to exploit the rich theory of functional languages to give very practical improvements in the... / Computer Science. Functional programming is a research area that offers br The Glasgow Haskell compiler a technical overview Simon L
94 Compiler Optimizations for Improving Data Locality - Carr, McKinley, Tseng (1994)(Correct)
In the past decade, processor speed has become significantly faster than memory speed. Small, fast cache memories are designed to overcome this discrepancy, but they are only effective when programs e... / Caches also have an impact on programming programmers substantially br Compiler Optimizations for Improving Data
91 Optimizing ML with Run-Time Code Generation - Leone, Lee (1995)(Correct)
We describe the design and implementation of a compiler that automatically translates ordinary
programs written in a subset of ML into code that generates native code at run time. Run-time
code genera... / performance. So in practice programmers often write unwieldy but br the design and implementation of a compiler that automatically translates
91 A Denotational Semantics of Inheritance and its Correctness - Cook, Palsberg (1994)(Correct)
This paper presents a denotational model of inheritance. The model is based on an intuitive motivation of inheritance as a mechanism for deriving modified versions of recursive definitions. The correc... / ACM Conference on Object-Oriented Programming Systems Languages and br as a basis for semantics-directed compiler generation for object-oriented
90 Tabled Evaluation with Delaying for General Logic Programs - Chen, Warren (1996)(Correct)
SLD resolution with negation as finite failure (SLDNF) reflects the procedural interpretation of predicate calculus as a programming language and forms the computational basis for Prolog systems. Desp... / of predicate calculus as a programming language and forms the br of queries. Furthermore Prolog compiler technology has been adapted for
87 Implementation of a Portable Nested Data-Parallel Language - Blelloch (1994)(Correct)
This paper gives an overview of the implementation
of Nesl, a portable nested data-parallel language. This
language and its implementation are the first to fully
support nested data structures as well... / languages a simple programming model and portability. The br nested parallelism allows a compiler to convert them into a form that
82 Simple Type-Theoretic Foundations For Object-Oriented Programming - Pierce, Turner (1993)(Correct)
We develop a formal, type-theoretic account of the basic mechanisms of object-oriented
programming: encapsulation, message passing, subtyping, and inheritance. By modeling
object encapsulation in term... / J. Functional Programming - January c br were typeset using a prototype compiler for F that typechecks
80 Improving Data Locality with Loop Transformations - McKinley (1996)(Correct)
this article, we present compiler optimizations to improve data locality based on a simple yet accurate cost model. The model computes both temporal and spatial unknown Improving Data Locality with Lo... / and Subject Descriptors D. . Programming Languages br In this article we present compiler optimizations to improve data
79 Automatically Tuned Linear Algebra Software - Whaley, Dongarra (1997)(Correct)
This paper describes an approach for the automatic generation and optimization of numerical
software for processors with deep memory hierarchies and pipelined functional units.
The production of such ... / has required tedious hand coded programming efforts. Since their br . . Why Can't the Compiler Do This
77 Reducing Indirect Function Call Overhead In C++ Programs - Calder, Grumwald (1994)(Correct)
Modern computer architectures increasingly depend on mechanisms that estimate future control flow decisions to increase performance. Mechanisms such as speculative execution and prefetching are becomi... / At the same time computer programmers are increasingly turning to br techniques and demonstratehow compilers can use existing branch
76 Integrating Message-Passing and Shared-Memory: Early Experience - Kranz, Johnson, Agarwal.. (1993)(Correct)
This paper discusses some of the issues involved in implementing a shared-address space programming model on large-scale, distributed-memory multiprocessors. While such a programming model can be impl... / a shared-address space programming model on large-scale br a simple interface we expect the compiler and runtime system to cooperate
75 Data and Computation Transformations for Multiprocessors - Anderson (1995)(Correct)
Effective memory hierarchy utilization is critical to the performance of modern multiprocessor architectures. We havedeveloped the first compiler system that fully automatically parallelizes sequentia... / and Practice of Parallel Programming PPoPP ' Santa Barbara CA br We havedeveloped the first compiler system that fully automatically
74 Programming Parallel Algorithms - Blelloch (1996)(Correct)
In the past 20 years there have been a huge number of algorithms designed for parallel computers, most which have been designed for one of the variants of the Parallel Random Access Machine (PRAM) mod... / Programming Parallel Algorithms Guy br the environment including the compiler on a local workstation while
72 Branch Prediction For Free - Ball (1993)(Correct)
ing with credit is permitted. To copy otherwise, to republish, to post on servers, or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from Publications D... / the ACMSIGPLAN ' Conference on Programming Language Design and br -Madison ABSTRACT Many compilers rely on branch prediction to
71 Unifying Data and Control Transformations for Distributed Shared.. - Cierniak (1994)(Correct)
We present a unified approach to locality optimization that employs both data and control transformations. Data transformations include changing the array layout in memory. Control transformations inv... / programs using a shared-memory programming model. As a result many br have developed new techniques for compiler optimizations for distributed
71 Unifying Data and Control Transformations for Distributed.. - Cierniak, Li (1994)(Correct)
We present a unified approach to locality optimization that employs both data and control transformations. Data transformations include changing the array layout in memory. Control transformations inv... / of the SIGPLAN ' Conference on Programming Language Design and br have developed new techniques for compiler optimizations for distributed
69 Linearity and the Pi-Calculus - Kobayashi (1996)(Correct)
A static type system with "use-once" channel types, inspired by linear logic, is applied to a pure calculus of processes and message passing. Applications of this type system include static detection ... / that a wide range of concurrent programming idioms can be modeled by simple br of errors in concurrent programs compiler optimizations and more natural
69 The Design and Implementation of a Certifying Compiler - Necula, Lee (1998)(Correct)
This paper presents the design and implementation of a
compiler that translates programs written in a type-safe
subset of the C programming language into highly optimized
DEC Alpha assembly language p... / to the traditional compiler design and hence it should be br in a type-safe subset of the C programming language into highly optimized
69 VIS: A System for Verification and Synthesis - Brayton, Sangiovanni-Vincentelli.. (1996)(Correct)
ion Manual abstraction can be performed by giving a file containing the names of variables to abstract. For each
variable appearing in the file, a new primary input node is created to drive all the no... / tools by . providing a better programming environment . providing new br VIS includes a stand-alone compiler from Verilog to BLIF-MV called
69 Lazy Functional State Threads - Launchbury, Jones (1993)(Correct)
Some algorithms make critical internal use of updatable
state, even though their external specification is purely
functional. Based on earlier work on monads, we present
a way of securely encapsulatin... / This paper has been submitted to Programming Languages Design and br in the Glasgow Haskell compiler and freely available. The system
68 Automatic Program Parallelization - Banerjee, Eigenmann, Nicolau (1993)(Correct)
This paper presents an overview of automatic program
parallelization techniques. It covers dependence analysis
techniques, followed by a discussion of program transformations,
including straight-line ... / machine organization and good programming methodology. Developing br effectiveness of parallelizing compilers. Introduction The last
68 Reducing Memory Latency via Non-blocking and Prefetching Caches - Chen (1992)(Correct)
Non-blocking caches and prefetching caches are two techniques for hiding memory latency by exploiting the overlap of processor computations with data accesses. A non-blocking cache allows execution to... / allocation. ACM Transactions on Programming Languages and Systems br these approaches. We also consider compiler-based optimizations to enhance
68 Software Versus Hardware Shared-Memory Implementation: A Case Study - Cox (1994)(Correct)
We compare the performance of software-supported shared memory on a general-purpose network to hardware-supported shared memory on a dedicated interconnect. Up to eight processors, our results are bas... / Caches Compilers And Parallel Programming Interfaces the Anl Parmacs br processor primary cache and compiler the shared-memory implementation
67 Compile-Time Techniques for Data Distribution in Distributed Memory.. - Ramanujam, Sadayappan (1991)(Correct)
This paper addresses the problem of partitioning data for distributed memory machines (multicomputers). In current day multicomputers, interprocessor communication is more time-consuming than instruct... / communication. As a result the programmer faces the enormously difficult br It is therefore worthwhile for a compiler to analyze patterns of data usage
67 Reducing False Sharing on Shared Memory Multiprocessors through.. - Jeremiassen (1994)(Correct)
We have developed compiler algorithms that analyze explicitly
parallel programs and restructure their shared data to
reduce the number of false sharing misses. The algorithms
analyze per-process share... / transformations always outperform programmer efforts to eliminate false br Abstract We have developed compiler algorithms that analyze
66 Typed Closure Conversion - Minamide, Morrisett, Harper (1996)(Correct)
We study the typing properties of closure conversion for simply-typed and polymorphic -calculi. Unlike most accounts of closure conversion, which only treat the untyped -calculus, we translate well-ty... / The usual operational models of programming languages based on the br target programs. This allows later compiler phases to take advantage of
66 An Overview of the Spring System - Mitchell, Gibbons, Hamilton.. (1994)(Correct)
Spring is a highly modular, distributed, object-oriented
operating system. This paper describes the goals of the
Spring system and provides overviews of the Spring object
model, the security model, an... / the system's existing Application Programming Interfaces APIs If you br components. As such IDL compilers are or have been implemented
65 Charlotte: Metacomputing on the Web - Baratloo (1996)(Correct)
The World Wide Web has the potential of being used as
an inexpensive and convenient metacomputing resource.
This brings forward new challenges and invalidates many
of the assumptions made in offering ... / runtime system transparent to the programmer. Charlotte provides br relying on operating system or compiler support. It is implemented soley
65 Baring it all to software: Raw machines - Waingold, al. (1997)(Correct)
this article. This project is funded by US Defense Advanced Research Projects Agency contract DABT63-96-C-0036 and a National Science Foundation Presidential Young Investigator Award. Ikos Systems don... / configurable logic and a programmable switch that supports both br low-level details to the compiler. This allows the compiler-or
65 A Practical System for Intermodule Code Optimization at Link-Time - Srivastava, Wall (1992)(Correct)
We have developed a system called OM to explore the problem of code optimization at link-time. OM takes a collection of object modules constituting the entire program, and converts the object code int... / in the March issue of Journal of Programming Languages. It replaces br to perform optimizations that a compiler looking at a single module cannot
64 Compiler Support for Machine-Independent Parallel Programming in.. - Hiranandani, Kennedy, Tseng (1991)(Correct)
Because of the complexity and variety of parallel architectures, an efficient machine-independent parallel programming model is needed to make parallel computing truly usable for scientific programmer... / the development of arf a compiler designed to interface Fortran br Machine-Independent Parallel Programming in Fortran D Seema
63 Garbage Collection Can Be Faster Than Stack Allocation - Appel (1987)(Correct)
A very old and simple algorithm for garbage collection gives very good results when the physical memory is much larger than the number of reachable cells. In fact, the overhead associated with allocat... / . Introduction Many modern programming environments use heap storage br algorithms and fancy compiler analysis become unnecessary.
63 Compiler Blockability of Numerical Algorithms - Carr (1992)(Correct)
Over the past decade, microprocessor design strategies have focused on increasing the computational power on a single chip. Unfortunately, memory speeds have not kept pace. The result is an imbalance ... / memory hierarchies. In turn programmers are explicitly restructuring br Compiler Blockability of Numerical
61 Making Pure Object-Oriented Languages Practical - Chambers, Ungar (1991)(Correct)
In the past, object-oriented language designers and programmers have been forced to choose between pure message passing and performance. Last year, our SELF system achieved close to half the speed of ... / language designers and programmers have been forced to choose br about as fast as an optimizing C compiler and runs at over half the speed
61 PolyP - a polytypic programming language extension - Jansson, Jeuring (1997)(Correct)
Many functions have to be written over and over again
for different datatypes, either because datatypes change
during the development of programs, or because functions
with similar functionality are n... / PolyP -a polytypic programming language extension Patrik br are automatically generated by the compiler but the definitions of these
60 The CMU Task Parallel Program Suite - Peter Dinda, Thomas Gross, David.. (1994)(Correct)
The idea of exploiting both task and data parallelism in programs is appealing. However, identifying realistic,
yet manageable example programs that can benefit from such a mix of task and data parall... / Keywords Parallel programming task parallelism functional br parallelism parallelizing compilers program mapping .
60 Profile-Guided Automatic Inline Expansion for C Programs - Chang, Mahlke, Chen, Hwu (1992)(Correct)
This paper describes critical implementation issues that must be addressed to develop a fully automatic inliner. These issues are: integration into a compiler, program representation, hazard preventio... / the original task. Structured programming techniques therefore encourage br issues are integration into a compiler program representation hazard
60 A Sound Type System For Secure Flow Analysis - Volpano, Smith, al. (1996)(Correct)
Ensuring secure information flow within programs in the context of multiple sensitivity
levels has been widely studied. Especially noteworthy is Denning's work in
secure flow analysis and the lattice ... / with respect to a standard programming language semantics that all br be easily incorporated into a compiler to verify secure information flow
59 Unboxed values as first class citizens in a non-strict functional.. - Jones, Launchbury (1991)(Correct)
The code compiled from a non-strict functional program usually manipulates heapallocated boxed numbers. Compilers for such languages often go to considerable trouble to optimise operations on boxed nu... / the Conference on Functional Programming Languages and Computer br heapallocated boxed numbers. Compilers for such languages often go to
59 Task Parallelism in a High Performance Fortran Framework - Gross, Hallaron, Subhlok (1994)(Correct)
High Performance Fortran (HPF) has emerged as a standard dialect of Fortran for data parallel computing.
However, for a wide variety of applications, both task and data parallelism must be exploited t... / communication. However the design and compiler have proven adequate for br and parallel loops. These allow programmers to write and compile data
59 Automatic Array Privatization - Tu (1993)(Correct)
Array privatization is one of the most effective transformations for the exploitation of parallelism. In this paper, we present a technique for automatic array privatization. Our algorithm uses data... / has to employ parametric integer programming in its most general case our br tasks of today's parallelizing compilers. Memory-related dependence can
59 Abstractions for Recursive Pointer Data Structures: Improving the.. - Hendren, Hummel, Nicolau (1992)(Correct)
ions for Recursive Pointer Data Structures:
Improving the Analysis and Transformation of Imperative Programs
Copyright c fl1992 by the Association for Computing Machinery, Inc. Permission
to make digi... / The Acm Sigplan ' Conferenceon Programminglanguage Design And br both optimizing and parallelizing compilers for imperative programming
59 The Zinc Experiment: An Economical Implementation Of The Ml Language - Leroy (1990)(Correct)
This report details the design and implementation of the ZINC system. This is an implementation of the ML language, intended to serve as a test field for various extensions of the language, and for ne... / Techniques N o Programme Calcul symbolique br The compiler . Some intermediate
58 A Type System for Object Initialization In the Java Bytecode Language - Freund, Mitchell (1998)(Correct)
In the standard Java implementation, a Java language
program is compiled to Java bytecode. This bytecode
may be sent across the network to another site, where it
is then interpreted by the Java Virtua... / Introduction The Java programming language is a statically-typed br generated by a conventional compiler is accepted. The need for
58 XSB as an Efficient Deductive Database Engine - Sagonas (1994)(Correct)
In this paper we describe the XSB system, an in-memory deductive database engine. XSB began from a Prolog foundation, and traditional Prolog systems are known to have a number of serious deficiencies ... / forms the basic language of logic programming is an elegant language for br and can take advantage of valuable compiler technology developed for Prolog.
57 A Static Parameter based Performance Prediction Tool for Parallel.. - Fahringer, Zima (1993)(Correct)
This paper presents a Parameter based Performance Prediction
Tool (P
3
T ) which is part of the Vienna Fortran Compilation
System (VFCS), a compiler that automatically translates
Fortran programs in... / part of the research projects A Programming Environment for Massively br Compilation System VFCS a compiler that automatically translates
57 Register Allocation with Instruction Scheduling: a New Approach - Pinter (1993)(Correct)
We present a new framework in which considerations of both register allocation and instruction scheduling can be applied uniformly and simultaneously. In this framework an optimal coloring of a graph,... / on Architectural Support for Programming Languages and Operating br is an important task of every compiler. The problem of efficiently
57 No Assembly Required: Compiling Standard ML to C - Tarditi, Lee, Acharya (1990)(Correct)
C has been used as a portable target language for implementing languages
like Standard ML and Scheme. Previous efforts at compiling these
languages to C have produced efficient code, but also compromi... / and Subject Descriptors D. . Programming Languages br of two slower than a native code compiler. The generated code is highly
57 Iterative Type Analysis and Extended Message Splitting: Optimizing.. - Chambers, Ungar (1990)(Correct)
Object-oriented languages have suffered from poor performance caused by frequent and slow dynamically-bound procedure calls. The best way to speed up a procedure call is to compile it out, but dynam... / The Acm Sigplan ' Conference On Programming Language Design And br used by a running program. The compiler constructs a control flow graph
56 A Linear Algebra Framework for Static HPF Code Distribution - Corinne Ancourt (1995)(Correct)
High Performance Fortran (hpf) was developed
to support data parallel programming for simd
and mimd machines with distributed memory. The
programmer is provided a familiar uniform logic address
space... / to support data parallel programming for simd and mimd br distribution by directives. The compiler then exploits these directives
56 From Region Inference to von Neumann Machines via Region.. - Birkedal, Tofte, Vejlstrup (1996)(Correct)
Region Inference is a technique for implementing programming
languages that are based on typed call-by-value lambda
calculus, such as Standard ML. The mathematical runtime
model of region inference us... / is a technique for implementing programming languages that are based on br of a new region-based ML compiler is compared to the performance
55 Automatic Data Layout for High Performance Fortran - Kennedy, Kremer (1994)(Correct)
High Performance Fortran (HPF) is rapidly gaining acceptance as a language for parallel
programming. The goal of HPF is to provide a simple yet efficient machine independent
parallel programming model... / as a language for parallel programming. The goal of HPF is to provide br layout. It is the task of the HPF compiler to generate efficient code for
55 Adaptive Cache Coherency for Detecting Migratory Shared Data - Cox, Fowler (1993)(Correct)
Parallel programs exhibit a small number of distinct datasharing
patterns. A common data-sharing pattern, migratory
access, is characterized by exclusive read and write access
by one processor at a t... / processors. Several common programming techniques give rise to the br model seen by the programmer and compiler nor do they add any special
55 Compiler-Based Prefetching for Recursive Data Structures - Luk (1996)(Correct)
Software-controlled data prefetching offers the potential for bridging the ever-increasing speed gap between the memory subsystem and today's high-performance processors. While prefetching has enjoyed... / schemes rely on either the programmer or the compiler to insert br Compiler-Based Prefetching for Recursive
54 Automatic Autoprojection of Recursive Equations with Global Variables .. - Bondorf, Danvy (1990)(Correct)
Self-applicable partial evaluation has been implemented for half a decade now, but many problems remain open. This paper addresses and solves the problems of automating call unfolding, having an open-... / fit well in an applicative order programming environment. We present a new br a number of experiments such as compiler generation from interpretive
54 Generating Communication for Array Statements: Design.. - Stichnoth (1994)(Correct)
Array statements as included in Fortran 90 or High Performance Fortran (HPF) are a wellaccepted way to specify data parallelism in programs. When generating code for such a data parallel program for a... / Introduction One approach to programming parallel systems that has br memory parallel system the compiler must determine when array
54 The Implementation Of Postgres - Stonebraker (1990)(Correct)
Currently, POSTGRES is about 90,000 lines of code in C and is being used by assorted "bold and brave" early users. The system has been constructed by a team of 5 part time students led by a full time ... / students led by a full time chief programmer over the last three years. br tightly coupled POSTGRES to the compiler and run-time environment of that
54 Compiling Collection-Oriented Languages onto Massively Parallel.. - Blelloch (1990)(Correct)
This paper introduces techniques for compiling the nested parallelism of collectionoriented
languages onto existing parallel hardware. Programmers of parallel machines
encounter nested parallelism ... / onto existing parallel hardware. Programmers of parallel machines br flat single-level parallelism. A compiler is presented that translates a
54 Scripting: Higher Level Programming for the 21st Century - Ousterhout (1997)(Correct)
Scripting languages such as Perl and Tcl represent a very different style of programming than system programming languages such as C or Java TM . Scripting languages are designed for "gluing" applicat... / Scripting Higher Level Programming for the st Century
54 Efficient Compilation of Lazy Evaluation - Johnsson (1984)(Correct)
This paper describes the principles underlying an efficient implementation of a
lazy functional language, compiling to code for ordinary computers. It is based
on combinator-like graph reduction: the ... / C Background Functional programming is emerging as an alternative br One might say that the compiler constructs a specialised
53 Tiling Multidimensional Iteration Spaces for Multicomputers - Ramanujam, Sadayappan (1992)(Correct)
This paper addresses the problem of compiling perfectly nested loops for multicomputers (distributed memory machines). The relatively high communication startup costs in these machines renders frequen... / suffer from a lack of adequate programming support tools. Parallelizing br support tools. Parallelizing compilers for such machines have received
53 Where is Time Spent in Message-Passing and Shared-Memory Programs? - Chandra, Larus, Rogers (1994)(Correct)
Message passing and shared memory are two techniques parallel
programs use for coordination and communication. This
paper studies the strengths and weaknesses of these two mechanisms
by comparing equi... / in a machine. When this occurs programmers and compiler writers will need br When this occurs programmers and compiler writers will need to make
53 Determining Average Program Execution Times and their Variance - Sarkar (1989)(Correct)
This paper presents a general framework for determining average program execution times and their variance, based on the program's interval structure and control dependence graph. Average execution ti... / information as feedback to the programmer. An early study of execution br It is important for a compiler to obtain estimates of execution
52 Tag-free Garbage Collection Using Explicit Type Parameters - Tolmach(Correct)
We have constructed a practical tag-free garbage collector
based on explicit type parameterization of polymorphic
functions, for a dialect of ML. The collector relies
on type information derived from ... / ' Conference on Functional Programming Languages and Computer br of the program generated by the compiler as a byproduct of ordinary
50 Views: A way for pattern matching to cohabit with data abstraction - Wadler (1987)(Correct)
Pattern matching and data abstraction are important concepts in designing programs, but they do not fit well together. Pattern matching depends on making public a free data type representation, while ... / abstraction Philip Wadler Programming Research Group Oxford br left-hand side of an equation the compiler can check that no cases have
49 Once Upon a Type - Turner, Wadler, Mossin (1995)(Correct)
A number of useful optimisations are enabled if we can determine when a value is accessed at most once. We extend the Hindley-Milner type system with uses, yielding a type-inference based program anal... / Conference on Functional Programming and Computer Architecture San br hoc manner in the Glasgow Haskell Compiler and a solution to a problem
48 Collection-Oriented Languages - Sipelstein (1991)(Correct)
This research was supported in part by the Defense Advanced Research Projects Agency (DOD) and monitored
by the Avionics Laboratory, Air Force Wright Aeronautical Laboratories, Aeronautical Systems Di... / Abstract Several programming languages arising from widely br removes the need for sophisticated compiler analysis normally needed to
48 An International Survey of Industrial Applications of Formal Methods: .. - Craigen, Gerhart, Ralston (1993)(Correct)
Formal methods are mathematically-based techniques, often supported by
reasoning tools, that can offer a rigorous and effective way to model, design
and analyze computer systems. The purpose of this s... / system development. However most programming languages lack adequate br languages Static analysis and compiler-type tools that have gained
48 Neural Network Synthesis Using Cellular Encoding And The Genetic.. - Frédéric Gruau (1994)(Correct)
Artificial neural networks used to be considered only as a machine that learns using small
modifications of internal parameters. Now this is changing. Such learning method do not allow
to generate big... / . Genetic Programming br a number of properties and a compiler of high level language. The
46 Exploiting Task and Data Parallelism on a Multicomputer - Subhlok (1993)(Correct)
For many applications, achieving good performance on
a private memory parallel computer requires exploiting
data parallelism as well as task parallelism. Depending
on the size of the input data set an... / Principles Practice of Parallel Programming May San Diego CA br a parallel system. Most existing compilers focus on only one of data
46 Memory Consistency Models - Mosberger (1993)(Correct)
This paper discusses memory consistency models and their influence on software in the context of parallel machines. In the first part we review previous work on memory consistency models. The second p... / in hand with a change in the programming model. In general the br models have on language compiler and runtime system design. We
46 A Standard ML Compiler - Appel, MacQueen (1987)(Correct)
Standard ML is a major revision of earlier dialects of the functional language
ML. We describe the first compiler written for Standard ML in Standard ML.
The compiler incorporates a number of novel fe... / produce novel challenges in compiler design. They also it turns out can br for general purpose symbolic programming and it wasn't long before
46 Optimal Code Motion: Theory and Practice - Knoop, Rüthing, Steffen (1994)(Correct)
this paper, we emphasize the practicality of lazy code motion by giving explicit
directions for its implementation in standard compiler environments. In particular,
we present a version of the algorit... / Cocke J.and Schwartz J. T. Programming languages and their compilers. br format is standard in optimizing compilers. The theoretical foundations of
45 Detecting Coarse-Grain Parallelism Using an Interprocedural.. - Hall, Amarasinghe, Murphy, Liao, Lam (1995)(Correct)
This paper presents an extensive empirical evaluation of an interprocedural parallelizing compiler, developed as part of the Stanford SUIF compiler system. The system incorporates a comprehensive and ... / developed to simplify parallel programming. A parallelizing compiler that br an Interprocedural Parallelizing Compiler Mary W. Hall y Saman P.
45 Static Detection of Dynamic Memory Errors - Evans (1996)(Correct)
Many important classes of bugs result from invalid assumptions about the results of functions and the values of parameters and global variables. Using traditional methods, these bugs cannot be detecte... / to legacy code and support a programming methodology based on abstract br this would be unacceptable in a compiler optimizer or a theorem prover.
44 A High-Performance Microarchitecture with Hardware-Programmable.. - Razdan, Smith (1994)(Correct)
This paper explores a novel way to incorporate hardware-programmable
resources into a processor microarchitecture to improve the
performance of general-purpose applications. Through a coupling
of comp... / Microarchitecture with Hardware-Programmable Functional Units Rahul br Using this information the compiler interacts with sophisticated
44 Fragmented Objects for Distributed Abstractions - Makpangou (1992)(Correct)
ions
Mesaac Makpangou Yvon Gourhant
Jean-Pierre Le Narzul
Marc Shapiro
INRIA, B.P. 105, 78153 Rocquencourt C'edex, France
tel.: +33 (1) 39-63-52-93, fax: +33 (1) 39 63 53 30
e-mail: mak@sor.inria.f... / objects object oriented programming distributed abstractions br toolbox of predefined FOs. The FOG compiler ensures distributed typesafety
43 Adding Threads to Standard ML - Cooper, Morrisett (1990)(Correct)
We have added multiple threads of control to the Standard ML programming language. Standard
ML's support for first-class functions and automatic storage management influenced the design in
a number of... / of control to the Standard ML programming language. Standard ML's br ML programming language A compiler may of course introduce
43 Simple and Effective Link-Time Optimization of Modula-3 Programs - Fernandez (1994)(Correct)
this paper, we describe the opportunities for link-time optimization of Modula-3 and present two link-time optimization techniques. Data-driven simplification is a new technique. It uses a program's t... / R. Hanson. A Retargetable C Compiler Design and Implementation. br Symposium on Principles of Programming Languages pages -
43 A Practical Soft Type System for Scheme - Wright, Cartwright (1993)(Correct)
Soft type systems provide the benefits of static type checking for dynamically typed languages without rejecting untypable programs. A soft type checker infers types for variables and expressions and ... / for defined operations. Scheme programmers typically have strong br prior to execution and enables compilers to omit many run-time type
42 Distributed Filaments: Efficient Fine-Grain Parallelism on a Cluster.. - Freeh, Lowenthal, Andrews (1994)(Correct)
A fine-grain parallel program is one in which processes are typically small, ranging from
a few to a few hundred instructions. Fine-grain parallelism arises naturally in many
situations, such as itera... / parallelism and a shared-memory programming model on a range of br a target for code generation by compilers. However fine-grain parallelism
42 Dependence-Based Program Analysis - Johnson, Pingali (1993)(Correct)
Program analysis and optimization can be speeded up through the use of the dependence flow graph (DFG), a representation of program dependences which generalizes def-use chains and static single assig... / implicit and hidden in modern programming language control structures. br into a traditional optimizing compiler framework. We accomplish this as
42 Dynamic Memory Disambiguation Using the Memory Conflict Buffer - Gallagher (1994)(Correct)
To exploit instruction level parallelism, compilers for
VLIW and superscalar processors often employ static
code scheduling. However, the available code reordering
may be severely restricted due to am... / width instructions is a poor programming practice and decide their br instruction level parallelism compilers for VLIW and superscalar
42 Polytypic Programming - Jeuring, Jansson (1996)(Correct)
Many functions have to be written over and over again for different
datatypes, either because datatypes change during the development
of programs, or because functions with similar functionality are... / Polytypic Programming Johan Jeuring and Patrik br to obtain a compiler that compiles Polyp into Haskell
42 A Classification and Comparison Framework for Software Architecture.. - Medvidovic (1996)(Correct)
Software architectures shift the focus of developers from lines-of-code to coarsergrained
architectural elements and their overall interconnection structure.
Architecture description languages (ADLs) ... / interconnection simulation and programming languages on the other. This br tools model checkers parsers compilers code synthesis tools runtime
42 Soft Typing - Cartwright, Fagan (1991)(Correct)
This paper presents a soft type systems that retains the expressiveness of dynamic typing, but offers the early error detection and improved optimization capabilities of static typing. The key idea un... / provide important feedback to the programmer by detecting a large class of br they extract information that a compiler can exploit to produce more
41 Metasystems: An Approach Combining Parallel Processing and.. - Grimshaw (1994)(Correct)
A metasystem is a single computing resource composed of a heterogeneous group of autonomous computers
linked together by a network. The interconnection network needed to construct large metasystems
wi... / a system is difficult. First the programmer must deal with all the br synchronization is managed by the compiler and run-time system. We have
41 A Semantics for Higher-order Functors - MacQueen, Tofte (1994)(Correct)
Standard ML has a module system that allows one to define parametric modules, called functors. Functors are "first-order," meaning that functors themselves cannot be passed as parameters or returned... / Jersey and have proved useful in programming practice. Introduction br in the Standard ML of New Jersey compiler The first step toward
40 A Language-Based Approach to Protocol Implementation - Abbott, Peterson (1993)(Correct)
Morpheus is a special-purpose programming language that facilitates the efficient implementation of communication protocols. Protocols are divided into three categories, called shapes, so that they ca... / Morpheus is a special-purpose programming language that facilitates the br languages because a Morpheus compiler has more domain knowledge
40 How to Declare an Imperative - Wadler (1995)(Correct)
How can we integrate interaction into a purely declarative language? This tutorial describes a solution to this problem based on a monad. The solution has been implemented in the functional language H... / and Subject Descriptors D. . Programming Languages Language br in the Glasgow Haskell compiler subsequently added to the
40 A transformation-based optimiser for Haskell - Jones, Santos (1998)(Correct)
Many compilers do some of their work by means of correctness-preserving, and hopefully performance-improving, program transformations. The Glasgow Haskell Compiler (GHC) takes this idea of "compilatio... / This leads to a more modular compiler design in contrast to compilers br appear in Science of Computer Programming . Introduction Using
40 Automatic Generation of Efficient Array Redistribution Routines for.. - Ramaswamy, Banerjee (1995)(Correct)
Appropriate data distribution has been found to be critical for obtaining good performance on Distributed Memory Multicomputers like the CM-5, Intel Paragon and IBM SP-1. It has also been found that s... / HPF effort aims at easing the programming process through the use of br Such directives can help compilers in guiding the partitioning of
40 Synchronization and Communication in the T3E Multiprocessor - Scott (1996)(Correct)
This paper describes the synchronization and communication primitives of the Cray T3E multiprocessor, a shared memory system scalable to 2048 processors. We discuss what we have learned from the T3D p... / using the sharedmemory programming model e.g.High Performance br significantly easier for the compiler. For either programming model
40 Code Compression - Ernst, Evans, Fraser, Lucco.. (1997)(Correct)
Current research in compiler optimization counts mainly
CPU time and perhaps the first cache level or two. This
view has been important but is becoming myopic, at least
from a system-wide viewpoint, a... / R. Hanson. A Retargetable C Compiler Design and Implementation. Addison br The Acm Sigplan' Conference On Programming Language Design And
39 Optimistic Active Messages: A Mechanism for Scheduling Communication.. - Wallach (1995)(Correct)
Low-overhead message passing is critical to the performance of many applications. Active Messages [27] reduce the software overhead for message handling: messages are run as handlers instead of as thr... / communication details from the programmer. ORPC is . to times faster br thread package and a stub compiler that hides communication details
39 Eliminating Array Bound Checking Through Dependent Types - Xi, Pfennig (1998)(Correct)
We present a type-based approach to eliminating array bound
checking and list tag checking by conservatively extending
Standard ML with a restricted form of dependent types.
This enables the programme... / dependent types. This enables the programmer to capture more invariants br languages such as C. Nonetheless compilers offer the option to omit array
38 Public International Benchmarks for Parallel Computers - Hockney, Berry (1994)(Correct)
this report: David Bailey (NASA Ames Research Center)
, Michael Berry (University of Tennessee), Jack Dongarra (University of Tennessee/Oak
Ridge National Laboratory), Vladimir Getov (University of So... / intended to fill this gap. Two programming models are used Fortran br to test the capabilities of HPF compilers Chapter- There is currently
38 An Integrated Runtime and Compile-time Approach for Parallelizing.. - Agrawal, Sussman, Saltz (1995)(Correct)
In compiling applications for distributed memory machines, runtime analysis is required when data
to be communicated cannot be determined at compile-time. One such class of applications requiring
runt... / compilers for HPF-like parallel programming languages in compiling codes br systems. We have also developed compiler analysis for determining data
38 A Compilation System that Integrates High Performance Fortran and.. - Foster (1994)(Correct)
this paper. unknown A Compilation System that Integrates
High Performance Fortran and Fortran M
Ian Foster,
Bhaven Avalani,
Alok Choudhary,
and Ming Xu
1 / opposing approaches to parallel programming many applications can in fact br to integrate existing HPF and FM compilers and present results from an
38 Improving the Performance of Runtime Parallelization - Leung, Zahorjan (1993)(Correct)
When the inter-iteration dependency pattern of the iterations of a loop cannot be determined statically, compile time parallelization of the loop is not possible. In these cases, runtime parallelizati... / and Practice of Parallel Programming.Improving the Performance br Introduction Parallelizing compilers offer the parallel machine
38 Preliminary Design of JML: A Behavioral Interface Specification.. - Leavens, Baker, Ruby (1999)(Correct)
JML is a behavioral interface specification language tailored to Java. It also allows
assertions to be intermixed with Java code, as an aid to verification and debugging.
JML is designed to be used by... / for clients written in a specific programming language BISLs are inherently br files To a Java compiler such annotations are comments
37 Approximation Techniques for Average Completion Time Scheduling - Chekuri, Motwani, Natarajan, Stein (1997)(Correct)
We consider the problem of nonpreemptive scheduling to minimize average (weighted) completion time, allowing for release dates, parallel machines, and precedence constraints. Recent work has led to co... / on solving a preemptive or linear programming relaxation and then using the br are of particular interest in compiler applications that partly
37 Productive Parallel Programming: The PCN Approach - Foster, Olson, Tuecke (1992)(Correct)
We describe the PCN programming system, focusing on those features designed to improve the productivity of scientists and engineers using parallel supercomputers. These features include a simple notat... / Productive Parallel Programming The PCN Approach Ian br not the result computed. The PCN compiler is optimized for efficient
36 Compiling Haskell by program transformation: a report from the.. - Jones (1996)(Correct)
Many compilers do some of their work by means of correctness-preserving, and hopefully performance-improving, program transformations. The Glasgow Haskell Compiler (GHC) takes this idea of "compilatio... / This leads to a more modular compiler design in contrast to compilers br of the European Symposium on Programming Linkoping April .
36 Fast Interprocedural Class Analysis - DeFouw, Grove, Chambers (1997)(Correct)
Previous algorithms for interprocedural control flow analysis of higher-order and/or object-oriented languages have been
described that perform propagation or constraint satisfaction and take O(N
3
... / ACM Transactions on Programming Languages and Systems br framework in the Vortex optimizing compiler and we measured the cost and
36 Typed Memory Management in a Calculus of Capabilities - Crary, Walker, Morrisett (1999)(Correct)
An increasing number of systems rely on programming language
technology to ensure safety and security of low-level
code. Unfortunately, these systems typically rely on a complex,
trusted garbage colle... / number of systems rely on programming language technology to ensure br type-safe code. We present a compiler intermediate language called the
36 The Rio File Cache: Surviving Operating System Crashes - Chen, Ng, Rajamani, Aycock (1996)(Correct)
One of the fundamental limits to high-performance, high-reliability file systems is memory's vulnerability to system crashes. Because memory is viewed as unsafe, systems periodically write data back... / bit flip with a specific error in programming and most hardware bit flips br is not an issue such as compiler-generated temporary files.
35 A Knowledge-Based Configurator that Supports Sales, Engineering, and.. - Jon Wright (1993)(Correct)
INTRODUCTION
PROSE (PRoduct OfferingS Expertise) is a knowledge based engineering and ordering
platform that supports sales and order processing at AT&T Network Systems (AT&T-NS).
The cornerstone of ... / has somewhat the feel of programming in a strongly typed programming br of datatypes are caught by the compiler. C-Classic's consistency
35 Object Distribution in Orca using Compile-Time and Run-Time Techniques - Bal, Kaashoek (1993)(Correct)
Orca is a language for parallel programming on distributed
systems. Communication in Orca is based
on shared data-objects, which is a form of distributed
shared memory. The performance of Orca
program... / Orca is a language for parallel programming on distributed systems. br and run-time techniques. The Orca compiler has been extended to determine
35 Software Caching and Computation Migration in Olden - Carlisle, Rogers (1995)(Correct)
The goal of the Olden project is to build a system
that provides parallelism for general purpose C programs
with minimal programmer annotations. We focus
on programs using dynamic structures such as ... / D. Hanson. A Retargetable C Compiler Design and Implementation. br and Practice of Parallel Programming July pp. -
34 Lightweight Run-Time Code Generation - Leone, Lee (1994)(Correct)
Run-time code generation is an alternative and complement
to compile-time program analysis and optimization. Static
analyses are inherently imprecise because most interesting
aspects of run-time behav... / not required. Syntactic cues and programmer hints are used to determine br developed for a prototype compiler are discussed and the results
34 The Design and Implementation of Arjuna - Parrington, al. (1995)(Correct)
Record // Important utility class
RecoveryRecord // handles object recovery
LockRecord // handles object locking
RecordList // Intentions list
other management record types
To make use of atomic acti... / UK Arjuna is an object-oriented programming system implemented entirely in br normally used by the standard compiler. The system is portable modular
34 Heap Profiling of Lazy Functional Programs - Runciman, Wakeling (1993)(Correct)
We describe the design, implementation and use of a new kind of profiling tool that
yields valuable information about the memory use of lazy functional programs. The
tool has two parts: a modified fun... / almost every paper on functional programming began with the standard br of the tool is a modified compiler which attaches two tags to
34 Mixed Integer Programming Methods for Computing Nonmonotonic.. - Bell (1994)(Correct)
Though the declarative semantics of both explicit and nonmonotonic negation in logic
programs has been studied extensively, relatively little work has been done on computation
and implementation of th... / Mixed Integer Programming Methods for Computing br of experiments with a prototype compiler implemented by us tend to confirm
34 Automatic Data Layout for Distributed Memory Machines - Kremer (1993)(Correct)
An approach to programming distributed memory-parallel machines that has recently become popular is one where the programmer explicitly specifies the layout of data in a global name space, relying on ... / C is a research Pascal compiler designed and implemented at the br Abstract An approach to programming distributed memory-parallel
33 The Behavior Language; User's Guide - Brooks (1990)(Correct)
The Behavior Language is a rule-based real-time parallel robot programming language originally based on ideas from [Brooks 86], [Connell 89], and [Maes 89]. It compiles into a modified and extended ve... / real-time parallel robot programming language originally based on br Connell The subsumption compiler compiles augmented finite state
33 Message-Passing Performance of Various Computers - Dongarra, Dunigan (1995)(Correct)
This report compares the performance of different computer systems for basic message-passing. Latency and bandwidth are measured on Convex, Cray, IBM, Intel, KSR, Meiko, nCUBE, NEC, SGI, and TMC multi... / Message Passing . Programming Model Processes of a br of parallelism in the application compiler technology message-passing
33 PERTS: A Prototyping Environment for Real-Time Systems - Liu, Redondo, Deng, Tia, Bettati.. (1993)(Correct)
PERTS is a prototyping environment for real-time systems. It is being built incrementally and will contain schedulers and resource access protocols for time-critical applications, together with tools ... / and building blocks in the Cprogramming language. They can be br Instrumented Source Code Compiler Concrete Description
33 Demand-driven Computation of Interprocedural Data Flow - Duesterwald, Gupta, Soffa (1995)(Correct)
This paper presents a general framework for deriving demanddriven
algorithms for interprocedural data flow analysis of
imperative programs. The goal of demand-driven analysis
is to reduce the time and... / in Symposium on Principles of Programming Languages POPL' January br Optimizing and parallelizing compilers that exhaustively analyze a
33 Flexible Representation Analysis - Shao (1997)(Correct)
Statically typed languages with Hindley-Milner polymorphism have long been compiled using inefficient and fully boxed data representations. Recently, several new compilation methods have been proposed... / Conference on Functional Programming ICFP' This research was br information passed at runtime a compiler can freely explore any point in
33 Data Transformations for Eliminating Conflict Misses - Rivera, Tseng (1998)(Correct)
Many cache misses in scientific programs are due to conflicts
caused by limited set associativity. We examine two
compile-time data-layout transformations for eliminating conflict
misses, concentratin... / Acm Sigplan Conference On Programming Language Design And br loop nests We believe compiler transformations can be very
32 Representing Control: A Study of the CPS Transformation - Danvy, Filinski (1992)(Correct)
continuations:
A mathematical semantics for handling full functional jumps. In Proceedings of the
1988 ACM Conference on Lisp and Functional Programming, pages 52--62, Snowbird, Utah,
July 1988.
[19] ... / Mathematical Foundations of Programming Semantics volume of br suggests that a Clinger-style compiler for n terms would be proven
32 Dynamic Typing in Polymorphic Languages - Abadi, Cardelli, Pierce, Rémy (1992)(Correct)
Types The interaction between the use of Dynamic and abstract data types gives rise to a puzzling design issue: should the type tag of a dynamically typed value containing an element of an abstract ty... / Hence there are situations in programming where one would like to use br to implement in a bootstrapped compiler where the run-time and
32 Reducing Branch Costs via Branch Alignment - Calder, Grunwald (1994)(Correct)
Several researchers have proposed algorithms for basic block reordering. We call these branch alignment algorithms. The primary emphasis of these algorithms has been on improving instruction cache loc... / on Architectural Support for Programming Languages and Operating Systems br are compiled by any existing compiler and then transformed via binary
32 Techniques for Debugging Parallel Programs with Flowback Analysis - Choi, Miller, Netzer (1991)(Correct)
Flowback analysis is a powerful technique for debugging programs. It allows the programmer to
examine dynamic dependences in a program's execution history without having to re-execute the program.
The... / debugging programs. It allows the programmer to examine dynamic dependences br we use the coarse traces and other compiler-generated information to
32 An Extensible Protocol Architecture for Application-Specific.. - Fiuczynski (1996)(Correct)
Plexus is a networking architecture that allows applications
to achieve high performance with customized
protocols. Application-specific protocols are written in
a typesafe language and installed dyna... / kernel is written in a typesafe programming language which guarantees that br have been signed by our Modula- compiler. The linker resolves any
32 GUM: a portable parallel implementation of Haskell - Hammond, Mattson, Jr., Partridge.. (1995)(Correct)
GUM is a portable, parallel implementation of the Haskell functional language which has been publicly released with version 0.26 of the Glasgow Haskell Compiler (GHC). GUM is message-based, and portab... / of the purely-functional programming language Haskell. So far as we br . of the Glasgow Haskell Compiler GHC GUM is message-based and
32 GUM: a portable parallel implementation of Haskell (Abstract) - Trinder, Hammond, Jr., Partridge.. (1996)(Correct)
Department of Computing Science, Glasgow University
Email: ftrinder,kh,simonpjg@dcs.glasgow.ac.uk
PW Trinder K Hammond JS Mattson Jr
AS Partridge
y
SL Peyton Jones
z
Abstract
GUM is a portable, ... / interest in parallel functional programming GUM is one of the first such br relative to the best sequential compiler technology. To improve the