Results 1  10
of
11
Adaptive Functional Programming
 IN PROCEEDINGS OF THE 29TH ANNUAL ACM SYMPOSIUM ON PRINCIPLES OF PROGRAMMING LANGUAGES
, 2001
"... An adaptive computation maintains the relationship between its input and output as the input changes. Although various techniques for adaptive computing have been proposed, they remain limited in their scope of applicability. We propose a general mechanism for adaptive computing that enables one to ..."
Abstract

Cited by 80 (27 self)
 Add to MetaCart
An adaptive computation maintains the relationship between its input and output as the input changes. Although various techniques for adaptive computing have been proposed, they remain limited in their scope of applicability. We propose a general mechanism for adaptive computing that enables one to make any purelyfunctional program adaptive. We show
Tupling Calculation Eliminates Multiple Data Traversals
 In ACM SIGPLAN International Conference on Functional Programming
, 1997
"... Tupling is a wellknown transformation tactic to obtain new efficient recursive functions by grouping some recursive functions into a tuple. It may be applied to eliminate multiple traversals over the common data structure. The major difficulty in tupling transformation is to find what functions are ..."
Abstract

Cited by 39 (20 self)
 Add to MetaCart
(Show Context)
Tupling is a wellknown transformation tactic to obtain new efficient recursive functions by grouping some recursive functions into a tuple. It may be applied to eliminate multiple traversals over the common data structure. The major difficulty in tupling transformation is to find what functions are to be tupled and how to transform the tupled function into an efficient one. Previous approaches to tupling transformation are essentially based on fold/unfold transformation. Though general, they suffer from the high cost of keeping track of function calls to avoid infinite unfolding, which prevents them from being used in a compiler. To remedy this situation, we propose a new method to expose recursive structures in recursive definitions and show how this structural information can be explored for calculating out efficient programs by means of tupling. Our new tupling calculation algorithm can eliminate most of multiple data traversals and is easy to be implemented. 1 Introduction Tupli...
Abstracting Dependencies between Software Configuration Items
 ACM Transactions on Software Engineering and Methodology
, 1996
"... ing Dependencies between Software Configuration Items Carl A. Gunter University of Pennsylvania http://www.cis.upenn.edu/~gunter Abstract This paper studies an abstract model of dependencies between software configuration items based on a theory of concurrent computation over a class of Petr ..."
Abstract

Cited by 15 (0 self)
 Add to MetaCart
(Show Context)
ing Dependencies between Software Configuration Items Carl A. Gunter University of Pennsylvania http://www.cis.upenn.edu/~gunter Abstract This paper studies an abstract model of dependencies between software configuration items based on a theory of concurrent computation over a class of Petri nets called production nets. A general theory of build optimizations and their correctness is developed based on a form of abstract interpretation called a build abstraction; these are created during a build and used to optimise subsequent builds. Various examples of such optimizations are discussed. The theory is used to show how correctness properties can be characterized and proved, and how optimizations can be composed and compared. 1 Introduction Even a modest software project entails the creation of a collection of what are sometimes called software configuration items. Such items may be held in files, one item per file, or they may be more abstractly described and stored. A ...
Principled Strength Reduction
 Algorithmic Languages and Calculi
, 1996
"... This paper presents a principled approach for optimizing iterative (or recursive) programs. The approach formulates a loop body as a function f and a change operation \Phi, incrementalizes f with respect to \Phi, and adopts an incrementalized loop body to form a new loop that is more efficient. Thre ..."
Abstract

Cited by 11 (10 self)
 Add to MetaCart
(Show Context)
This paper presents a principled approach for optimizing iterative (or recursive) programs. The approach formulates a loop body as a function f and a change operation \Phi, incrementalizes f with respect to \Phi, and adopts an incrementalized loop body to form a new loop that is more efficient. Three general optimizations are performed as part of the adoption; they systematically handle initializations, termination conditions, and final return values on exits of loops. These optimizations are either omitted, or done in implicit, limited, or ad hoc ways in previous methods. The new approach generalizes classical loop optimization techniques, notably strength reduction, in optimizing compilers, and it unifies and systematizes various optimization strategies in transformational programming. Such principled strength reduction performs drastic program efficiency improvement via incrementalization and appreciably reduces code size via associated optimizations. We give examples where this app...
Computational Divided Differencing and DividedDifference Arithmetics
, 2000
"... Tools for computational differentiation transform a program that computes a numerical function F (x) into a related program that computes F 0 (x) (the derivative of F ). This paper describes how techniques similar to those used in computationaldifferentiation tools can be used to implement other pr ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
(Show Context)
Tools for computational differentiation transform a program that computes a numerical function F (x) into a related program that computes F 0 (x) (the derivative of F ). This paper describes how techniques similar to those used in computationaldifferentiation tools can be used to implement other program transformations  in particular, a variety of transformations for computational divided differencing . The specific technical contributions of the paper are as follows: It presents a program transformation that, given a numerical function F (x) de ned by a program, creates a program that computes F [x0 ; x1 ], the first divided difference of F(x), where F [x0 ; x1 ] def = F (x 0 ) F (x 1 ) x 0 x 1 if x0 6= x1 d dz F (z); evaluated at z = x0 if x0 = x1 It shows how computational first divided differencing generalizes computational differentiation. It presents a second program transformation that permits the creation of higherorder divided differences of a numerical function de ...
EarlyReply Components: Concurrent Execution with Sequential Reasoning
 Proc. Of the 7 th International Conference on Software Reuse, Vol 2319 of LNCS
, 2002
"... Generic software components have a reputation for being inefficient. Parallel implementations may improve performance, but can thwart reuse by being architecturedependent or by exposing concurrency to clientside reasoning about component interactions. To address performance, we present EarlyReply ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
Generic software components have a reputation for being inefficient. Parallel implementations may improve performance, but can thwart reuse by being architecturedependent or by exposing concurrency to clientside reasoning about component interactions. To address performance, we present EarlyReply as an alternative to blocking method invocations. Component operations can be partitioned into a material computation required to satisfy the postcondition, and a residual computation required to reestablish the component invariant, optimize its representation, etc. EarlyReply exploits opportunities for parallelism by forwarding final parameter values to the caller as soon as the material computation completes, thereby offloading the residual computation to execute in parallel with subsequent client activities. Proof obligations for EarlyReply support a synchronous calling model, so clients can still reason sequentially about component behavior. Also, since EarlyReply components do not depend on systemwide support for component synchronization, they can be deployed incrementally. Finally, EarlyReply can improve the response time of idle components by orders of magnitude; when composed hierarchically, performance benefits are magnified by the potential fanout of concurrently executing components.
A Systematic Incrementalization Technique and its Application to Hardware Design
"... Abstract. A transformation method based on incrementalization and value caching, generalizes a broad family of loop refinement techniques. This method and CACHET, an interactive tool supporting it, are presented. Though highly structured and automatable, better results are obtained with intelligent ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
Abstract. A transformation method based on incrementalization and value caching, generalizes a broad family of loop refinement techniques. This method and CACHET, an interactive tool supporting it, are presented. Though highly structured and automatable, better results are obtained with intelligent interaction, which provides insight and proofs involving term equality. Significant performance improvements are obtained in many representative program classes, including iterative schemes that characterize Today’s hardware specifications. Incrementalization is illustrated by the derivation of a hardwareefficient nonrestoring squareroot algorithm.
APPROVAL
"... Highquality mesh representations of 3D objects are useful in many applications ranging from computer graphics to mathematical simulation. We present a novel method to generate triangular meshes with a guaranteed face angle bound of [30 ◦,90 ◦]. Our strategy is to first remesh a 2manifold, open or ..."
Abstract
 Add to MetaCart
(Show Context)
Highquality mesh representations of 3D objects are useful in many applications ranging from computer graphics to mathematical simulation. We present a novel method to generate triangular meshes with a guaranteed face angle bound of [30 ◦,90 ◦]. Our strategy is to first remesh a 2manifold, open or closed, mesh into a rough approximate mesh that respects the proposed angle bounds. This is achieved by a novel extension to the Marching Cubes algorithm. Next, we perform an iterative constrained optimization, along with constrained Laplacian smoothing, to arrive at a close approximation of the input mesh. A constrained mesh decimation algorithm is then carried out to produce a hierarchy of coarse meshes where the angle bounds are maintained. We demonstrate the quality of our work through several examples. iii iv To my parents Acknowledgments I would like to express my gratitude to Dr. Richard Zhang who has been more than a supervisor throughout my studies. He has always provided me with guidance, motivation, and support. Having the chance to work with him was an honour. I would also like to take this opportunity to thank the fellow students at the GrUVi lab for lending their helping hands whenever I desperately needed help. I give special acknowledgement to my parents who were of great influence to me throughout my life. I thank them for their unconditional love and support. Last but not least, I owe special thanks to Jackie for her continuous support and encouragement. Without them, I would not have been able to acheive my goal. v
EarlyReply Components: Concurrent Execution with Sequential Reasoning
 Proc. Of the 7 th International Conference on Software Reuse, Vol 2319 of LNCS
, 2002
"... Generic software components have a reputation for being inecient. Parallel implementations may improve performance, but can thwart reuse by being architecturedependent or by exposing concurrency to clientside reasoning about component interactions. To address performance, we present EarlyRepl ..."
Abstract
 Add to MetaCart
Generic software components have a reputation for being inecient. Parallel implementations may improve performance, but can thwart reuse by being architecturedependent or by exposing concurrency to clientside reasoning about component interactions. To address performance, we present EarlyReply as an alternative to blocking method invocations. Component operations can be partitioned into a material computation required to satisfy the postcondition, and a residual computation required to reestablish the component invariant, optimize its representation, etc. EarlyReply exploits opportunities for parallelism by forwarding nal parameter values to the caller as soon as the material computation completes, thereby ooading the residual computation to execute in parallel with subsequent client activities. Proof obligations for EarlyReply support a synchronous calling model, so clients can still reason sequentially about component behavior. Also, since EarlyReply components do not depend on systemwide support for component synchronization, they can be deployed incrementally. Finally, EarlyReply can improve the response time of idle components by orders of magnitude; when composed hierarchically, performance bene ts are magni ed by the potential fanout of concurrently executing components.
and
"... We present techniques for incremental computing by introducing adaptive functional programming. As an adaptive program executes, the underlying system represents the data and control dependences in the execution in the form of a dynamic dependence graph. When the input to the program changes, a chan ..."
Abstract
 Add to MetaCart
We present techniques for incremental computing by introducing adaptive functional programming. As an adaptive program executes, the underlying system represents the data and control dependences in the execution in the form of a dynamic dependence graph. When the input to the program changes, a change propagation algorithm updates the output and the dynamic dependence graph by propagating changes through the graph and reexecuting code where necessary. Adaptive programs adapt their output to any change in the input, small or large. We show that adaptivity techniques are practical by giving an efficient implementation as a small ML library. The library consists of three operations for making a program adaptive, plus two operations for making changes to the input and adapting the output to these changes. We give a general bound on the time it takes to adapt the output, and based on this, show that an adaptive Quicksort adapts its output in logarithmic time when its input is extended by one key. To show the safety and correctness of the mechanism we give a formal definition of AFL, a callbyvalue functional language extended with adaptivity primitives. The modal type system of AFL enforces correct usage of the adaptivity mechanism, which can only be checked at run time in the ML library. Based on the AFL dynamic semantics, we formalize the changepropagation algorithm and prove its correctness.