Lightweight generics in embedded systems through static analysis

Sallenave, Olivier; Ducournau, Roland

doi:10.1145/2248418.2248421

Cited by 9 publications

(6 citation statements)

References 20 publications

(17 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…This bound was never exceeded in our experimental evaluation, implying that recursive types did not occur in the benchmark programs. The same issue also occurs in Java and C#, and was previously noted by Sallenave and Ducourneau [22]. Their implementation issues a warning when it detects the situation.…”

Section: Tca Expandsupporting

confidence: 55%

“…It is more precise to consider only concrete types with which each abstract type is instantiated, similar to the approach of [22]. To this end, we introduce a mapping expand(), which maps each abstract type 9 T to those concrete types with which it has been instantiated:…”

Section: Tca Expandmentioning

confidence: 99%

“…Intuitively, RTA call refines CHA call by requiring that C ∈Σ, and rule RTA new reads: "Σ contains the classes that are instantiated in a reachable method." Sallenave and Ducourneau [22] recently presented an extension of RTA for the C# language that determines the types with which parameterized classes are instantiated by maintaining sets of type tuples for parameterized classes and methods. They use their analysis to generate efficient CLI code for embedded applications that avoids expensive boxing/unboxing operations on primitive types, while permitting a space-efficient shared representation for reference types.…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Constructing Call Graphs of Scala Programs

Ali

Rapoport

Lhoták

et al. 2014

ECOOP 2014 – Object-Oriented Programming

View full text Add to dashboard Cite

Abstract. ConsAs Scala gains popularity, there is growing interest in programming tools for it. Such tools often require call graphs. However, call graph construction algorithms in the literature do not handle Scala features, such as traits and abstract type members. Applying existing call graph construction algorithms to the JVM bytecodes generated by the Scala compiler produces very imprecise results due to type information being lost during compilation. We adapt existing call graph construction algorithms, Name-Based Resolution (RA) and Rapid Type Analysis (RTA), for Scala, and present a formalization based on Featherweight Scala. We evaluate our algorithms on a collection of Scala programs. Our results show that careful handling of complex Scala constructs greatly helps precision and that our most precise analysis generates call graphs with 1.1-3.7 times fewer nodes and 1.5-18.7 times fewer edges than a bytecode-based RTA analysis.

show abstract

Section: Tca Expandsupporting

confidence: 55%

Section: Tca Expandmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Constructing Call Graphs of Scala Programs

Ali

Rapoport

Lhoták

et al. 2014

ECOOP 2014 – Object-Oriented Programming

View full text Add to dashboard Cite

show abstract

“…In Scala, where use of generic type parameters and abstract type members is pervasive, our static-type-based context-sensitive analysis that can precisely model these features significantly improves call graph precision. The technique of using type arguments as context is most closely related to the C# type analysis of (Sallenave and Ducournau 2012). Their analysis adds type arguments as context to types of instantiated objects (their analogue of the setΣ).…”

Section: Call Graph Construction and Context Sensitivitymentioning

confidence: 99%

Call graphs for languages with parametric polymorphism

PetrashkoDmitry¹,

UrecheVlad²,

LhotákOndřej

et al. 2016

SIGPLAN Not.

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 work by Sallenave and Ducournau [35] shares the same goals as miniboxing: offering unboxed generics without the bytecode explosion. However, the target is different: their Lightweight Generics compiler targets embedded devices and works under a closed world assumption.…”

Section: Related Workmentioning

confidence: 99%

Miniboxing

Ureche

Talau

Odersky

2013

Proceedings of the 2013 ACM SIGPLAN International Conference on Object Oriented Programming Systems Languages &Amp; Application

View full text Add to dashboard Cite

Parametric polymorphism enables code reuse and type safety. Underneath the uniform interface exposed to programmers, however, its low level implementation has to cope with inherently non-uniform data: value types of different sizes and semantics (bytes, integers, floating point numbers) and reference types (pointers to heap objects). On the Java Virtual Machine, parametric polymorphism is currently translated to bytecode using two competing approaches: homogeneous and heterogeneous. Homogeneous translation requires boxing, and thus introduces indirect access delays. Heterogeneous translation duplicates and adapts code for each value type individually, producing more bytecode. Therefore bytecode speed and size are at odds with each other. This paper proposes a novel translation that significantly reduces the bytecode size without affecting the execution speed. The key insight is that larger value types (such as integers) can hold smaller ones (such as bytes) thus reducing the duplication necessary in heterogeneous translations. In our implementation, on the Scala compiler, we encode all primitive value types in long integers. The resulting bytecode approaches the performance of monomorphic code, matches the performance of the heterogeneous translation and obtains speedups of up to 22x over the homogeneous translation, all with modest increases in size.

show abstract

Lightweight generics in embedded systems through static analysis

Cited by 9 publications

References 20 publications

Constructing Call Graphs of Scala Programs

Constructing Call Graphs of Scala Programs

Call graphs for languages with parametric polymorphism

Miniboxing

Contact Info

Product

Resources

About