Tracing the meta-level

Bolz, Carl Friedrich; Cuni, Antonio; Fijałkowski, Maciej; Rigo, Armin

doi:10.1145/1565824.1565827

Cited by 217 publications

(41 citation statements)

References 18 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…We added this configuration also to estimate the overhead of state-of-the-art synchronization strategies as used by the JRuby object model. 3 As illustrated in Figure 9, there is no significant difference between the unsafe and safe object model on these benchmarks. Specifically, the maximum difference between the medians is 5.1%, which is well within measurement error.…”

Section: Impact On Sequential Performancementioning

confidence: 86%

Efficient and thread-safe objects for dynamically-typed languages

DalozeBenoit¹,

MarrStefan²,

BonettaDaniele³

et al. 2016

SIGPLAN Not.

View full text Add to dashboard Cite

We are in the multi-core era. Dynamically-typed languages are in widespread use, but their support for multithreading still lags behind. One of the reasons is that the sophisticated techniques they use to efficiently represent their dynamic object models are often unsafe in multithreaded environments. This paper defines safety requirements for dynamic object models in multithreaded environments. Based on these requirements, a language-agnostic and thread-safe object model is designed that maintains the efficiency of sequential approaches. This is achieved by ensuring that field reads do not require synchronization and field updates only need to synchronize on objects shared between threads. Basing our work on JRuby+Truffle, we show that our safe object model has zero overhead on peak performance for thread-local objects and only 3% average overhead on parallel benchmarks where field updates require synchronization. Thus, it can be a foundation for safe and efficient multithreaded VMs for a wide range of dynamic languages.

show abstract

Section: Impact On Sequential Performancementioning

confidence: 86%

Efficient and thread-safe objects for dynamically-typed languages

DalozeBenoit¹,

MarrStefan²,

BonettaDaniele³

et al. 2016

SIGPLAN Not.

View full text Add to dashboard Cite

show abstract

“…The most popular open-source production VMs using this design are LuaJIT [35] and Pypy 6 [36]. The Pharo VM does not use this design, so we will not discuss it further.…”

Section: High-performance Virtual Machine Execution Modelmentioning

confidence: 99%

“…However, we are not aware of the level of difficulty it would produce. There is a 745 question of how to implement a dynamic type data gatherer for VMs using a metatracing runtime compiler, such as LuaJIT [35] and Pypy [36], as their execution model is different than the method-based one. As for the static code analysis, it may not be trivial to do in other object-oriented languages, due to the need for external tools to analyse the source code and obtain the AST of the code, e.g.,…”

mentioning

confidence: 99%

Mining inline cache data to order inferred types in dynamic languages

Milojković

Béra

Ghafari

et al. 2018

Science of Computer Programming

View full text Add to dashboard Cite

The lack of static type information in dynamically-typed languages often poses obstacles for developers. Type inference algorithms can help, but inferring precise type information requires complex algorithms that are often slow.A simple approach that considers only the locally used interface of variables can identify potential classes for variables, but popular interfaces can generate a large number of false positives. We propose an approach called inline-cache type inference (ICTI) to augment the precision of fast and simple type inference algorithms. ICTI uses type information available in the inline caches during multiple software runs, to provide a ranked list of possible classes that most likely represent a variable's type. We evaluate ICTI through a proof-of-concept that we implement in Pharo Smalltalk. The analysis of the top-n+2 inferred types (where n is the number of recorded run-time types for a variable) for 5486 variables from four different software systems shows that ICTI produces promising results for about 75% of the variables. For more than 90% of variables, the correct runtime type is present among first six inferred types. Our ordering shows a twofold improvement when compared with the unordered basic approach, i.e., for a significant number of variables for which the basic approach offered ambiguous results, ICTI was able to promote the correct type to the top of the list.

show abstract

“…They showed that the context threading technique significantly improves branch prediction and reduces execution time for OCaml and Java interpreters. In 2009, Brunthaler [2009] explained that the optimization potential for threaded code varies with the complexity of the i-ops.…”

Section: Threaded Codementioning

confidence: 99%

Efficient hosted interpreters on the JVM

Savrun-Yeniçeri

Zhang

et al. 2014

ACM Trans. Archit. Code Optim.

View full text Add to dashboard Cite

Many guest languages are implemented using the Java Virtual Machine (JVM) as a host environment. There are two major implementation choices: custom compilers and so-called hosted interpreters. Custom compilers are complex to build but offer good performance. Hosted interpreters are comparatively simpler to implement but until now have suffered from poor performance.We studied the performance of hosted interpreters and identified common bottlenecks preventing their efficient execution. First, similar to interpreters written in C/C++, instruction dispatch is expensive on the JVM. Second, Java's semantics require expensive runtime exception checks that negatively affect array performance essential to interpreters.We present two optimizations targeting these bottlenecks and show that the performance of optimized interpreters increases dramatically: we report speedups by a factor of up to 2.45 over the Jython interpreter, 3.57 over the Rhino interpreter, and 2.52 over the JRuby interpreter, respectively. The resulting performance is comparable with that of custom compilers. Our optimizations are enabled by a few simple annotations that require only modest implementation effort; in return, performance increases substantially.

show abstract

Tracing the meta-level

Cited by 217 publications

References 18 publications

Efficient and thread-safe objects for dynamically-typed languages

Efficient and thread-safe objects for dynamically-typed languages

Mining inline cache data to order inferred types in dynamic languages

Efficient hosted interpreters on the JVM

Contact Info

Product

Resources

About