Results 11  20
of
23
Using the Parametricity Theorem for Program Fusion
, 1996
"... Program fusion techniques have long been proposed as an effective means of improving program performance and of eliminating unnecessary intermediate data structures. This paper proposes a new approach on program fusion that is based entirely on the type signatures of programs. First, for each functi ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Program fusion techniques have long been proposed as an effective means of improving program performance and of eliminating unnecessary intermediate data structures. This paper proposes a new approach on program fusion that is based entirely on the type signatures of programs. First, for each function, a recursive skeleton is extracted that captures its pattern of recursion. Then, the parametricity theorem of this skeleton is derived, which provides a rule for fusing this function with any function. This method generalizes other approaches that use fixed parametricity theorems to fuse programs. 1 Introduction There is much work recently on using higherorder operators, such as fold [11] and build [8, 5], to automate program fusion [2] and deforestation [13]. Even though these methods do a good job on fusing programs, they are only effective if programs are expressed in terms of these operators. This limits their applicability to conventional functional languages. To ameliorate this pr...
PType system: A featherweight parallelizability detector
 IN PROCEEDINGS OF 2ND ASIAN SYMPOSIUM ON PROGRAMMING LANGUAGES AND SYSTEMS (APLAS 2004), LNCS 3302
, 2004
"... Parallel programming is becoming an important cornerstone of general computing. In addition, type systems have significant impact on program analysis. In this paper, we demonstrate an automated typebased system that soundly detects parallelizability of sequential functional programs. Our type infer ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
Parallel programming is becoming an important cornerstone of general computing. In addition, type systems have significant impact on program analysis. In this paper, we demonstrate an automated typebased system that soundly detects parallelizability of sequential functional programs. Our type inference system discovers the parallelizability property of a sequential program in a modular fashion, by exploring a ring structure among the program’s operators. It handles selfrecursive functions with accumulating parameters, as well as a class of nonlinear mutualrecursive functions. Programs whose types are inferred to be parallelizable can be automatically transformed to parallel code in a mutumorphic form – a succint model for parallel computation. Transforming into such a form is an important step towards constructing efficient data parallel programs.
Towards polytypic parallel programming
, 1998
"... Data parallelism is currently one of the most successful models for programming massively parallel computers. The central idea is to evaluate a uniform collection of data in parallel by simultaneously manipulating each data element in the collection. Despite many of its promising features, the curre ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
Data parallelism is currently one of the most successful models for programming massively parallel computers. The central idea is to evaluate a uniform collection of data in parallel by simultaneously manipulating each data element in the collection. Despite many of its promising features, the current approach suffers from two problems. First, the main parallel data structures that most data parallel languages currently support are restricted to simple collection data types like lists, arrays or similar structures. But other useful data structures like trees have not been well addressed. Second, parallel programming relies on a set of parallel primitives that capture parallel skeletons of interest. However, these primitives are not well structured, and efficient parallel programming with these primitives is difficult. In this paper, we propose a polytypic framework for developing efficient parallel programs on most data structures. We showhow a set of polytypic parallel primitives can be formally defined for manipulating most data structures, how these primitives can be successfully structured into a uniform recursive definition, and how an efficient combination of primitives can be derived from a naive specification program. Our framework should be significant not only in development of new parallel algorithms, but also in construction of parallelizing compilers.
A Calculational Framework for Parallelization of Sequential Programs
 In International Symposium on Information Systems and Technologies for Network Society
, 1997
"... this paper, we propose ..."
Abstract Program Transformation by Solving Recurrences
"... Recursive programs may require large numbers of procedure calls and stack operations, and many such recursive programs exhibit exponential time complexity, due to the time spent recalculating already computed subproblems. As a result, methods which transform a given recursive program to an iterati ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
Recursive programs may require large numbers of procedure calls and stack operations, and many such recursive programs exhibit exponential time complexity, due to the time spent recalculating already computed subproblems. As a result, methods which transform a given recursive program to an iterative one have been intensively studied. We propose here a new framework for transforming programs by removing recursion. The framework includes a unified method of deriving low timecomplexity programs by solving recurrences extracted from the program sources. Our prototype system, ������, is an initial implementation of the framework, automatically finding simpler “closed form ” versions of a class of recursive programs. Though in general the solution of recurrences is easier if the functions have only a single recursion parameter, we show a practical technique for solving those with multiple recursion parameters.
A TypeBased Approach to Parallelization
 National University of Singapore
, 2003
"... Parallel programs can be synthesized from sequential functional programs via a technique known as context preservation [6]. This technique has significantly broadened the set of sequential programs eligible for parallelization. However, the ability to automatically detect functions which admit conte ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Parallel programs can be synthesized from sequential functional programs via a technique known as context preservation [6]. This technique has significantly broadened the set of sequential programs eligible for parallelization. However, the ability to automatically detect functions which admit contextpreservation property has not been investigated. In this paper, we propose a typebased approach to automatically detect a class of functions with contextpreservation property. In essence, our type system aims to detect an extendedring property of the subject program, from which context preservation is guaranteed. Through this type system, a sequential program can be automatically transformed to fit into a skeletal form, which can then be parallelized.
Swapping arguments and results of recursive functions
 In Mathematics of Program Construction, Proceedings, volume 4014 of LNCS
, 2006
"... Abstract. Many useful calculation rules, such as fusion and tupling, rely on wellstructured functions, especially in terms of inputs and outputs. For instance, fusion requires that wellproduced outputs should be connected to wellconsumed inputs, so that unnecessary intermediate data structures ca ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
Abstract. Many useful calculation rules, such as fusion and tupling, rely on wellstructured functions, especially in terms of inputs and outputs. For instance, fusion requires that wellproduced outputs should be connected to wellconsumed inputs, so that unnecessary intermediate data structures can be eliminated. These calculation rules generally fail to work unless functions are wellstructured. In this paper, we propose a new calculation rule called IO swapping. IO swapping exchanges calltime computations (occurring in the arguments) and returntime computations (occurring in the results) of a function, while guaranteeing that the original and resulting function compute the same value. IO swapping enables us to rearrange inputs and outputs so that the existing calculation rules can be applied. We present new systematic derivations of efficient programs for detecting palindromes, and a method of higherorder removal that can be applied to defunctionalize function arguments, as two concrete applications. 1
The expression lemma ⋆
"... Abstract. Algebraic data types and catamorphisms (folds) play a central role in functional programming as they allow programmers to define recursive data structures and operations on them uniformly by structural recursion. Likewise, in objectoriented (OO) programming, recursive hierarchies of objec ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Abstract. Algebraic data types and catamorphisms (folds) play a central role in functional programming as they allow programmers to define recursive data structures and operations on them uniformly by structural recursion. Likewise, in objectoriented (OO) programming, recursive hierarchies of object types with virtual methods play a central role for the same reason. There is a semantical correspondence between these two situations which we reveal and formalize categorically. To this end, we assume a coalgebraic model of OO programming with functional objects. The development may be helpful in deriving refactorings that turn sufficiently disciplined functional programs into OO programs of a designated shape and vice versa. Key words: expression lemma, expression problem, functional object, catamorphism, fold, the composite design pattern, program calculation, distributive law, free monad, cofree comonad. 1
Three Complementary Approaches to Bidirectional Programming
"... Abstract. This paper surveys three distinct approaches to bidirectional programming. The first approach, syntactic bidirectionalization, takes a program describing the forward transformation as input and calculates a wellbehaved reverse transformation. The second approach, semantic bidirectionaliza ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Abstract. This paper surveys three distinct approaches to bidirectional programming. The first approach, syntactic bidirectionalization, takes a program describing the forward transformation as input and calculates a wellbehaved reverse transformation. The second approach, semantic bidirectionalization, is similar, but takes the forward transformation itself as input rather than a program describing it. It requires the transformation to be a polymorphic function and uses parametricity and free theorems in the proof of wellbehavedness. The third approach, based on bidirectional combinators, focuses on the use of types to ensure wellbehavedness and special constructs for dealing with alignment problems. In presenting these approaches, we pay particular attention to use of complements, which are structures that represent the information discarded by the transformation in the forward direction. 1
PolynomialTime Inverse Computation for Accumulative Functions with Multiple Data Traversals
"... Inverse computation has many applications such as serialization/deserialization, providing support for undo, and testcase generation for software testing. In this paper, we propose an inverse computation method that always terminates for a class of functions known as parameterlinear macro tree tra ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
Inverse computation has many applications such as serialization/deserialization, providing support for undo, and testcase generation for software testing. In this paper, we propose an inverse computation method that always terminates for a class of functions known as parameterlinear macro tree transducers, which involve multiple data traversals and the use of accumulations. The key to our method is the observation that a function in the class can be regarded as a nonaccumulative contextgenerating transformation without multiple data traversals. Accordingly, we demonstrate that it is easy to achieve terminating inverse computation for the class by contextwise memoization of the inverse computation results. We also show that when we use a tree automaton to express the inverse computation results, the inverse computation runs in time polynomial to the size of the original output and the textual program size.