Results 1 
8 of
8
Typed Memory Management via Static Capabilities
 ACM Transactions on Programming Languages and Systems
, 2000
"... Machine We have described the type constructor language of CL and the typing rules for the main termlevel constructs. In fact, the previous section contains all of the ACM Transactions on Programming Languages and Systems, Vol. TBD, No. TDB, Month Year. 20 D. Walker, K. Crary, and G. Morriset ..."
Abstract

Cited by 60 (6 self)
 Add to MetaCart
Machine We have described the type constructor language of CL and the typing rules for the main termlevel constructs. In fact, the previous section contains all of the ACM Transactions on Programming Languages and Systems, Vol. TBD, No. TDB, Month Year. 20 D. Walker, K. Crary, and G. Morrisett #; #;# # h at r : # # # # f : Type #; ## # ; #{f :# f , x 1 :# 1 , . . . , xn :# n}; C # e # # f = #[# # ].(C, # 1 , . . . , #n ) # 0 at r f, x 1 , . . . , xn ## Dom(#) # #; #;# # fix f[# # ](C, x 1 :# 1 , . . . , xn :# n ).e at r : # f (hfix) #; #;# # v i : # i (for 1 # i # n) # # r : Rgn #; #;# # #v 1 , . . . , vn # at r : ## 1 , . . . , #n # at r (htuple) #; #;# # h at r : # # # # # # = # : Type #; #;# # h at r : # (heq) #; #;# # v : # #; #;# # x : # (#(x) = #) (vvar) #; #;# # i : int (vint) #; #;# # v : #[#:#, # # ].(C, # 1 , . . . , #n ) # 0 at r # # c : # #; #;# # v[c] : (#[# # ].(C, # 1 , . . . , #n ) # 0)[c/#] at r (vtype) #; #;# # v : #[# # C ## , # # ].(C # , # 1 , . . . , #n ) # 0 at r # # C # C ## #; #;# # v[C] : (#[# # ].(C # , # 1 , . . . , #n ) # 0)[C/#] at r (vsub) #; #;# # v : # # # # # # = # : Type #; #;# # v : # (veq) Fig. 6. Capability static semantics: Heap and word values. information programmers or compilers require to write typesafe programs in CL. However, in order to prove a type soundness result in the style of Wright and Felleisen [Wright and Felleisen 1994], we must be able to type check programs at every step during their evaluation. In this section, we give the static semantics of the runtime values that are not normally manipulated by programmers, but are nevertheless necessary to prove our soundness result. At first, the formal definition ...
Possibilities and limitations of callbyneed space improvement
 In Proceedings of the sixth ACM SIGPLAN International Conference on Functional Programming
, 2001
"... ..."
(Show Context)
A new criterion for safe program transformations
 In Proceedings of the Forth International Workshop on Higher Order Operational Techniques in Semantics (HOOTS), volume 41(3) of ENTCS
, 2000
"... Previous studies on safety of program transformations with respect to performance considered two criteria: preserving performance within a constant factor and preserving complexity. However, as the requirement of program transformations used in compilers the former seems too restrictive and the latt ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
(Show Context)
Previous studies on safety of program transformations with respect to performance considered two criteria: preserving performance within a constant factor and preserving complexity. However, as the requirement of program transformations used in compilers the former seems too restrictive and the latter seems too loose. We propose a new safety criterion: a program transformation preserves performance within a factor proportional to the size of a source program. This criterion seems natural since several compilation methods have effects on performance proportional to the size of a program. Based on this criterion we have shown that two semantics formalizing the size of stack space are equivalent. We also discuss the connection between this criterion and the properties of local program transformations rewriting parts of a program. 1
Runtime Behavior of Conversion Interpretation of Subtyping
"... A programming language with subtyping can be translated into a language without subtyping by inserting conversion functions. Previous studies of this interpretation showed only the extensional correctness of the translation. We study runtime behavior of translated programs and show that this transla ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
A programming language with subtyping can be translated into a language without subtyping by inserting conversion functions. Previous studies of this interpretation showed only the extensional correctness of the translation. We study runtime behavior of translated programs and show that this translation preserves execution time and stack space within a factor determined by the types in a program. Both the proofs on execution time and stack space are based on the method of logical relations where relations are extended with the factor of slowdown or increase of stack space.
The Space Usage Problem: An Evaluation Kit for GraphReduction Semantics
 School of Computer Science, University of St
, 2000
"... We describe a software tool for specifying operational semantics as a termgraph reduction system. The semantics are guaranteed to model the asymptotic space and time usage of an implementation accurately yet are abstract enough to support reasoning at the program level. Term graphs make all th ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
We describe a software tool for specifying operational semantics as a termgraph reduction system. The semantics are guaranteed to model the asymptotic space and time usage of an implementation accurately yet are abstract enough to support reasoning at the program level. Term graphs make all the aspects of reduction relating to space usage explicit as they naturally encode size and address information. The semantics are constrained to be smallstep, deterministic rules and each rewrite step uses bounded resources. The result is a system suitable for describing and analysing the space behaviour of functional programming languages. 1
Cost Semantics for Space Usage in a Parallel Language
"... We describe a framework for better understanding scheduling policies for finegrained parallel computations and their effect on space usage. We define a profiling semantics that can be used to determine the asymptotic space taken by any schedule. A nondeterministic parallel transition semantics is u ..."
Abstract
 Add to MetaCart
(Show Context)
We describe a framework for better understanding scheduling policies for finegrained parallel computations and their effect on space usage. We define a profiling semantics that can be used to determine the asymptotic space taken by any schedule. A nondeterministic parallel transition semantics is used to describe all possible parallel executions. Refinements of that semantics can be used to model the behavior of particular schedulers. We use the framework to show that different schedules can lead to asymptotic differences in space usage. 1.
Possibilities and Limitations of CallbyNeed SpaceImprovement \Lambda
"... Consider the following equivalence for a pure functional language: x+y = y +x. How does this affect the space complexity of a program? Of course, it depends on the program and the language. In a lazy functional language the transformation is not space safe; there are programs for which this innocen ..."
Abstract
 Add to MetaCart
(Show Context)
Consider the following equivalence for a pure functional language: x+y = y +x. How does this affect the space complexity of a program? Of course, it depends on the program and the language. In a lazy functional language the transformation is not space safe; there are programs for which this innocentlooking transformation will change their space complexity. Now consider the following family of Haskell programs, indexed by some integer n: