Results 1  10
of
12
Spaceefficient gradual typing
 In Trends in Functional Programming (TFP
, 2007
"... Gradual type systems offer a smooth continuum between static and dynamic typing by permitting the free mixture of typed and untyped code. The runtime systems for these languages–and other languages with hybrid type checking–typically enforce function types by dynamically generating function proxies. ..."
Abstract

Cited by 25 (3 self)
 Add to MetaCart
Gradual type systems offer a smooth continuum between static and dynamic typing by permitting the free mixture of typed and untyped code. The runtime systems for these languages–and other languages with hybrid type checking–typically enforce function types by dynamically generating function proxies. This approach can result in unbounded growth in the number of proxies, however, which drastically impacts space efficiency and destroys tail recursion. We present an implementation strategy for gradual typing that is based on coercions instead of function proxies, and which combines adjacent coercions to limit their space consumption. We prove bounds on the space consumed by coercions as well as soundness of the type system, demonstrating that programmers can safely mix typing disciplines without incurring unreasonable overheads. Our approach also detects certain errors earlier than prior work. 1 GRADUAL TYPING FOR SOFTWARE EVOLUTION Dynamically typed languages have always excelled at exploratory programming.
Logical Predicates for Intuitionistic Linear Type Theories
 In Typed Lambda Calculi and Applications (TLCA'99), Lecture Notes in Computer Science 1581
, 1999
"... We develop a notion of Kripkelike parameterized logical predicates for two fragments of intuitionistic linear logic (MILL and DILL) in terms of their categorytheoretic models. Such logical predicates are derived from the categorical glueing construction combined with the free symmetric monoidal co ..."
Abstract

Cited by 11 (4 self)
 Add to MetaCart
We develop a notion of Kripkelike parameterized logical predicates for two fragments of intuitionistic linear logic (MILL and DILL) in terms of their categorytheoretic models. Such logical predicates are derived from the categorical glueing construction combined with the free symmetric monoidal cocompletion. As applications, we obtain full completeness results of translations between linear type theories.
Spaceprofiling semantics of the callbyvalue lambda calculus and the CPS transformation
 In The 3rd International Workshop on Higher Order Operational Techniques in Semantics, volume 26 of Electronic Notes in Theoretical Computer Science
, 1999
"... We show that the CPS transformation from the callbyvalue lambda calculus to a CPS language preserves space required for execution of a program within a constant factor. For the callbyvalue lambda calculus we adopt a spaceprofiling semantics based on the profiling semantics of NESL by Blelloch a ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
We show that the CPS transformation from the callbyvalue lambda calculus to a CPS language preserves space required for execution of a program within a constant factor. For the callbyvalue lambda calculus we adopt a spaceprofiling semantics based on the profiling semantics of NESL by Blelloch and Greiner. However, we have noticed their semantics has some inconsistency between the treatments of stack space and heap space. This requires us to revise the semantics so that the semantics treats space in more consistent manner in order to obtain our result. 1
Categorical Glueing and Logical Predicates for Models of Linear Logic
, 1999
"... We give a series of glueing constructions for categorical models of fragments of linear logic. Specifically, we consider the glueing of (i) symmetric monoidal closed categories (models of Multiplicative Intuitionistic Linear Logic), (ii) symmetric monoidal adjunctions (for interpreting the modality ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
We give a series of glueing constructions for categorical models of fragments of linear logic. Specifically, we consider the glueing of (i) symmetric monoidal closed categories (models of Multiplicative Intuitionistic Linear Logic), (ii) symmetric monoidal adjunctions (for interpreting the modality !) and (iii) autonomous categories (models of Multiplicative Linear Logic); the glueing construction for autonomous categories is a mild generalization of the double glueing construction due to Hyland and Tan. Each of the glueing techniques can be used for creating interesting models of linear logic. In particular, we use them, together with the free symmetric monoidal cocompletion, for deriving Kripkelike parameterized logical predicates (logical relations) for the fragments of linear logic. As an application, we show full completeness results for translations between linear type theories. Contents 1 Introduction 3 2 Preliminaries 4 2.1 Symmetric Monoidal Structures . . . . . . . ....
Representation Analysis for Coercion Placement
"... This paper presents a global approach to representation analysis based on programwide data and control flow information. Boxing and unboxing coercions can be placed around any variable occurrence, not only where values are produced and consumed. ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
This paper presents a global approach to representation analysis based on programwide data and control flow information. Boxing and unboxing coercions can be placed around any variable occurrence, not only where values are produced and consumed.
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
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
Evaluation of a JustinTime Compiler Retrofitted for PHP
"... Programmers who develop Web applications often use dynamic scripting languages such as Perl, PHP, Python, and Ruby. For general purpose scripting language usage, interpreterbased implementations are efficient and popular but the serverside usage for Web application development implies an opportuni ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
Programmers who develop Web applications often use dynamic scripting languages such as Perl, PHP, Python, and Ruby. For general purpose scripting language usage, interpreterbased implementations are efficient and popular but the serverside usage for Web application development implies an opportunity to significantly enhance Web server throughput. This paper summarizes a study of the optimization of PHP script processing. We developed a PHP processor, P9, by adapting an existing productionquality justintime (JIT) compiler for a Java virtual machine, for which optimization technologies have been wellestablished, especially for serverside application. This paper describes and contrasts microbenchmarks and SPECweb2005 benchmark results for a welltuned configuration of a traditional PHP interpreter and our JIT compilerbased implementation, P9. Experimental results with the microbenchmarks show 2.59.5x advantage with P9, and the SPECweb2005 measurements show 2030 % improvements. These results show that the acceleration of dynamic scripting language processing does matter in a realistic Web application server environment. CPU usage profiling shows our simple JIT compiler introduction reduces the PHP core runtime overhead from 45 % to 13 % for a SPECweb2005 scenario, implying that further improvements of dynamic compilers would provide little additional return unless other major overheads such as heavy memory copy between the language runtime and Web server frontend are reduced.
... : Using Nondeterministic Choice as Part of a Deterministic Calculus
, 2000
"... Optimizing compilers for functional languages often use calculus to represent programs during optimization. We investigate the addition of a nondeterministic choice operator to such a language and demonstrate how a compiler can take advantage of it by encoding pending optimization decisions in ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Optimizing compilers for functional languages often use calculus to represent programs during optimization. We investigate the addition of a nondeterministic choice operator to such a language and demonstrate how a compiler can take advantage of it by encoding pending optimization decisions in the calculus itself. We consider two versions of choice (free and constrained), discuss their differences, and suggest applications for each. We point out that the resulting system lacks confluence and show how to circumvent this potential problem. To this end, we define what constitutes a nonambiguous term and argue that nonambiguity is preserved by our transition rules. This leads to a notion of confluence that, although it is limited to a subset of all expressions, does not rule out any term an actual compiler would be interested in. Finally, we have a look at how one can construct efficiently computable heuristics for the calculus with choice. 1 Introduction The constructi...
Selective Tail Call Elimination
, 2003
"... Tail calls are expected not to consume stack space in most functional languages. However, there is no support for tail calls in some environments. Even in such environments, proper tail calls can be implemented with a technique called a trampoline. To reduce the overhead of trampolining while pr ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
Tail calls are expected not to consume stack space in most functional languages. However, there is no support for tail calls in some environments. Even in such environments, proper tail calls can be implemented with a technique called a trampoline. To reduce the overhead of trampolining while preserving stack space asymptotically we propose selective tail call elimination based on an e#ect system. The e#ect system infers the number of successive tail calls generated by the execution of an expression, and trampolines are introduced only when they are necessary.
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 1 (0 self)
 Add to MetaCart
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.