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.
1540.4 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
1148.9 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
920.6 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
668.0 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
572.8 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
531.9 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
530.4 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
485.1 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
469.5 Performance of Various Computers Using Standard Linear Equations.. - Jack 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
455.0 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
443.4 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
410.3 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
400.0 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
394.2 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
388.4 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
365.2 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
358.0 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
356.5 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
350.5 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
345.4 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
344.8 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
336.2 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
336.1 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
331.4 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
327.9 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
327.2 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
323.4 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
319.5 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
315.9 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
313.0 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
308.6 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
286.9 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
276.5 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
263.7 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
260.8 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
259.5 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
249.3 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
236.7 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
236.3 Nonlinear Array Layouts for Hierarchical Memory Systems - Chatterjee, Jain, Lebeck, Mundhra.. (1999)(Correct)
Programming languages that provide multidimensional arrays and
a flat linear model of memory must implement a mapping between
these two domains to order array elements in memory. This layout
function ... / Thottethodi z Abstract Programming languages that provide br in several high-performance compilers. Tiling techniques are also
232.0 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
231.8 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
230.9 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
229.7 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
228.5 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
224.6 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
222.8 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
217.3 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
214.8 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
214.4 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
214.3 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
208.3 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
203.5 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
203.4 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
200.0 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
200.0 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
191.3 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
190.1 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
188.5 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
188.4 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
187.9 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
181.8 What is a Recursive Module? - Crary, Harper, Puri (1999)(Correct)
A hierarchical module system is an effective tool for
structuring large programs. Strictly hierarchical module
systems impose an acyclic ordering on import dependencies
among program units. This can i... / units. This can impede modular programming by forcing mutually-dependent br formalism used in the SML NJ compiler and in the TIL ML
181.0 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
180.8 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
177.1 Using State Space Exploration and a Natural Deduction Style Message.. - Clarke, Jha, Marrero (1998)(Correct)
As more resources are added to computer networks, and as more vendors look to the World Wide Web as a viable marketplace, the importance of being able to restrict access and to insure some kind of acc... / thesis he proved that certain programming language control structures br as a state machine. While a new compiler now provides this feature for the
175.3 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
175.3 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
173.9 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
173.5 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
172.7 Certifying Compilation and Run-time Code Generation - Hornof, Jim (1999)(Correct)
A certifying compiler takes a source language program and
produces object code, as well as a "certificate" that can be
used to verify that the object code satisfies desirable properties,
such as type ... / recent work has applied advanced programming language techniques to the br Abstract A certifying compiler takes a source language program
170.2 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
169.0 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
167.9 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
167.6 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
165.4 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
163.7 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
163.6 Cache-Conscious Structure Definition - Chilimbi, Davidson, Larus (1999)(Correct)
A program's cache performance can be improved by changing the
organization and layout of its data---even complex, pointer-based
data structures. Previous techniques improved the cache performance
of t... / The Acm Sigplan' Conference On Programming Language Design And br or cold rarely accessed A compiler extracts cold fields from the
162.9 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
162.3 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
162.3 A Linear Algebra Framework for Static HPF Code Distribution - Ancourt, Coelho, Irigoin, Keryell (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 logical address spac... / to support data parallel programming for simd and mimd machines br Fourth International Workshop on Compilers for Parallel Computers held in
159.9 Applying Patterns to Develop Extensible ORB Middleware - Schmidt (1998)(Correct)
Distributed object computing forms the basis for nextgeneration application middleware. At the heart of distributed object computing are Object Request Brokers (ORBs), which automate many tedious and ... / and error-prone distributed programming tasks. Like many other br Repository Repository Idl Idl Compiler Compiler Dii Dii Orb Orb
159.4 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
159.2 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
157.4 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... / solving a preemptive or linear programming relaxation and then using the br are of particular interest in compiler applications that partly
156.7 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
154.2 Compiling Standard ML to Java Bytecodes - Benton, Kennedy, Russell (1998)(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... / SIGPLAN Conference on Functional Programming September Baltimore. br for ML. Notable features of the compiler itself include whole-program
154.2 Space-Time Scheduling of Instruction-Level Parallelism on a Raw.. - Lee, Barua, Srikrishna, Babb.. (1998)(Correct)
Advances in VLSI technology will enable chips with over a billion transistors within the next
decade. Unfortunately, the centralized-resource architectures of modern microprocessors are illsuited
to e... / connected via a mostly static programmable network. The fully exposed br and exposing them fully to the compiler. Compilation for
153.1 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
151.4 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
148.4 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
148.1 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 .
145.6 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
143.2 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.
142.2 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
142.0 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 typeinference based program analy... / Conference on Functional Programming and Computer Architecture br hoc manner in the Glasgow Haskell Compiler. Previous analyses to determine
140.4 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
140.2 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
135.8 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
133.3 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
131.9 An Industrial Strength Theorem Prover for a Logic Based on Common Lisp - Kaufmann, Moore (1997)(Correct)
ACL2 is a re-implemented extended version
of Boyer and Moore's Nqthm and Kaufmann's Pc-Nqthm,
intended for large scale verification projects. This paper
deals primarily with how we scaled up Nqthm's l... / to an industrial strength programming language -namely a large br directly to a Common Lisp compiler and then executed in an
131.9 Procedure Placement Using Temporal Ordering Information - Gloy, Blackwell, Smith, Calder (1997)(Correct)
Instruction cache performance is very important to
instruction fetch efficiency and overall processor performance.
The layout of an executable has a substantial effect
on the cache miss rate during ex... / Proc Acm Sigplan' Conf. On Programming Language Design And br direct-mapped caches where the compiler achieves an optimized cache line
130.8 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
130.4 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.
130.4 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.
124.6 Simple and Effective Link-Time Optimization of Modula-3 Programs - Fernandez (1995)(Correct)
Modula-3 supports development of modular programs by separating an object's interface from its implementation. This separation induces a runtime overhead in the implementation of objects, because it p... / R. Hanson. A Retargetable C Compiler Design and Implementation. Benjamin br Nackman et al. describe programming conventions for using abstract
121.7 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
121.7 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
121.6 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
119.9 Improving Data-flow Analysis with Path Profiles - Ammons (1998)(Correct)
Data-flow analysis computes its solutions over the paths in a control-flow graph. These paths---whether feasible or infeasible, heavily or rarely executed---contribute equally to a solution. However, ... / Acm Sigplan Conference On Programming Language Design And br along these paths can aid a compiler in optimizing these heavily
119.1 Auto-Blocking Matrix-Multiplication or Tracking BLAS3 Performance.. - Frens, Wise (1997)(Correct)
An elementary, machine-independent, recursive algorithm for matrix multiplication C+=A*B provides implicit blocking at every level of the memory hierarchy and tests out faster than classically optimal... / or pages and without ad hoc programming. It also exposed a weakness in br exposed a weakness in SGI's C compilers that merrily unroll loops for
118.5 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
117.5 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
117.5 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
117.2 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
115.9 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
115.9 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
115.9 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
113.5 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
113.4 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
113.0 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
112.0 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
110.6 UPPAAL in a Nutshell - Larsen, Pettersson, Yi (1997)(Correct)
This paper presents the overall structure, the
design criteria, and the main features of the tool box Uppaal.
It gives a detailed user guide which describes how
to use the various tools of Uppaal ve... / i.e. ta provides a basic programming language for timed automata. br than the graphical interface. The compiler atg ta automatically
110.1 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
108.6 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
108.6 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
108.5 Fast Module Mapping and Placement for Datapaths in FPGAs - Callahan, Chong, DeHon, Wawrzynek (1998)(Correct)
By tailoring a compiler tree-parsing tool for datapath module
mapping, we produce good quality results for datapath synthesis
in very fast run time. Rather than flattening the design
to gates, we pres... / HANSON D. A Retargetable C Compiler Design and Implementation. br with a linear-time dynamic programming algorithm. In a novel extension
104.3 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 .
104.3 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.
103.7 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
103.7 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
103.4 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
102.8 Building Program Optimizers with Rewriting Strategies - Visser, Benaissa, Tolmach (1998)(Correct)
We describe a language for defining term rewriting strategies, and its application to the production of program optimizers. Valid transformations on program terms can be described by a set of rewrite ... / Conference on Functional Programming ICFP' ACM Baltimore MD br Introduction Compiler components such as parsers
101.7 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
101.4 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 C programs with minimal programmer annotations. We focus on
101.2 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
101.2 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
99.9 Flexible Type Analysis - Crary, Weirich (1999)(Correct)
Run-time type dispatch enables a variety of advanced
optimization techniques for polymorphic languages, including
tag-free garbage collection, unboxed function
arguments, and flattened data structures... / of previous-stage types as a programming idiom. This language is quite br However modern type-preserving compilers transform types between stages
98.9 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
98.5 The Design and Implementation of Arjuna - Graham Parrington (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 actio... / UK Arjuna is an object-oriented programming system implemented entirely in br normally used by the standard compiler. The system is portable modular
98.5 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
97.1 Typed Cross-Module Compilation - Shao (1998)(Correct)
Higher-order modules are very effective in structuring large
programs and defining generic, reusable software components.
Unfortunately, many compilation techniques for the
core languages do not work ... / Introduction Modular programming has proven to be extremely br As a result few optimizing compilers support these module facilities
97.1 Variable Length Path Branch Prediction - Stark, al. (1998)(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... / . of the Python objectoriented programming language interpreter python br a mechanism for letting the compiler select the predictor to use for
95.6 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
95.6 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
94.8 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
94.8 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
94.1 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
93.8 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
93.8 A Compilation System That Integrates High Performance Fortran and.. - Foster, Avalani, Xu, Choudhary (1994)(Correct)
Task parallelism and data parallelism are often seen
as mutually exclusive approaches to parallel programming.
Yet there are important classes of application,
for example in multidisciplinary simulati... / exclusive approaches to parallel programming. Yet there are important br and data-parallel Fortran compilers to provide an environment in
93.6 HPJava: data parallel extensions to Java - Carpenter, Zhang, Fox, Li, Wen (1997)(Correct)
We outline an extension of Java for programming with distributed arrays. The basic programming style is Single Program Multiple Data (SPMD), but parallel arrays are provided as new language primitives... / outline an extension of Java for programming with distributed arrays. The br several years of effort by various compiler groups HPF compilers are still
92.7 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
92.7 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
92.7 GUM: a portable parallel implementation of Haskell - Trinder, Hammond, Mattson, Jr.. (1996)(Correct)
GUM is a portable, parallel implementation of the Haskell
functional language. Despite sustained research interest in
parallel functional programming, GUM is one of the first
such systems to be made p... / interest in parallel functional programming GUM is one of the first such br relative to the best sequential compiler technology. To improve the
92.7 Efficient Microarchitecture Modeling and Path Analysis for Real-Time.. - Li, Malik, Wolfe (1996)(Correct)
Real-time systems are characterized by the presence of timing constraints in which a task must be completed within a specific amount of time. This paper examines the problem of determining the bound o... / and uses an integer linear programming formulation to solve the br to capture all the effects of compiler optimizations and the
91.4 A Type-Theoretic Interpretation of Standard ML - Harper, Stone (1998)(Correct)
ion boundaries must be broken at run-time. Consequently, an association between
the abstract stamps and their underlying representations must be maintained.
In this paper we outline an interpretation ... / step in the development of programming languages. Milner's elegant br to implementation. The TIL ML compiler and recent versions of the
91.4 Wide-Area Implementation of the Message Passing Interface - Foster, Geisler, Gropp, Karonis.. (1998)(Correct)
The Message Passing Interface (MPI) can be used as a portable, high-performance programming
model for wide-area computing systems. The wide-area environment introduces challenging
problems for the MPI... / as a portable high-performance programming model for wide-area computing br for use by library writers and compiler writers in addition to MPI
91.3 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
89.8 Measuring the Performance of Communication Middleware on High-Speed.. - Aniruddha Gokhale (1996)(Correct)
Conventional implementations of communication middleware
(such as CORBA and traditional RPC toolkits) incur
considerable overhead when used for performance-sensitive
applications over high-speed netwo... / inefficient middleware will force programmers to use lower-level mechanisms br by the RPC and CORBA stub compilers excessive control information
89.8 Dynamic Self-Invalidation: Reducing Coherence Overhead in.. - Lebeck, Wood (1995)(Correct)
This paper introduces dynamic self-invalidation (DSI),
a new technique for reducing cache coherence overhead in
shared-memory multiprocessors. DSI eliminates invalidation
messages by having a processo... / multiprocessors simplify parallel programming by providing a single address br system directives inserted by the compiler profile-based tools or the
89.8 The Design of a Pretty-printing Library - Hughes (1995)(Correct)
Layouts We'll begin by looking for an abstract model of a pretty-printer's output --- that is, prettily indented text. We could say that the output is just a string, but a string has so little structu... / what does the power of functional programming depend Why are functional br at some point -whether it is a compiler displaying internal structures
89.7 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
88.6 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
86.9 An Integrated Compilation and Performance Analysis Environment for.. - Adve (1995)(Correct)
Supporting source-level performance analysis of programs written in data-parallel languages requires
a unique degree of integration between compilers and performance analysis tools. Compilers for lang... / performance feedback to programmers via a pair of graphical br degree of integration between compilers and performance analysis tools.
86.7 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
86.5 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
85.7 Model Checking Concurrent Systems with Unbounded Integer Variables.. - Tevfik Bultan (1998)(Correct)
Model checking is a powerful technique for analyzing large, finite-state systems. In an
infinite-state system, however, many basic properties are undecidable. In this paper, we present
a new symbolic ... / useful is more like that a programmer draws on when setting br Fellowship. Presburger Compiler DNF Partitioning Control-Point
85.7 Run-time Code Generation and Modal-ML - Wickline, Lee, Pfenning (1998)(Correct)
This paper presents a typed programming language and
compiler for run-time code generation. The language, called
ML
2
, extends ML with modal operators in the style of the
Mini-ML
2
e language of ... / This paper presents a typed programming language and compiler for br a typed programming language and compiler for run-time code generation. The
85.1 An Efficient Implementation of Reactivity for Modeling Hardware in.. - Liao, Tjiang, Gupta (1997)(Correct)
Reactivity is one of the key features of hardware
description languages. We present an efficient implementation
of reactivity in the Scenic framework that allows the system
designer to model hardware ... / models in a high-level programming language such as C or CThe br systems with a Ccompiler and a small library and without
84.0 The execution algorithm of Mercury, an efficient purely declarative.. - Zoltan Somogyi (1996)(Correct)
We introduce Mercury, a new purely declarative logic programming language designed to provide the support that
groups of application programmers need when building large programs. Mercury's strong typ... / purely declarative logic programming language Zoltan Somogyi br code. The prototype Mercury compiler uses this execution model to
83.9 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
83.9 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
82.4 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