The Experts below are selected from a list of 3477 Experts worldwide ranked by ideXlab platform
Alberto Bacchelli - One of the best experts on this subject based on the ideXlab platform.
-
On the reaction to deprecation of clients of 4 + 1 popular Java APIs and the JDK
Empirical Software Engineering, 2018Co-Authors: Anand Ashok Sawant, Romain Robbes, Alberto BacchelliAbstract:Application Programming Interfaces (APIs) are a tremendous resource—that is, when they are stable. Several studies have shown that this is unfortunately not the case. Of those, a large-scale study of API changes in the Pharo Smalltalk ecosystem documented several findings about API deprecations and their impact on API clients. We extend this study, by analyzing clients of both popular third-party Java APIs and the JDK API. This results in a dataset consisting of more than 25,000 clients of five popular Java APIs on GitHub, and 60 clients of the JDK API from Maven Central. This work addresses several shortcomings of the previous study, namely: a study of several distinct API clients in a popular, Statically-Typed Language, with more accurate version information. We compare and contrast our findings with the previous study and highlight new ones, particularly on the API client update practices and the startling similarities between reaction behavior in Smalltalk and Java. We make a comparison between reaction behavior for third-party APIs and JDK APIs, given that Language APIs are a peculiar case in terms of wide-spread usage, documentation, and support from IDEs. Furthermore, we investigate the connection between reaction patterns of a client and the deprecation policy adopted by the API used.
Toshio Nakatani - One of the best experts on this subject based on the ideXlab platform.
-
on the benefits and pitfalls of extending a Statically Typed Language jit compiler for dynamic scripting Languages
Conference on Object-Oriented Programming Systems Languages and Applications, 2012Co-Authors: Jose G Castanos, David Joel Edelsohn, Kazuaki Ishizaki, Priya Nagpurkar, Toshio Nakatani, Takeshi OgasawaraAbstract:Whenever the need to compile a new dynamically Typed Language arises, an appealing option is to repurpose an existing Statically Typed Language Just-In-Time (JIT) compiler (repurposed JIT compiler). Existing repurposed JIT compilers (RJIT compilers), however, have not yet delivered the hoped-for performance boosts. The performance of JVM Languages, for instance, often lags behind standard interpreter implementations. Even more customized solutions that extend the internals of a JIT compiler for the target Language compete poorly with those designed specifically for dynamically Typed Languages. Our own Fiorano JIT compiler is an example of this problem. As a state-of-the-art, RJIT compiler for Python, the Fiorano JIT compiler outperforms two other RJIT compilers (Unladen Swallow and Jython), but still shows a noticeable performance gap compared to PyPy, today's best performing Python JIT compiler. In this paper, we discuss techniques that have proved effective in the Fiorano JIT compiler as well as limitations of our current implementation. More importantly, this work offers the first in-depth look at benefits and limitations of the repurposed JIT compiler approach. We believe the most common pitfall of existing RJIT compilers is not focusing sufficiently on specialization, an abundant optimization opportunity unique to dynamically Typed Languages. Unfortunately, the lack of specialization cannot be overcome by applying traditional optimizations.
-
adding dynamically Typed Language support to a Statically Typed Language compiler performance evaluation analysis and tradeoffs
Virtual Execution Environments, 2012Co-Authors: Kazuaki Ishizaki, Jose G Castanos, David Joel Edelsohn, Priya Nagpurkar, Takeshi Ogasawara, Toshio NakataniAbstract:Applications written in dynamically Typed scripting Languages are increasingly popular for Web software development. Even on the server side, programmers are using dynamically Typed scripting Languages such as Ruby and Python to build complex applications quickly. As the number and complexity of dynamically Typed scripting Language applications grows, optimizing their performance is becoming important. Some of the best performing compilers and optimizers for dynamically Typed scripting Languages are developed entirely from scratch and target a specific Language. This approach is not scalable, given the variety of dynamically Typed scripting Languages, and the effort involved in developing and maintaining separate infrastructures for each. In this paper, we evaluate the feasibility of adapting and extending an existing production-quality method-based Just-In-Time (JIT) compiler for a Language with dynamic types. Our goal is to identify the challenges and shortcomings with the current infrastructure, and to propose and evaluate runtime techniques and optimizations that can be incorporated into a common optimization infrastructure for static and dynamic Languages. We discuss three extensions to the compiler to support dynamically Typed Languages: (1) simplification of control flow graphs, (2) mapping of memory locations to stack-allocated variables, and (3) reduction of runtime overhead using Language semantics. We also propose four new optimizations for Python in (2) and (3). These extensions are effective in reduction of compiler working memory and improvement of runtime performance. We present a detailed performance evaluation of our approach for Python, finding an overall improvement of 1.69x on average (up to 2.74x) over our JIT compiler without any optimization for dynamically Typed Languages and Python.
-
a study of devirtualization techniques for a java just in time compiler
Conference on Object-Oriented Programming Systems Languages and Applications, 2000Co-Authors: Kazuaki Ishizaki, Motohiro Kawahito, Toshiaki Yasue, Hideaki Komatsu, Toshio NakataniAbstract:Many devirtualization techniques have been proposed to reduce the runtime overhead of dynamic method calls for various object-oriented Languages, however, most of them are less effective or cannot be applied for Java in a straightforward manner. This is partly because Java is a Statically-Typed Language and thus transforming a dynamic call to a static one does not make a tangible performance gain (owing to the low overhead of accessing the method table) unless it is inlined, and partly because the dynamic class loading feature of Java prohibits the whole program analysis and optimizations from being applied.We propose a new technique called direct devirtualization with the code patching mechanism. For a given dynamic call site, our compiler first determines whether the call can be devirtualized, by analyzing the current class hierarchy. When the call is devirtualizable and the target method is suitably sized, the compiler generates the inlined code of the method, together with the backup code of making the dynamic call. Only the inlined code is actually executed until our assumption about the devirtualization becomes invalidated, at which time the compiler performs code patching to make the backup code executed subsequently. Since the new technique prevents some code motions across the merge point between the inlined code and the backup code, we have furthermore implemented recently-known analysis techniques, such as type analysis and preexistence analysis, which allow the backup code to be completely eliminated. We made various experiments using 16 real programs to understand the effectiveness and characteristics of the devirtualization techniques in our Java Just-In-Time (JIT) compiler. In summary, we reduced the number of dynamic calls by ranging from 8.9% to 97.3% (the average of 40.2%), and we improved the execution performance by ranging from -1% to 133% (with the geometric mean of 16%).
Anand Ashok Sawant - One of the best experts on this subject based on the ideXlab platform.
-
On the reaction to deprecation of clients of 4 + 1 popular Java APIs and the JDK
Empirical Software Engineering, 2018Co-Authors: Anand Ashok Sawant, Romain Robbes, Alberto BacchelliAbstract:Application Programming Interfaces (APIs) are a tremendous resource—that is, when they are stable. Several studies have shown that this is unfortunately not the case. Of those, a large-scale study of API changes in the Pharo Smalltalk ecosystem documented several findings about API deprecations and their impact on API clients. We extend this study, by analyzing clients of both popular third-party Java APIs and the JDK API. This results in a dataset consisting of more than 25,000 clients of five popular Java APIs on GitHub, and 60 clients of the JDK API from Maven Central. This work addresses several shortcomings of the previous study, namely: a study of several distinct API clients in a popular, Statically-Typed Language, with more accurate version information. We compare and contrast our findings with the previous study and highlight new ones, particularly on the API client update practices and the startling similarities between reaction behavior in Smalltalk and Java. We make a comparison between reaction behavior for third-party APIs and JDK APIs, given that Language APIs are a peculiar case in terms of wide-spread usage, documentation, and support from IDEs. Furthermore, we investigate the connection between reaction patterns of a client and the deprecation policy adopted by the API used.
Kazuaki Ishizaki - One of the best experts on this subject based on the ideXlab platform.
-
on the benefits and pitfalls of extending a Statically Typed Language jit compiler for dynamic scripting Languages
Conference on Object-Oriented Programming Systems Languages and Applications, 2012Co-Authors: Jose G Castanos, David Joel Edelsohn, Kazuaki Ishizaki, Priya Nagpurkar, Toshio Nakatani, Takeshi OgasawaraAbstract:Whenever the need to compile a new dynamically Typed Language arises, an appealing option is to repurpose an existing Statically Typed Language Just-In-Time (JIT) compiler (repurposed JIT compiler). Existing repurposed JIT compilers (RJIT compilers), however, have not yet delivered the hoped-for performance boosts. The performance of JVM Languages, for instance, often lags behind standard interpreter implementations. Even more customized solutions that extend the internals of a JIT compiler for the target Language compete poorly with those designed specifically for dynamically Typed Languages. Our own Fiorano JIT compiler is an example of this problem. As a state-of-the-art, RJIT compiler for Python, the Fiorano JIT compiler outperforms two other RJIT compilers (Unladen Swallow and Jython), but still shows a noticeable performance gap compared to PyPy, today's best performing Python JIT compiler. In this paper, we discuss techniques that have proved effective in the Fiorano JIT compiler as well as limitations of our current implementation. More importantly, this work offers the first in-depth look at benefits and limitations of the repurposed JIT compiler approach. We believe the most common pitfall of existing RJIT compilers is not focusing sufficiently on specialization, an abundant optimization opportunity unique to dynamically Typed Languages. Unfortunately, the lack of specialization cannot be overcome by applying traditional optimizations.
-
adding dynamically Typed Language support to a Statically Typed Language compiler performance evaluation analysis and tradeoffs
Virtual Execution Environments, 2012Co-Authors: Kazuaki Ishizaki, Jose G Castanos, David Joel Edelsohn, Priya Nagpurkar, Takeshi Ogasawara, Toshio NakataniAbstract:Applications written in dynamically Typed scripting Languages are increasingly popular for Web software development. Even on the server side, programmers are using dynamically Typed scripting Languages such as Ruby and Python to build complex applications quickly. As the number and complexity of dynamically Typed scripting Language applications grows, optimizing their performance is becoming important. Some of the best performing compilers and optimizers for dynamically Typed scripting Languages are developed entirely from scratch and target a specific Language. This approach is not scalable, given the variety of dynamically Typed scripting Languages, and the effort involved in developing and maintaining separate infrastructures for each. In this paper, we evaluate the feasibility of adapting and extending an existing production-quality method-based Just-In-Time (JIT) compiler for a Language with dynamic types. Our goal is to identify the challenges and shortcomings with the current infrastructure, and to propose and evaluate runtime techniques and optimizations that can be incorporated into a common optimization infrastructure for static and dynamic Languages. We discuss three extensions to the compiler to support dynamically Typed Languages: (1) simplification of control flow graphs, (2) mapping of memory locations to stack-allocated variables, and (3) reduction of runtime overhead using Language semantics. We also propose four new optimizations for Python in (2) and (3). These extensions are effective in reduction of compiler working memory and improvement of runtime performance. We present a detailed performance evaluation of our approach for Python, finding an overall improvement of 1.69x on average (up to 2.74x) over our JIT compiler without any optimization for dynamically Typed Languages and Python.
-
a study of devirtualization techniques for a java just in time compiler
Conference on Object-Oriented Programming Systems Languages and Applications, 2000Co-Authors: Kazuaki Ishizaki, Motohiro Kawahito, Toshiaki Yasue, Hideaki Komatsu, Toshio NakataniAbstract:Many devirtualization techniques have been proposed to reduce the runtime overhead of dynamic method calls for various object-oriented Languages, however, most of them are less effective or cannot be applied for Java in a straightforward manner. This is partly because Java is a Statically-Typed Language and thus transforming a dynamic call to a static one does not make a tangible performance gain (owing to the low overhead of accessing the method table) unless it is inlined, and partly because the dynamic class loading feature of Java prohibits the whole program analysis and optimizations from being applied.We propose a new technique called direct devirtualization with the code patching mechanism. For a given dynamic call site, our compiler first determines whether the call can be devirtualized, by analyzing the current class hierarchy. When the call is devirtualizable and the target method is suitably sized, the compiler generates the inlined code of the method, together with the backup code of making the dynamic call. Only the inlined code is actually executed until our assumption about the devirtualization becomes invalidated, at which time the compiler performs code patching to make the backup code executed subsequently. Since the new technique prevents some code motions across the merge point between the inlined code and the backup code, we have furthermore implemented recently-known analysis techniques, such as type analysis and preexistence analysis, which allow the backup code to be completely eliminated. We made various experiments using 16 real programs to understand the effectiveness and characteristics of the devirtualization techniques in our Java Just-In-Time (JIT) compiler. In summary, we reduced the number of dynamic calls by ranging from 8.9% to 97.3% (the average of 40.2%), and we improved the execution performance by ranging from -1% to 133% (with the geometric mean of 16%).
Romain Robbes - One of the best experts on this subject based on the ideXlab platform.
-
On the reaction to deprecation of clients of 4 + 1 popular Java APIs and the JDK
Empirical Software Engineering, 2018Co-Authors: Anand Ashok Sawant, Romain Robbes, Alberto BacchelliAbstract:Application Programming Interfaces (APIs) are a tremendous resource—that is, when they are stable. Several studies have shown that this is unfortunately not the case. Of those, a large-scale study of API changes in the Pharo Smalltalk ecosystem documented several findings about API deprecations and their impact on API clients. We extend this study, by analyzing clients of both popular third-party Java APIs and the JDK API. This results in a dataset consisting of more than 25,000 clients of five popular Java APIs on GitHub, and 60 clients of the JDK API from Maven Central. This work addresses several shortcomings of the previous study, namely: a study of several distinct API clients in a popular, Statically-Typed Language, with more accurate version information. We compare and contrast our findings with the previous study and highlight new ones, particularly on the API client update practices and the startling similarities between reaction behavior in Smalltalk and Java. We make a comparison between reaction behavior for third-party APIs and JDK APIs, given that Language APIs are a peculiar case in terms of wide-spread usage, documentation, and support from IDEs. Furthermore, we investigate the connection between reaction patterns of a client and the deprecation policy adopted by the API used.