• The Korean Journal of Applied Statistics
• /
• v.33 no.6
• /
• pp.665-682
• /
• 2020

This paper introduces numba library in Python, which improves computational efficiency of the provided implemented code written by naive Python language by applying just-in-time (JIT) compilation. To apply just-in-time compilation, the numba only needs to use a decorator on a target Python function. We provide implementation examples with numba for the permutation test and the parameter estimation for Gaussian mixture distribution. We also numerically show the efficiency of numba by comparing the total computation times of the implementation using naive python and the implementation using numba for each application.

• Journal of KIISE:Software and Applications
• /
• v.32 no.12
• /
• pp.1283-1291
• /
• 2005

One of the problems in boosting Java performance using a Just-in-Time (JIT) compiler is removing redundant array bound checks. In conventional static compilers, many powerful algorithms have been developed, yet they are not directly applicable to JIT compilation where the compilation time is part of the whole running time. In the current JIT compilers, we tan use either a naive algorithm that is not powerful enough or an aggressive algorithm which requires the transformation into a static single assignment (SSA) form of programs (and back to the original form after optimization), thus causing too much overhead not appropriate for JIT compilation This paper proposes a new algorithm based on an inequality graph which can eliminate array bounds check codes aggressively without resorting to the SSA form. When we actually perform this type of optimization, there are many constraints in code motion caused by the precise exception rule in Java specification, which would cause the algorithm to miss many opportunities for eliminating away bound checks. We also propose a new method to overcome these constraints.

• Proceedings of the Korean Information Science Society Conference
• /
• 2006.06a
• /
• pp.217-219
• /
• 2006

내장형 시스템에서 많이 채택되고 있는 자바 가상 머신의 성능을 향상시키기 위해 interpreter. just-in-time 컴파일러 (JITC), ahead-of-time 컴파일러 (AOTC) 세가지 방식을 모두 지원하는 자바 가상 머신을 설계하고 구현하였다. 특히 이런 환경을 지원하기 위한 효율적인 JITC와 시스템의 idle 시간에 JITC모듈을 활용하기 위한 client-AOTC의 설계와 구현에 대해 살펴보고 현재까지의 실험 결과를 보고한다.

• Journal of KIISE:Software and Applications
• /
• v.32 no.3
• /
• pp.215-226
• /
• 2005

Loop invariant code motion (LICM) optimization includes relatively heavy code analyses, thus being not readily applicable to Java Just-In-Time (JIT) compilation where the JIT compilation time is part of the whole running time. 'Classical' LICM optimization first analyzes the code and constructs both the def-use chains and the use-def chains. which are then used for performing code motions. This paper proposes a light-weight LICM algorithm, which requires only the def-use chains of loop invariant code (without use-def chains) by exploiting the fact that the Java virtual machine is based on a stack machine, hence generating code with simpler patterns. We also propose two techniques that allow more code motions than classical LICM techniques. First, unlike previous JIT techniques that uses LICM only in single-path loops for simplicity, we apply LICM to multi-path loops (natural loops) safely for partially redundant code. Secondly, we move loop-invariant, partially-redundant null pointer check code via predication support in Itanium. The proposed techniques were implemented in a JIT compiler for Itanium processor on ORP (Open Runtime Platform) Java virtual machine of Intel. On SPECjvrn98 benchmarks, the proposed technique increases the JIT compilation overhead by the geometric mean of 1.3％, yet it improves the total running time by the geometric mean of 2.2％.

• Journal of KIISE:Software and Applications
• /
• v.32 no.7
• /
• pp.683-692
• /
• 2005

Java specification states that all accesses to an object must be checked at runtime if object refers to null. Since Java is an object-oriented language, object accesses are frequent enough to make null pointer checks affect the performance significantly. In order to reduce the performance degradation, there have been attempts to remove redundant null pointer checks. For example, in a Java environment where a just-in-time (JIT) compiler is used, the JIT compiler removes redundant null pointer check code via code analysis. This paper proposes a technique to remove additional null pointer check code that could not be removed by previous JIT compilation techniques, via early null pointer check using an architectural feature called predication. Generally, null point check code consists of two instructions: a compare and a branch. Our idea is moving the compare instruction that is usually located just before an use of an object, to the point right after the object is defined so that the total number of compare instructions is reduced. This results in reduction of dynamic and static compare instructions by 3.21$\%$ and 1.98$\%$. respectively, in SPECjvm98 bechmarks, compared to the code that has already been optimized by previous null pointer check elimination techniques. Its performance impact on an Itanium machine is an improvement of 0.32$\%$.

• KIPS Transactions on Computer and Communication Systems
• /
• v.2 no.6
• /
• pp.231-236
• /
• 2013

Recently, to improve the user response times of Android applications, several studies have been proposed to combine the idea of Ahead-of-Time compilation into Dalvik virtual machine, which uses Just-in-Time compilation. The studies, however, require modifications of the Dalvik executables of target applications, thus are difficult to be adopted for legacy applications already deployed. This paper proposes a JITwP(JIT with Precompile) technique that precompiles hot traces at application launch time with no modification of the Dalvik executable. It improves the user response times of target applications by providing precompile hints prepared offline. Our experimental results demonstrate a 4% improvement in terms of execution time for the Web browser application.

• Proceedings of the Korean Information Science Society Conference
• /
• 2010.11a
• /
• pp.13-14
• /
• 2010

• Journal of KIISE:Computing Practices and Letters
• /
• v.16 no.8
• /
• pp.868-872
• /
• 2010

Many embedded Java systems are equipped with limited memory, which can constrain the code cache size provided for Java just-in-time compilation, affecting the Java performance. This paper proposes expanding the limited code cache when it is full, by saving the machine code for some methods in the code cache into the file system of the permanent storage and reloading it to the code cache when they are re-invoked later. This is applying the client ahead-of-time compilation during the execution time for the purpose of enlarging the code cache. Our experimental results indicate that the proposed execution method can improve the performance by as much as 1.6 times compared to the conventional method, when the code cache size is reduced by half.

• Journal of Software Engineering Society
• /
• v.28 no.1
• /
• pp.1-6
• /
• 2019

Google released an initial version of Android that runs Dex(Dalvik Executable) through the Dalvik Runtime. Since Dalvik Runtime is based on interpreter, JIT(Just-in-time) compilation has been applied to improve performance. After Lollipop(Android 5.0) Dalvik Runtime has replaced with ART Runtime which support AOT (Ahead-of-time) compilation of Dex into Native Code. The late st Android has a problem that the application execution speed is slow until the AOT compilation is completed according to the actual usage record after the installation of the app. To improve the problem we have investigate the characteristics of profile that can improve the execution speed of the application and generate the profile automatically. Finally we propose a method that can optimize the application at install time. With the proposed method we can optimize selectively at install time and can help improving the execution speed of the app from the initial execution.

• The Korean Journal of Archival Studies
• /
• no.4
• /
• pp.93-130
• /
• 2001

Chosen General Government initiated the activities of collecting and managing the archives from Chosen Dynasty because of necessity to push positively for its colonial policies. Particularly, such efforts of the regime resulted eventually in boosting their understanding on the Korea cultures, as well as contributed to their reigning Korea to an extent. Some aspects that reflect it are as follows. In 1910 Chosen General Government took over, and began to arrange and classify huge volumes of archives that were held by the royal family. During this period, they collected and arranged literatures that they took over from the earlier Korean government. In 1913, Chosen General Government increased enormously the varieties and volumes of the archives that they intended to collect. They started with collecting archives limited to those literatures that had existed in the civil sector before 1894. It can be noticed that just in 1913 Chosen General Government revealed their intention to collect and classify both royal archives and civil archives. With the work of collecting, classification and annotating archives, Chosen General Government commenced the compilation of Chosensa (Korean History). These efforts aimed at cultural assimilation and educating of Korean people, and in this process, the importance of Chosen Dynasty's archives was reconfirmed. One of the representative cases was a change of terminology. With the compilation efforts into full swing since 1915, Chosen General Government repeatedly started to use the term 'Saryo' (historical records) in connection with Chosen's literatures and archives. The term 'Saryo' previously had been used in Japanese literatures, and it is deemed that it was used as a term generally referring to archives of Chosen Dynasty from that time. This signifies that Chosen General Government began to involve their historical point of view in approaching to the archives of Chosen. As they broadened their understanding on Korea through the annotation of old literatures and compilation of Chosen History, they seriously set on the work of assimilating Korean people culturally aiming at gripping its reign on Korea. Archives of Chosen likewise were very crucial basic data for understanding Korea and its people, and Chosen General Government is deemed to have utilized the archives as a means to reign and assimilate Korean people.