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 purely-functional program adaptive. We show

Tupling is a well-known 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...

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

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

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 hardware-efficient nonrestoring squareroot algorithm.

Generic software components have a reputation for being inecient. Parallel implementations may improve performance, but can thwart reuse by being architecture-dependent or by exposing concurrency to client-side reasoning about component interactions. To address performance, we present Early-Reply 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. Early-Reply 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 Early-Reply support a synchronous calling model, so clients can still reason sequentially about component behavior. Also, since Early-Reply components do not depend on system-wide support for component synchronization, they can be deployed incrementally. Finally, Early-Reply can improve the response time of idle components by orders of magnitude; when composed hierarchically, performance bene ts are magni ed by the potential fan-out of concurrently executing components.