KR101088515B1 - Computer readable recording medium having install-time compiler program for embedded system - Google Patents

Abstract

The present invention relates to an install-time compiler for an embedded Java system, and more specifically, (1) a class file and a resource file that uses only application memory (M _app ) and is included in an input Jar file input from the outside. An application program reader for reading the list; (2) a class file reader / byte code verification unit which uses only application program memory (M _class ) and reads class files and verifies byte codes; (3) Perform a conversion operation using a method memory (M _method ), and if a byte code that accesses a reference to be optimized is encountered during conversion, a reference list is created in the application memory (M _app ), and the application memory ( A bytecode conversion unit generating a code by referring to a reference list of M _app ); (4) a class data structure / runtime function unit using only class memory (M _class ) and storing class data structures and runtime functions verified from the file reader / bytecode verification unit; (5) a binding / relocation unit that uses only application program memory M _app and modifies the generated code through a binding and relocation process to be executed on a platform; (6) a binary file generation unit using only an application memory M _app and generating a class file transmitted from the binding / relocation unit as a binary file; And (7) using only an application program memory (M _app ), and including a jar compressing unit for compressing the binary file generated by the binary file generating unit into an output Jar file and transmitting it to a Java virtual machine. .
According to the install-time compiler for the embedded system proposed in the present invention, the optimization of the install-time compiler based on the analysis of the application through the optimization of the reference access optimization and the memory usage, thereby implementing an optimization that is difficult to implement. This enables high memory efficiency, especially for embedded systems with low memory.

Description

COMPUTER READABLE RECORDING MEDIUM HAVING INSTALL-TIME COMPILER PROGRAM FOR EMBEDDED SYSTEM}

The present invention relates to an install-time compiler for an embedded Java system, and more particularly to an install-time compilation for an embedded Java system that can increase the efficiency of reference access optimization and memory usage.

Recently, a Java execution device has been used in various embedded systems. Java enabled devices are not only adopted by popular mobile phones, but are also widely adopted as standardization standards for digital television (Television) and Blu-ray.

As such, there is a problem that Java in a built-in system is slow in performance. There is a Java just-in-time compiler (JIT compiler). However, due to the limited hardware resources of embedded systems, it is difficult to achieve satisfactory performance with this technique alone, and additional optimization techniques have been proposed.

Additional optimization techniques other than the JIT compiler include the Ahead-Of-Time Compiler (AOTC), which precompiles outside of the embedded device, and at the time the Java executable is installed on the embedded device. In other words, there is a Java Install-Time Compiler that precompiles before running the application. Each technique has different advantages and disadvantages and complements each other.

1 is a view showing a comparison of the configuration of three compilers (compile method) for an embedded system.

First, the Java JIT compiler (compile method) uses runtime information to convert the code optimized for the platform while executing a Java application on the client side, as shown in FIG. Although it can be done, if the execution time is wasted because the Java JIT compiler is running during the execution of Java, there is a problem that much time cannot be used for optimization. In addition, the Java JIT compiler also has a problem in that response time is unpredictable because code conversion is performed while an application is running.

Next, the Java AOT compiler (compilation method) does not have any runtime problem like the Java JIT compiler because it is precompiled on the server side rather than the client side as shown in FIG. Binary files are platform-dependent and can't maintain platform independency, one of Java's strengths, and are only used in some limited environments.

Finally, in the case of the Java install-time compiler (compile method), as shown in Fig. 1, the conversion is performed on the client side like the Java JIT compiler, but before the application is executed, the conversion is performed in advance. While maintaining platform independence, many optimizations can be performed without worrying about wasting execution time, and response time during application execution is predictable. However, there is still a problem that an additional space for storing the binary file, which is the result of the conversion by the install-time compiler, is needed, and optimization using runtime information is not applicable.

The present invention is proposed to solve the above problems of the conventionally proposed methods, and it is difficult to implement by optimizing the install-time compiler through the optimization considering the reference access and the memory usage based on the application analysis. Its purpose is to provide an install-time compiler that enables the implementation of optimizations and, in particular, improves the memory efficiency of low-memory embedded systems.

According to a feature of the present invention for achieving the above object, an install-time compiler for an embedded Java system,

(1) an application program reader unit using only an application program memory M _app and reading a list of class files and resource files included in an input Jar file input from the outside;

(2) a class file reader / byte code verification unit which uses only application program memory (M _class ) and reads class files and verifies byte codes;

(3) Perform a conversion operation using a method memory (M _method ), and if a byte code that accesses a reference to be optimized is encountered during conversion, a reference list is created in the application memory (M _app ), and the application memory ( A bytecode conversion unit generating a code by referring to a reference list of M _app );

(4) a class data structure / runtime function unit using only class memory (M _class ) and storing class data structures and runtime functions verified from the file reader / bytecode verification unit;

(5) a binding / relocation unit that uses only application program memory M _app and modifies the generated code through a binding and relocation process to be executed on a platform;

(6) a binary file generation unit using only an application memory M _app and generating a class file transmitted from the binding / relocation unit as a binary file; And

(7) It uses the application program memory (M _app ) only, and comprises a Jar compression unit for compressing the binary file generated by the binary file generating unit to an output Jar file to transmit to the Java virtual machine.

Preferably, the bytecode conversion unit,

The application memory (M _app) if the reference is a new reference access is not in the list out, the application memory add the new reference (M _app) of

Preferably, the bytecode conversion unit,

An IR generation / optimizer for converting byte codes inputted from the file reader / byte code verification unit into IR and performing optimization;

A register allocating unit arranged at a rear end of the IR generation / optimizing unit to allocate a register; And

It may be disposed after the register allocation unit, and may include a code generation unit for generating a code.

According to the install-time compiler for the embedded system proposed by the present invention, the optimization of the install-time compiler based on the analysis of the application through the optimization of the reference access optimization and the memory usage, thereby implementing an optimization that is difficult to implement. This enables high memory efficiency, especially for embedded systems with low memory.

BRIEF DESCRIPTION OF THE DRAWINGS The figure which compares and shows the structure of three compilers (compile method) for embedded systems.
2 illustrates the configuration of an install-time compiler for an embedded system, in accordance with an embodiment of the present invention.
3 is a graph comparing performance differences before and after sharing a reference in an install-time compiler (compiler method) according to an embodiment of the present invention.
FIG. 4 illustrates a ratio of increasing a size of a file in which a data structure for reference access is generated in an install-time compiler (compiler method) according to an embodiment of the present invention, compared with before and after removing duplicate references. graph.
5 is a graph showing the ratio of the maximum memory usage of the install-time compiler proposed in the present invention to the maximum memory usage when running the application program.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings.

2 is a diagram illustrating a configuration of an install-time compiler for an embedded system according to an exemplary embodiment of the present invention. As shown in FIG. 2, the install-time compiler 200 for an embedded system according to an exemplary embodiment of the present invention may include an application program reader 205, a class file reader / byte code verifier 210, and a byte. The code conversion unit 220, the class data structure / runtime function unit 260, the binding / relocation unit 230, the binary file generation unit 240, and the Jar compression unit 250 may be configured.

The application program reader 205 reads a list of class files and resource files included in an input Jar file input from the outside.

The class file reader / byte code verification unit 210 reads class files from an input Jar file input from the outside and verifies the byte code. In the install-time compiler 200 according to an embodiment of the present invention, the external input file assumes a Jar file, but is not limited thereto. Jar files contain various resources (resource files) such as application programs, class files, and other images.

The bytecode converter 220 performs IR conversion and optimization on the bytecode input from the class file reader / bytecode verifier 210, allocates a register, and generates a code. At this time, when the bytecode conversion unit 220 in the present invention is to use the method memory (M _method), to meet the bytecodes that access to the reference of the transformation refer to the list of application memory (M _app) by the code and generating, when a new access is not referenced in the reference list of the application memory (M _app) come out, and add a new reference to an application memory (M _app). That is, instead of using the method memory (M _method ) for reference access in the bytecode conversion unit 220, do not create a separate reference list for each method or class file by referring to the reference list of the application memory (M _app ). Is not an important feature of the present invention.

As shown in FIG. 2, the bytecode conversion unit 220 converts the bytecode input from the file reader / bytecode verification unit 210 into an IR and performs an optimization of the IR generation / optimization unit 222. ), A register allocating unit 224 disposed at the rear end of the IR generation / optimizing unit 222 to allocate a register, and a code generating unit 226 arranged at the rear end of the register allocating unit 224 to generate a code. It can be configured as.

The class data structure / runtime function unit 260 stores class data structures and runtime functions verified from the file reader / byte code verifier 210. At this time, the class data structure / runtime function unit 260 uses only class memory (M _class ). That is, in the present invention, the class data structure and the runtime function are not stored using the method memory (M _method ) or the application program memory (M _app ), but only using the class memory (M _class ).

The binding / relocation unit 230 binds and rearranges the code generated by the bytecode conversion unit 220 with reference to the class data structure / runtime function unit 260 so that the class file is executable on the platform. In this case, the binding / relocating unit 230 uses only the application program memory M _app .

The binary file generator 240 generates a class file transmitted from the binding / relocator 230 as a binary file, and the binary file generated by the binary file generator 240 is output from the jar compressor 250. It is compressed into a Jar file and sent to the Java virtual machine. Like the binding / relocating unit 230, the binary file generating unit 240 and the jar compressing unit 250 use only the application program memory M _app .

Hereinafter, the matters to be considered in the implementation of the install-time compiler will be described in detail. Based on this, the install-time compiler according to an embodiment of the present invention will be implemented and the performance thereof will be evaluated. Specifically, in relation to the install-time compiler, the application program is analyzed for efficient code generation, and the characteristics of reference access optimization and memory usage are considered as follows.

1. Analysis of the application

The present invention proposes methods for implementing an efficient install-time compiler (compile method) by analyzing nine applications described in Table 1 below. Looking at the nine analyzed applications listed in Table 1 below, the first three applications, armflo, manyballs, and midpman, accept user input and consist of 3D applications, 2D applications, and games, respectively. In addition, the remaining six applications consisted of five performance measurement applications selected from JKernelmark and EEMBC, which are widely used when measuring the performance of embedded Java virtual machines, as shown in Table 1.

Application Explanation armflo 3D application (user input) manyballs 2D application (user input) midpman Multithreaded game (user input) JKernelMark Includes six performance small test codes chess Automatic Chess Game Simulation (EEMBC) crypto Various encryption decryption (EEMBC) kxml XML parsing (EEMBC) parallel Multithreaded Program (EEMBC) png PNG image file decoding (EEMBC)

2. Reference Access Optimization

In addition to traditional optimization techniques, the information available to the install-time compiler is that the embedded system knows the entire Java application downloaded. Java applications are written in Java bytecode that the Java virtual machine understands, and method invocations and references are used to find and execute actual methods and references with names and types when executed in the Java virtual machine. The install-time compiler recognizes that Java applications run on the Java virtual machine embedded in the embedded system, and that method calls and references are made within the mode application and the Java virtual machine. Therefore, the install-time compiler can generate optimized code by interpreting method calls and references in the application to be converted based on the recognized information, and the generated code can improve performance. Before actually applying this optimization, let's measure the ratio of references in the application selected above and see the possibilities.

Table 2 below shows the percentage of the total number of bytecodes measured by the number of bytecodes to which each kind of reference is actually accessed. In Table 2, sm is the ratio of bytecodes to accessing static methods in the total number of bytecodes, and vm is the ratio of bytecodes to accessing virtual methods in the total number of bytecodes. im is the ratio of bytecodes accessing the interface method to the total number of bytecodes, sf is the ratio of bytecodes accessing the static field to the total number of bytecodes, and if is total bytes The ratio of bytecodes accessing an interface field to the number of codes is measured, respectively. Looking at Table 2, you can see that Java applications have a lot of references.

program Class s.m v.m. i.m. s.f. i.f. armflo 27.3 4.0 5.4 0.0 0.9 9.9 manyballs 35.2 2.5 6.9 0.0 2.4 16.5 midpman 11.2 0.3 1.5 0.0 0.0 9.0 JKernelMark 35.8 4.6 7.9 0.8 0.9 11.4 chess 29.4 3.6 5.6 0.0 0.2 12.9 crypto 11.0 2.1 1.4 0.1 0.6 2.8 kxml 38.4 5.0 12.2 0.1 0.4 10.3 parallel 4.0 0.6 0.8 0.0 0.1 1.2 png 27.6 4.8 5.3 0.0 0.3 8.6

In particular, if you add up the proportions of the individual references, you can see that the application kxml has a very high proportion of references. However, we measured this because many references actually access the same reference from multiple bytecodes. In fact, the measurements were repeated except for duplicates of the above references. Table 3 below shows the rate at which each reference accesses different references except duplicate references.

program Class s.m v.m. i.m. s.f. i.f. armflo 1.8 5.2 22.9 0.0 25.0 16.2 manyballs 5.5 51.9 52.0 0.0 19.2 16.2 midpman 2.0 57.9 31.4 0.0 0.0 10.8 JKernelMark 4.8 24.3 34.4 0.0 14.3 16.8 chess 2.8 7.4 27.6 100.0 23.8 15.5 crypto 3.5 8.5 33.9 4.5 21.2 16.9 kxml 3.3 13.3 23.9 100.0 26.1 18.9 parallel 5.4 15.9 27.0 100.0 27.8 26.5 png 4.5 12.4 27.4 100.0 25.0 19.4

Looking at Table 3, several features can be found.

First, less than 5% of the class accesses that are very common in Java applications actually access other classes. This means that, on average, about 20 class accesses are redundant, and the classes actually used in the program are very limited.

On the other hand, accessing methods and fields has relatively little duplication, which is understood by the fact that there are many ways to access methods and fields in languages such as Java that support Object Oriented Programming. It is a part.

Lastly, the interface method (im) is rarely used in the above program, and there is one case of 100% of the application chess, and there are relatively many interface method accesses such as application crypto. There were many cases of duplicates, as in the case of accessing other references.

With this analysis, we can reduce the overhead caused by duplication by applying the deduplication of each reference in the install-time compiler (compilation method). The overhead of duplicating Java applications is as follows.

First, each reference in a Java program finds the memory address of the reference that it actually accesses when loading the class in the Java virtual machine and at runtime. However, even if the same reference is accessed from different bytecodes during execution, this method finds the memory address of the actual reference every byte, which may cause performance degradation. You can improve performance by avoiding looking back the memory address of the reference once found.

Also, because Java applications look up references by name and type, they have the name and type of the reference as a string in the class file. These strings are stored in the constant pool area of class files, and because they are stored as strings, they require more file space than relatively simple memory addresses. Of course, class files save space by allowing duplicate names and types of references within a class to share a single string. However, since the names and types of duplicate references in different classes cannot be shared, if the names and types are also shared in the different classes in the present invention, space can be additionally saved.

And finally, you can save additional memory space by sharing the address range of the same references.

3. Memory usage

In addition to the performance of Java applications converted by the install-time compiler, the install-time compiler itself must run on a low-memory embedded system, so you must consider the memory usage of the install-time compiler itself. In general, compilers with optimizations generate a variety of analysis and extensive intermediate representations while working on code generation. When analyzing the entire application to optimize the above-mentioned reference approaches, the memory usage is further increased. Therefore, the compiler (compilation method) proposed in the present invention separates the optimizations and the individual optimizations that must analyze all classes such as reference access optimization, so that the memory usage does not become larger than necessary.

Looking at the concrete method, the first part of the entire Java application is to read the classes one by one, storing only the references to be optimized in a save list where the memory address can be obtained later, and defer the optimization. At the same time, the methods belonging to one class read are converted into method units and applied optimization to generate optimized machine code. The machine code thus generated is coded to access the list created earlier for reference accesses. When all selected classes are converted, all memory in use is returned, except for lists and some data structures.

In this way, the maximum memory usage of the install-time compiler is determined by the size of the underlying data structures and lists, and the data structures for the class currently being converted. Of course, in this case, the size of the converting class itself is large, so this part also needs to be converted into method units in two steps, and the memory that is no longer needed is returned.

The conversion steps of the install-time compiler (compile method) proposed by the present invention in terms of memory allocation and return are as follows.

1. Allocate application memory (M _app ) for application optimization

Example: resolve list

2. Allocating class memory (M _class ) for one class

2.1 Select each method in the current class

2.2 Method memory (M _method ) allocation for selected method

2.3 Returning method memory (M _method ) for completed methods

2.4 Go to step 2.1 and repeat the same process for the next method

3. Return class memory (M _class ) after converting current class

4. Go to step 2 and repeat the same process for the next class

5. Return class application memory (M _app ) after converting all classes

In this way, the memory usage M _total at any one time of the install-time compiler (compile method) proposed by the present invention may be determined as in Equation 1 below.

In addition, the maximum memory usage will be determined by the method memory (M _method ) used for relatively large optimizations and intermediate representation (Intermediate Representation) generation, class memory (M _class ) and method memory (M _method ) Because it is affected by classes and methods, it must be verified by experiment after actual implementation.

4. Experiment and Evaluation

The install-time compiler (compilation method) applying the reference access optimization and the efficient memory usage scheme proposed in the present invention is implemented in J2ME (Java2 Micro edition) CLDC / MIDP environment. The microprocessor executed is ARM7, and the code was generated using Thumb ISA. In the experiment, we evaluated the install-time compiler (compile method) proposed in the present invention using the Java applications analyzed above.

3 to 5 are graphs illustrating performance of an install-time compiler (compiler method) for an embedded Java system according to an embodiment of the present invention.

First, FIG. 3 is a graph comparing performance differences before and after sharing a reference in an install-time compiler (compiler method) according to an embodiment of the present invention. The horizontal axis represents each application program, and the vertical axis represents the performance improvement rate. Here, armflo, manyballs, and midpman, Java applications whose behavior depends on user input, did not measure performance. Instead, we measured five small benchmarks of the Java application JKernelmark separately. From FIG. 3, it can be seen that when the install-time compiler (compile method) proposed in the present invention is applied, a 5% performance improvement can be obtained by geometric mean, which is purely in the reference access bytecode. This is a performance improvement that can be achieved by sharing the memory address found. However, in benchmarks such as logic where simple computations determine performance, the performance gains are relatively small.

Next, FIG. 4 shows a ratio of increasing the size of a file in which a data structure for reference access is generated in an install-time compiler (compiler method) according to an embodiment of the present invention. It is a graph shown in comparison. In Fig. 4, the horizontal axis represents each application program, and the vertical axis represents the overhead ratio. Also, the black graph shows the size of the file in which the data structure before deduplication is created, and the comb graph shows the size of the file in which the data structure after deduplication is created. From FIG. 4, the size of the file is increased by 2 to 6.4% before the deduplication of the reference, whereas after sharing the duplicated references through the reference optimization, the size of the file is increased by only 1 to 3%. . Looking at the details of increasing file size, after eliminating redundancy, the size of the table to access the reference has been significantly reduced to within 1%. However, an additional data structure is needed to remove duplicates, which results in a file size increase of 1 to 3%. In summary, the benefits of eliminating duplicate references are even greater, reducing the file size. This has the same effect on code memory usage during execution.

Finally, by measuring the memory usage during the conversion of the install-time compiler, it was confirmed whether the install-time compiler implemented according to an embodiment of the present invention can operate in the embedded system. To this end, we compared the maximum amount of in-memory memory used by an interpreter-based Java virtual machine to run an application program, and the maximum memory used by the install-time compiler proposed by the present invention during conversion. Through this comparison, it is possible to show that the install-time compiler proposed in the present invention can complete the conversion without a memory problem in an environment that can be actually executed by the corresponding application. 5 is a graph showing the ratio of the maximum memory usage of the install-time compiler proposed by the present invention to the maximum memory usage when the application program is executed. The horizontal axis represents each application program and the vertical axis represents the ratio of memory usage. From FIG. 5, it can be seen that the install-time compiler proposed by the present invention uses the memory within 25.5% of the maximum runtime at the time of executing each application program. From these results, the install-time proposed by the present invention is suggested. It was clear that the compiler could work on an embedded Java system.

The present invention described above may be variously modified or applied by those skilled in the art, and the scope of the technical idea according to the present invention should be defined by the following claims.

200 : install-time compiler
205: application reader unit
210: class file reader / byte code verification unit
220: byte code conversion unit
260: class data structure / runtime function unit
230: binding / repositioning unit
240: binary file generator
250: Jar compression unit

Claims (3)

In a computer-readable recording medium recording an install-time compiler program for an embedded Java system,
(1) Use only application memory (M _app ) (where 'use' means to store (write) to memory or to reference (read) memory), input Jar file input from outside An application program reader unit for reading a list of class files and a list of resource files included in the list;
(2) a class file reader / byte code verification unit using only application program memory (M _app ) and reading class files contained in the input Jar file input from the outside and verifying byte codes;
(3) Using a method memory (M _method ), performing a conversion operation on the bytecode verified by the class file reader / bytecode verification unit, and when encountering a bytecode that accesses a reference to be optimized (optimized) during conversion. the application memory (M _app) to create a reference to the list, the number of bytes to generate a code with reference to a reference list of the application memory (M _app) code converter;
(4) a class data structure / runtime function unit that uses only class memory (M _class ) and stores class data structures and runtime functions of the class file verified by the file reader / bytecode verification unit;
(5) a binding / relocation unit that uses only application program memory M _app and modifies the generated code through a binding and relocation process to be executed on a platform;
(6) a binary file generation unit using only an application memory M _app and generating a class file transmitted from the binding / relocation unit as a binary file; And
(7) an embedded Java system using only an application program memory (M _app ) and including a Jar compression unit for compressing the binary file generated by the binary file generation unit into an output Jar file and transmitting the result to a Java virtual machine. A computer-readable recording medium having recorded thereon an install-time compiler program.
The method of claim 1, wherein the bytecode conversion unit,
When a new reference approach is not in the reference list of the application memory (M _app) come out, the application memory installed for embedded Java systems which comprises adding a new reference to the (M _app) - Time compiler program Computer-readable recording medium.
The method of claim 1, wherein the bytecode conversion unit,
An IR generation / optimizer for converting byte codes inputted from the file reader / byte code verification unit into IR and performing optimization;
A register allocating unit arranged at a rear end of the IR generation / optimizing unit to allocate a register; And
And a code generating unit arranged at a rear end of the register allocating unit to generate a code. The computer-readable recording medium recording an install-time compiler program for an embedded Java system.

Images