Improving the Interoperation between Generics Translations

Ureche, Vlad; Stojanović, Miloš; Beguet, Romain Michel; Stucki, Nicolas; Odersky, Martin

doi:10.1145/2807426.2807436

“…Wider use of miniboxing suggested that similar specialization techniques can harm performance if specialized code is called frequently from generic code and vice versa (Ureche et al 2015). Consider the following example.…”

Section: Specialization Techniquesmentioning

confidence: 99%

Call graphs for languages with parametric polymorphism

PetrashkoDmitry¹,

UrecheVlad²,

LhotákOndřej

³

et al. 2016

Self Cite

View full text Add to dashboard Cite

The performance of contemporary object oriented languages depends on optimizations such as devirtualization, inlining, and specialization, and these in turn depend on precise call graph analysis. Existing call graph analyses do not take advantage of the information provided by the rich type systems of contemporary languages, in particular generic type arguments. Many existing approaches analyze Java bytecode, in which generic types have been erased. This paper shows that this discarded information is actually very useful as the context in a context-sensitive analysis, where it significantly improves precision and keeps the running time small. Specifically, we propose and evaluate call graph construction algorithms in which the contexts of a method are (i) the type arguments passed to its type parameters, and (ii) the static types of the arguments passed to its term parameters. The use of static types from the caller as context is effective because it allows more precise dispatch of call sites inside the callee.Our evaluation indicates that the average number of contexts required per method is small. We implement the analysis in the Dotty compiler for Scala, and evaluate it on programs that use the type-parametric Scala collections library and on the Dotty compiler itself. The context-sensitive analysis runs 1.4x faster than a context-insensitive one and discovers 20% more monomorphic call sites at the same time. When applied to method specialization, the imprecision in a context-insensitive call graph would require the average method to be cloned 22 times, whereas the context-sensitive call graph indicates a much more practical 1.00 to 1.50 clones per method.

show abstract

“…The miniboxing implementation also provides warnings ("performance advisories") to notify the programmer about the code locations where boxing and unboxing operations are inserted and to suggest annotations that would eliminate them (Ureche et al 2015). However, the fundamental problems remain.…”

Section: Application To Specializationmentioning

confidence: 99%

“…In contrast, the value a in the generic method bar1 will already be boxed before bar1 is called, so it will not have to be boxed again in every iteration of the loop. The miniboxing implementation tries to help users to solve this problem by providing comprehensive warnings that suggest possible changes to the code (Ureche et al 2015).…”

Section: Specialization Techniquesmentioning

confidence: 99%

Call graphs for languages with parametric polymorphism

Petrashko

¹

,

Ureche

²

,

Lhoták

³

et al. 2016

Proceedings of the 2016 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applicatio

Self Cite

View full text Add to dashboard Cite

The performance of contemporary object oriented languages depends on optimizations such as devirtualization, inlining, and specialization, and these in turn depend on precise call graph analysis. Existing call graph analyses do not take advantage of the information provided by the rich type systems of contemporary languages, in particular generic type arguments. Many existing approaches analyze Java bytecode, in which generic types have been erased. This paper shows that this discarded information is actually very useful as the context in a context-sensitive analysis, where it significantly improves precision and keeps the running time small. Specifically, we propose and evaluate call graph construction algorithms in which the contexts of a method are (i) the type arguments passed to its type parameters, and (ii) the static types of the arguments passed to its term parameters. The use of static types from the caller as context is effective because it allows more precise dispatch of call sites inside the callee.Our evaluation indicates that the average number of contexts required per method is small. We implement the analysis in the Dotty compiler for Scala, and evaluate it on programs that use the type-parametric Scala collections library and on the Dotty compiler itself. The context-sensitive analysis runs 1.4x faster than a context-insensitive one and discovers 20% more monomorphic call sites at the same time. When applied to method specialization, the imprecision in a context-insensitive call graph would require the average method to be cloned 22 times, whereas the context-sensitive call graph indicates a much more practical 1.00 to 1.50 clones per method.

show abstract

“…The adrt scoped transformation is a conceptual generalization of a mechanism motivated by library transformation scenarios. In particular, the resulting data representation transformation is used in conjunction with the miniboxing transformation [6,46] functions and tuples by custom, optimized versions adequate for miniboxed code [48]. The scope of this data representation transformation is miniboxing-transformed code.…”

Section: Adrt In Realistic Librariesmentioning

confidence: 99%

Automating ad hoc data representation transformations

Ureche

¹

,

Biboudis

²

,

Smaragdakis

³

et al. 2015

Proceedings of the 2015 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applicatio

Self Cite

View full text Add to dashboard Cite

To maximize run-time performance, programmers often specialize their code by hand, replacing library collections and containers by custom objects in which data is restructured for efficient access. However, changing the data representation is a tedious and error-prone process that makes it hard to test, maintain and evolve the source code.We present an automated and composable mechanism that allows programmers to safely change the data representation in delimited scopes containing anything from expressions to entire class definitions. To achieve this, programmers define a transformation and our mechanism automatically and transparently applies it during compilation, eliminating the need to manually change the source code.Our technique leverages the type system in order to offer correctness guarantees on the transformation and its interaction with object-oriented language features, such as dynamic dispatch, inheritance and generics.We have embedded this technique in a Scala compiler plugin and used it in four very different transformations, ranging from improving the data layout and encoding, to retrofitting specialization and value class status, and all the way to collection deforestation. On our benchmarks, the technique obtained speedups between 1.8x and 24.5x.

show abstract

Improving the Interoperation between Generics Translations

Cited by 6 publications

References 22 publications

Call graphs for languages with parametric polymorphism

Call graphs for languages with parametric polymorphism

Call graphs for languages with parametric polymorphism

Automating ad hoc data representation transformations

Contact Info

Product

Resources

About