Classifications

• • G—PHYSICS
  • G06—COMPUTING; CALCULATING OR COUNTING
  • G06F—ELECTRIC DIGITAL DATA PROCESSING
  • G06F8/00—Arrangements for software engineering
  • G06F8/40—Transformation of program code
  • G06F8/41—Compilation
  • G06F8/44—Encoding
  • G06F8/443—Optimisation
• • G—PHYSICS
  • G06—COMPUTING; CALCULATING OR COUNTING
  • G06F—ELECTRIC DIGITAL DATA PROCESSING
  • G06F8/00—Arrangements for software engineering
  • G06F8/40—Transformation of program code
  • G06F8/41—Compilation
• • G—PHYSICS
  • G06—COMPUTING; CALCULATING OR COUNTING
  • G06F—ELECTRIC DIGITAL DATA PROCESSING
  • G06F8/00—Arrangements for software engineering
  • G06F8/40—Transformation of program code
  • G06F8/52—Binary to binary
• • G—PHYSICS
  • G06—COMPUTING; CALCULATING OR COUNTING
  • G06F—ELECTRIC DIGITAL DATA PROCESSING
  • G06F9/00—Arrangements for program control, e.g. control units
  • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
  • G06F9/44—Arrangements for executing specific programs
  • G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
  • G06F9/45504—Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
  • G06F9/45516—Runtime code conversion or optimisation

Definitions

• the present invention relates to the field of compilation of programs or software applications.
• the present invention relates more particularly to the compilation of programs or software applications in heterogeneous environments.
• a computer program, or a software application is generally composed of a set of binary or intermediate instructions said executable.
• These executable instructions are usually derived from a compilation of a program written in a source language.
• a developer writes a source program written in a specific programming language.
• This source program is then compiled to form an executable program.
• the instructions written in source language are transformed into a binary program which is itself executed on a hardware platform such as a computer, a communication terminal.
• Figure 1 describes the general principle of a virtual machine-based code execution technique.
• the source code 100 is compiled to an intermediate code 102 by the compiler 101.
• This code is then executed on a virtual machine 103, itself running on the operating system 104, itself running on a platform 105. Since the intermediate code must be able to run on any platform with a virtual machine adapted to the intermediate code, it is not optimized.
• the first technique is to compile the intermediate code dynamically. It is referred to as dynamic compilation.
• the virtual machine includes a compiler capable of dynamically compiling intermediate bits of code into binary, and also includes a mechanism for dynamically executing the binary code generated by this compiler in place of the original intermediate code.
• the execution of the application consists of a mixture of intermediate code and dynamically generated binary code.
• JIT just in time
• DAC dynamic adaptive compiler
• Just In Time usually has a compilation granularity to the method (it can only compile entire methods). It carries out the compilation in binary code of the method to be executed during the first execution of the method.
• the dynamic adaptive compiler implements another strategy. It executes the application by the virtual machine and dynamically determines the parts of code penalizing the performance of the application. These parts are called hot spots of the application.
• Each DAC has its own hotspot detection strategy. For example, the most frequently executed methods, or methods that include loops, or methods that take the most time to execute. Once this identification is made, it compiles hot spots in binary code. Then, the virtual machine executes the binary code of the hotspots.
• a source software application (100) is written by an application developer.
• This source program includes computer program instructions written in a source programming language.
• the source program (100) undergoes a first compilation phase by a compiler (101) which results in its transformation into an intermediate program (102).
• This intermediate program (102) is executed by a virtual machine (103) that runs over a binary operating system (104), which is based on a hardware platform (105).
• the virtual machine (103) is coupled to a dynamic compiler (106) that dynamically determines and compiles bit code intermediate code portions within a binary code buffer (107).
• the virtual machine (103) also includes means for executing a binary version of an intermediate code, if it exists, in order to increase the performance of the application.
• a dynamic compiler takes time to execute in addition to the application both to determine hotspots, and when compiling the intermediate code in binary code. Indeed, to realize the identification of the hot spots, an instrumentation of the interpreter of the virtual machine is usually performed in order to monitor the behavior of the application. These instrumentations penalize the performance of the application. Concerning the compiler, in order to limit their compilation time, the optimizations realized by these compilers are simple and can not be aggressive. This will limit the performance of the generated binary code compared to a compiler that runs upstream of the execution. Then, these solutions use temporary memory to store the generated binary codes.
• this code is stored in a limited memory area, and the compiler must therefore make continuous choices to determine which are the correct binary codes to keep in this buffer. This results in a performance problem of these dynamic compilers as they manage many applications, or the size of this memory area is small.
• the second technique of optimizing the performance of the intermediate code is to make the virtual machine faster on the chosen target. This optimization can be done by optimizing the virtual machine so that it exploits as much as possible the capabilities of the processor that uses it. It can also be done through additional specific hardware support. It can also be achieved by the specific algorithm design to increase the performance of the virtual machine on the target.
• the invention does not include these disadvantages of the prior art. Indeed, the invention relates to a method of compiling a software application intended to execute within a virtual machine of a hardware platform, said software application originally being in the form of a set of compile.
• such a method comprises a phase of selective compilation of said set of codes to compile delivering a compiled application comprising a first application part executed by said virtual machine by using instructions from said virtual machine and a second application part comprising binary instructions. directly executable on said hardware platform.
• the invention makes it possible to optimize the performance of the applications by producing, from a single set of codes, an application consisting of an application part executed by said virtual machine and an application part executed directly by the hardware platform, without using the interpreter of the virtual machine.
• the set of codes to compile consists of files that are written in a single language.
• said set of codes to be compiled is a set of intermediate codes and in that said method comprises a first phase of compiling a set of source codes and delivering said set of intermediate codes used during said phase. selective compilation.
• the invention makes it possible to directly optimize an intermediate code, which has already been the subject of a first compilation, to optimize the execution of this intermediate code.
• said set of codes to be compiled is a set of source codes written in a programming language.
• said selective compilation phase comprises:
• said selective compilation phase furthermore comprises:
• said method further comprises, during said step of compiling said second subset of source code to be compiled, a step of introducing at least one interfacing structure of said second application part with said virtual machine.
• This data structure may for example a JNI type interface ("Java Native Interface").
• this interfacing structure may be a particular structure for making a link with an internal interface, more efficient, of the virtual machine.
• said set of codes to be compiled is a set of Java "ByteCode”.
• said set of codes to be compiled is a set of "ByteCode” Dalvik.
• said set of codes to be compiled is a set of Java codes.
• said method is implemented prior to an execution of said software application within said virtual machine.
• the invention also relates to a device for compiling a software application intended to execute within a virtual machine of a hardware platform, said software application originally being in the form of a set of codes to compile.
• a device for compiling a software application intended to execute within a virtual machine of a hardware platform, said software application originally being in the form of a set of codes to compile.
• such a device comprises means of selective compilation of said set of codes to compile delivering a compiled application comprising a first application part executed by said virtual machine by using instructions from said virtual machine and a second application part comprising binary instructions. directly executable on said hardware platform.
• the invention also relates to a computer program comprising program code instructions for implementing the navigation method as described above, when this program is executed by a processor.
• the invention provides a new and inventive solution to these problems of the prior art. Indeed, the invention proposes a method of automatically and selectively compiling a code written in a source programming language. or intermediate to generate a binary code of the selected parts that can be executed by a virtual machine.
• This virtual machine can complementarily run a dynamic compiler that will compile the intermediate code remaining to run.
• the invention is based on a completely new and inventive approach to compiling software applications for virtual machine-based environments.
• the invention allows the developer to choose precisely what he wants to compile in order to keep control of the use of offline compilation. It also allows to combine the offline compilation approaches and the dynamic compilation approach, with the aim of providing a better performance of execution
• Figure 4 is a block diagram of a compilation device according to the invention.
• the general principle of the invention lies in the combination of a static approach to the compilation, making it possible to create applications optimized computing by performing a compilation (prior to the execution of the application) while maintaining an execution based on the implementation of virtual machines.
• a compilation prior to the execution of the application
• an execution based on the implementation of virtual machines one of the problems of applications that work with virtual machines.
• one of the problems of applications that work with virtual machines is performance.
• the principle behind the use of virtual machines is to allow portability of the intermediate code (from one or more source code compilations) on any hardware platform having a virtual machine capable of executing the virtual code. intermediate code in question.
• the invention thus relates to a compilation technique for virtual machine-based runtime environments that provides a better performance of execution.
• the principle of improving performance relies on moving the execution of some parts of intermediate code in the form of binary code much more powerful, while remaining under the control of execution of the application by the target virtual machine.
• the compilation is based on the source (or intermediate) code of the application.
• the compiler performs code generation comprising two parts: a first set of intermediate code that executes by implementing the virtual machine and a second set of binary code that executes directly by the processor of the hardware platform.
• Figure 3 describes the principle of the invention.
• the invention allows the developer to select (101) from a source code or an intermediate code 100 the code parts to compile in binary code.
• the compiler 102 generates the codes (103, 104, 106 and 107) for executing the code portions chosen by the developer in binary code.
• the generated codes (103, 104, 106 and 107) will be executed by the virtual machine 105, thanks to its binary code execution support 1 16.
• the virtual machine runs over the operating system 108 , itself running on a hardware platform 109.
• the invention allows the developer to choose the pieces of source code to perform with great performance, without additional manual integration operation.
• the integration to the virtual machine is transparent. There is no modification of the virtual machine.
• the performance of the final code depends on the binary code execution support of the virtual machine.
• the integration is compatible with a dynamic compilation solution of a virtual machine. This integration makes it possible to cumulate the performances.
• the binary code can be loaded dynamically, or embedded according to the possibilities of the virtual machine.
• the invention also makes it possible to have different granularities of compilation: method, application, service, APIs, or piece of code.
• the fact of having different granularities of compilation makes it possible to precisely target the parts of code to be accelerated according to the cases.
• the compilation method of the invention is implemented prior to the execution of the application on the platform. Having no resource constraints, the compiler can thus use aggressive optimizations very advanced to generate the binary code or intermediate code that will further improve the performance of the application.
• a set of specific codes linking the two sets is integrated with the two sets of codes generated using a native interface of the virtual machine.
• the use of a native interface positively impacts the degree of performance improvement obtained (depending on the interface used).
• the compiler uses one of the native interfaces available by the virtual machine.
• this native interface can be either the standard native interface of the virtual machine to link with native libraries (for example a JNI interface), or one of the most powerful internal interfaces.
• the dependence between the binary application part and the virtual machine lies in the native interface of the latter. Sometimes this native interface does not need to be modified, sometimes it has to be modified to get the desired performance improvement.
• the compilation method since the compilation method relies on one of the native interfaces of the virtual machine, it makes it possible to keep the object system of the target virtual machine without having to modify it.
• this interfacing structure is in one particular embodiment one or more global variables of the binary application part.
• a global variable includes a pointer that points to an address (in memory) for accessing objects or data structures managed by the virtual machine for the application.
• Another example is when compiling to obtain the set of binary codes, to introduce in it another set of referencing instructions allowing, during the execution of the application, to create an interfacing structure to an array of referencing objects used by the binary application part.
• This object referencing table is part of the data that is managed by the application part. Indeed, during the execution of the application, the objects being shared between the virtual machine and the binary application part, it is necessary that the latter knows the objects that are used by the binary application part to prevent the "garbage" collector "of the virtual machine does not delete objects used by the binary application part. It is therefore necessary that the virtual machine can get acquainted with the objects used by the binary application part within the memory space allocated to the application part.
• the addition, during the generation of code sets, referencing structures allows the virtual machine to ensure that it does not delete objects used by the binary part.
• the use of a second object system making it possible to execute the binary code without having to use the native interface of the virtual machine is also possible in order to improve performance even more.
• the quasi-totality of an application can be compiled into binary code by using a specific object system.
• the set of intermediate codes generated is minimal and allows the virtual machine to perform the minimum of operation required to execute the application such as launching, terminating or suspending the execution of the application on the terminal.
• the basis of the method of compiling a set of source or intermediate code into two sets of codes is automatic.
• the entire process can be completely automatic, or include complementary manual phases.
• the binary code occupies a more important place in memory than the intermediate code. Indeed, it is intended to take into account the memory size constraints of the terminal.
• the method allows, in at least one embodiment, to select the code parts to be compiled.
• the developer of the application masters the code expansion in view of the memory constraints of the target terminal.
• the compiler can also decide for itself the cutting of the codes to be performed using a particular optimization that makes it possible to achieve a memory / performance expansion compromise automatically.
• the method is compatible with an interpreted target virtual machine.
• This virtual machine can also have a dynamic compiler that will improve the performance of the intermediate code.
• the performance improvements are cumulative (initial with the method of the invention and dynamic with the dynamic compiler).
• the method is not restricted to applications and can be used for source or intermediate code of an application, service or library to be executed by the virtual machine.
• the method can be used on all code sets of an application, or a particular code portion, without granularity limit (a class, a method, or a piece of code of a method ).
• the implementation of the invention is presented for an Android TM runtime environment.
• Google's Android TM runtime environment is based on a Linux TM operating system distribution that includes libraries, a virtual machine called Dalvik TM, and intermediate code. This intermediate code includes applications, system services and embedded libraries on the platform. Source codes for applications, services and libraries are written in JAVA TM and compiled into Dalvik TM intermediate code.
• the particularity of Android TM is that it is adapted to the operation of light terminals with, compared to current personal computers, low execution capabilities.
• the Dalvik TM virtual machine has the particularity of being based on a "register-based virtual machines” architecture unlike other virtual machines that are called “stack” (from the "register-based virtual machines”). stack based virtual machines).
• stack-based virtual machines must use the instructions to load data on the stack and manipulate the data, and therefore require more instructions than "register” machines to implement code at the same level, but the instructions in a "register” machine must encode the source and destination registers and, therefore, tend to be larger.
• the compilation chain of Andro ⁇ d TM for the Java language compiles intermediate code java code using two compilers. The first compiles java source code into Java intermediate code (ByteCode Java). The second compiles the java intermediate code (ByteCode Java) into Dalvik intermediate code (.dex file). So we have a chain of two successive compilations to come up with an executable code ".dex" on an Andro ⁇ d TM platform from a source code written in java. In the Android TM platform, to improve performance, the implementation of the invention is as follows:
• the initial java source code CSj is compiled using the java compiler of the Android TM platform to produce a first set of intermediate code (ByteCode Java) Clj, which is, in this embodiment, the code to be compiled.
• the intermediate code Clj is compiled selectively to obtain two distinct sets of code: a first set of source code C / C ++ CSc l and a second set of intermediate code Clj 2.
• the second set of intermediate code CIj2 is compiled into Dalvik TM intermediate code using the compiler available in the Andro ⁇ d TM compilation chain in order to produce the ".dex" application executable on the platform via the Dalvik TM virtual machine.
• the first set of CScl source code including C / C ++ code
• the first set of CScl source code is compiled using the C / C ++ compiler available in the Android TM compilation chain to generate binary code that is in the form of dynamic libraries Linux TM, to produce the second part of the application.
• JNI Java Native Interface
• framework development framework
• Java Byte Code running inside a java virtual machine. call (and be called) by so-called native applications or libraries running in binary code.
• This JNI interface is widely used in Java environments. Also, in order to link the execution of the two types of codes generated (on the one hand the Dalvik TM code and on the other hand the Linux TM dynamic libraries, the compiler of the invention adds specific JNI codes allowing to execute the two parts. Thus, the invention makes it possible to compile Java parts in native code, while keeping intermediate code parts, while linking the execution of the two parts of the application using the Dalvik TM JNI interface. .
• Another implementation of the invention may also consist in using the internal native interface of the Dalvik TM virtual machine to avoid the use of the JNI interface, which itself may pose some performance problems.
• the Dalvik TM virtual machine remains master of the execution and its object execution model remains preserved and used to execute the application.
• This object execution model is in charge of the management of fields, methods, associated memory.
• the invention thus makes it possible to benefit from a high-performance binary code that executes within the virtual machine.
• Each processor of the hardware platform has an associated memory architecture. This can be composed of several levels of memory cache, specific memory (direct access, ROM, ...), additional RAM or flash, different timing frequencies.
• the performance of the processor will be a function of the location of the instructions and data of an application in its memory hierarchy.
• the processor makes it possible to have two memory access channels in parallel. One for the instructions, the other for the data. These two channels are also optimized and calibrated according to the distribution of instructions and data access.
• the intermediate code is considered to be data. Also, all the memory accesses pass through the same channel, which penalizes the operation of the memory architecture and impacts the execution performance.
• Dynamic compilers generate binary code that can be loaded by the instruction channel. Also, they allow to use both channels memory access in parallel. However, this binary code is in a RAM, preventing the use of ROM, resident near the processor.
• the compiler can execute upstream of the integration of the terminal, the binary code can be placed in a read-only memory close to the processor. This allows :
• the invention is in the form of a device capable of implementing the compilation method as described above. Such a device is schematically described in relation to FIG. 4.
• the processing unit 42 receives as input, via an input interface module I, a set of codes to be compiled, which the microprocessor processes, according to the instructions of the aforementioned program, to generate an application composed of two parts. This two-part application is delivered via the T interface.
• the device comprises means of selective compilation of the set of codes to compile delivering a compiled application comprising a first application part executed by said virtual machine by using instructions of said virtual machine and a second application part comprising binary instructions directly executable on said hardware platform.
• the selective compilation means comprise means for selecting the subsets of codes to be compiled. These selection means are either implemented manually or implemented automatically. An automatic implementation of the selection may be performed by a code pre-analysis device 43 for identifying those portions of code for which optimization and / or binary execution is preferable.
• the selective compilation means furthermore comprise at least two compilation devices which make it possible on the one hand to generate the first part of the application, which is executed by the virtual machine and the second part of the application, which is executed directly. by the operating system of the hardware platform.
• These two compilation devices can be complemented by other devices, such as other compilers, linkers, or optimizers.

Applications Claiming Priority (2)

Publications (1)

Family

ID=43465985

Family Applications (1)

Country Status (4)

Families Citing this family (9)

Family Cites Families (32)

• 2010
  • 2010-06-29 FR FR1055261A patent/FR2961922B1/fr not_active Expired - Fee Related
• 2011
  • 2011-06-27 WO PCT/EP2011/060748 patent/WO2012000949A1/fr active Application Filing
  • 2011-06-27 EP EP11728266.5A patent/EP2588953A1/de not_active Withdrawn
  • 2011-06-27 US US13/807,398 patent/US9535672B2/en not_active Expired - Fee Related
• 2016
  • 2016-11-22 US US15/359,478 patent/US10216497B2/en active Active

Non-Patent Citations (2)

Also Published As

Similar Documents

Legal Events