Uniqueness typing for functional languages with graph rewriting semantics

Barendsen, Erik; Smetsers, Sjaak

doi:10.1017/s0960129500070109

Cited by 82 publications

(43 citation statements)

References 15 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…zip and unzip behave as usual, i.e, zip({1,2,3},{4,5,6}) = {(1,4), (2,5), (3,6)}, but the semantics of zip requires that the input arrays have outermost dimensions of equal sizes. Otherwise a compile or runtime error is signalled.…”

Section: Preliminaries: L 0 and Enabling Optimizationsmentioning

confidence: 99%

“…If so, then it is used in at least two kernels that may share an execution path, and hence it is unfusable. We make two remarks: First, if an array in the input set of Sc was produced by 5 A normalized program guarantees that the input arrays of a SOAC are variables rather than arbitrary expressions, hence we need not scan them. Figure 13.…”

Section: Fusing One Soacmentioning

confidence: 99%

See 1 more Smart Citation

A T2 graph-reduction approach to fusion

Henriksen¹,

Oancea²

2013

Proceedings of the 2nd ACM SIGPLAN Workshop on Functional High-Performance Computing

View full text Add to dashboard Cite

Fusion is one of the most important code transformations as it has the potential to substantially optimize both the memory hierarchy time overhead and, sometimes asymptotically, the space requirement. In functional languages, fusion is naturally and relatively easily derived as a producer-consumer relation between program constructs that expose a richer, higher-order algebra of program invariants, such as the map-reduce list homomorphisms.In imperative languages, fusing producer-consumer loops requires dependency analysis on arrays applied at loop-nest level. Such analysis, however, has often been labeled as "heroic effort" and, if at all, is supported only in its simplest and most conservative form in industrial compilers.Related implementations in the functional context typically apply fusion only when the to-be-fused producer is used exactly once, i.e., in the consumer. This guarantees that the transformation is conservative: the resulting program does not duplicate computation.We show that the above restriction is more conservative than needed, and present a structural-analysis technique, inspired from the T1-T2 transformation for reducible data flow, that enables fusion even in some cases when the producer is used in different consumers and without duplicating computation.We report an implementation of the fusion algorithm for a functional-core language, named L0, which is intended to support nested parallelism across regular multi-dimensional arrays. We succinctly describe L0's semantics and the compiler infrastructure on which the fusion transformation relies, and present compilergenerated statistics related to fusion on a set of six benchmarks.

show abstract

Section: Preliminaries: L 0 and Enabling Optimizationsmentioning

confidence: 99%

Section: Fusing One Soacmentioning

confidence: 99%

A T2 graph-reduction approach to fusion

Henriksen¹,

Oancea²

2013

Proceedings of the 2nd ACM SIGPLAN Workshop on Functional High-Performance Computing

View full text Add to dashboard Cite

show abstract

“…Barring a linear or affine type system in the host language-Clean's uniqueness types (Barendsen and Smetsers 1996) may be sufficient-some other means to prevent aliasing of capabilities is required. The indexed monad Session accomplishes this in our Haskell implementation of session types.…”

Section: Applicability To Other Languagesmentioning

confidence: 99%

Haskell session types with (almost) no class

Pucella

Tov

2008

SIGPLAN Not.

View full text Add to dashboard Cite

We describe an implementation of session types in Haskell. Session types statically enforce that client-server communication proceeds according to protocols. They have been added to several concurrent calculi, but few implementations of session types are available.Our embedding takes advantage of Haskell where appropriate, but we rely on no exotic features. Thus our approach translates with minimal modification to other polymorphic, typed languages such as ML and Java. Our implementation works with existing Haskell concurrency mechanisms, handles multiple communication channels and recursive session types, and infers protocols automatically.While our implementation uses unsafe operations in Haskell, it does not violate Haskell's safety guarantees. We formalize this claim in a concurrent calculus with unsafe communication primitives over which we layer our implementation of session types, and we prove that the session types layer is safe. In particular, it enforces that channel-based communication follows consistent protocols.

show abstract

“…The type systems [25,24,2] based on linear logic fail to achieve the Example 1 case because variable l is used twice. Kobayashi [10], and Aspinall and Hofmann [1] overcome this shortcoming by using more fine-grained usage aspects, but their systems still reject Example 1 because variables l and t are aliased at line (2)- (3).…”

Section: Related Workmentioning

confidence: 99%

“…A → ∃X. (A˙ X, A) of copyleft, we instantiate A by the memory-type π.left of the argument t1, and X by the name X 2 for the newly allocated cells at line (2). The instantiated memory-type π.left → (π.left˙ X 2 , π.left) says that when applied to the left subtree t1 of t, the function returns a tree consisting of new cells or the cells already in the left subtree t1, but uses only the cells in the left subtree t1.…”

Section: Step One: the Memory Usage Analysismentioning

confidence: 99%

Static insertion of safe and effective memory reuse commands into ML-like programs

Lee

Yang

2005

Science of Computer Programming

View full text Add to dashboard Cite

We present a static analysis that estimates reusable memory cells and a source-level transformation that adds explicit memory reuse commands into the program text. For benchmark ML programs, our analysis and transformation system achieves a memory reuse ratio from 5.2% to 91.3% and reduces the memory peak from 0.0% to 71.9%. The small-ratio cases are for programs that have a number of data structures that are shared. For other cases, our experimental results are encouraging in terms of accuracy and cost. Major features of our analysis and transformation are: (1) polyvariant analysis of functions by parameterization for the argument heap cells; (2) use of multiset formulas in expressing the sharings and partitionings of heap cells; (3) deallocations conditioned by dynamic flags that are passed as extra arguments to functions; (4) individual heap cells as the granularity of explicit memory reuse. Our analysis and transformation system is fully automatic.

show abstract

Uniqueness typing for functional languages with graph rewriting semantics

Cited by 82 publications

References 15 publications

A T2 graph-reduction approach to fusion

A T2 graph-reduction approach to fusion

Haskell session types with (almost) no class

Static insertion of safe and effective memory reuse commands into ML-like programs

Contact Info

Product

Resources

About