CA2249042A1 - Method for generating a java bytecode data flow graph - Google Patents
Method for generating a java bytecode data flow graph Download PDFInfo
- Publication number
- CA2249042A1 CA2249042A1 CA002249042A CA2249042A CA2249042A1 CA 2249042 A1 CA2249042 A1 CA 2249042A1 CA 002249042 A CA002249042 A CA 002249042A CA 2249042 A CA2249042 A CA 2249042A CA 2249042 A1 CA2249042 A1 CA 2249042A1
- Authority
- CA
- Canada
- Prior art keywords
- bytecodes
- bytecode
- blocks
- uninterrupted
- data flow
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
- 238000000034 method Methods 0.000 title claims abstract description 18
- 230000015572 biosynthetic process Effects 0.000 claims abstract 4
- 238000010586 diagram Methods 0.000 description 18
- 201000008103 leukocyte adhesion deficiency 3 Diseases 0.000 description 4
- 238000012795 verification Methods 0.000 description 4
- 238000004519 manufacturing process Methods 0.000 description 3
- 238000013459 approach Methods 0.000 description 2
- 238000012545 processing Methods 0.000 description 2
- 238000004590 computer program Methods 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 150000002500 ions Chemical class 0.000 description 1
- 238000013507 mapping Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- GWUSZQUVEVMBPI-UHFFFAOYSA-N nimetazepam Chemical compound N=1CC(=O)N(C)C2=CC=C([N+]([O-])=O)C=C2C=1C1=CC=CC=C1 GWUSZQUVEVMBPI-UHFFFAOYSA-N 0.000 description 1
- 238000004088 simulation Methods 0.000 description 1
- 238000013519 translation Methods 0.000 description 1
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/43—Checking; Contextual analysis
- G06F8/433—Dependency analysis; Data or control flow analysis
Abstract
According to a first aspect of the present invention, a method for linking bytecodes of an uninterrupted block of bytecodes in the formation of a data flow graph comprises the steps of scanning the uninterrupted block of bytecodes in a forward manner to identify the start of each of the bytecodes, scanning in a backward manner bytecodewise each of the bytecodes in the uninterrupted block of bytecodes, and generating a link in the data flow graph that links each of the bytecodes to all other of the bytecodes used by the each of the bytecodes.
According to a second aspect of the present invention, a method for linking bytecodes between uninterrupted blocks of bytecodes in the formation of a data flow graph, the uninterrupted blocks of bytecodes having links according to an order of execution of the uninterrupted blocks and wherein a stack state has been generated for each of the uninterrupted blocks of bytecodes, comprises the steps of stepping through a first path of a plurality of paths of the order of execution that terminates in a join to generate a link in the data flow graph between each bytecode producing a value in one of the uninterrupted blocks and each bytecode consuming the value in another of the uninterrupted blocks in the first path, and duplicating each link in the first path with a link for each bytecode in all of the plurality of paths other than the first path for each bytecode producing a value having a similar stack location to each bytecode producing a value in one of the uninterrupted blocks in the first path.
According to a second aspect of the present invention, a method for linking bytecodes between uninterrupted blocks of bytecodes in the formation of a data flow graph, the uninterrupted blocks of bytecodes having links according to an order of execution of the uninterrupted blocks and wherein a stack state has been generated for each of the uninterrupted blocks of bytecodes, comprises the steps of stepping through a first path of a plurality of paths of the order of execution that terminates in a join to generate a link in the data flow graph between each bytecode producing a value in one of the uninterrupted blocks and each bytecode consuming the value in another of the uninterrupted blocks in the first path, and duplicating each link in the first path with a link for each bytecode in all of the plurality of paths other than the first path for each bytecode producing a value having a similar stack location to each bytecode producing a value in one of the uninterrupted blocks in the first path.
Description
This application is submitted in the name of inventor Sanjoy Ghosh, assignor to Sun Microsystems, Inc., a California Corporation.
SPECI_IC_TIQN
METHOD FOR GENERAT~G A
BACKGROUND OF THE INVE~TION
l. Field of the Invention The present invention relates to the optimi7~ion of Java class files. More particularly, the present invention relates to the generation of aspects of a data ffow 10 graph from a Java classfile optimizer that identifies the propagation of data values in blocks of bytecode and between blocks of bytecode.
SPECI_IC_TIQN
METHOD FOR GENERAT~G A
BACKGROUND OF THE INVE~TION
l. Field of the Invention The present invention relates to the optimi7~ion of Java class files. More particularly, the present invention relates to the generation of aspects of a data ffow 10 graph from a Java classfile optimizer that identifies the propagation of data values in blocks of bytecode and between blocks of bytecode.
2. The Prior Art A known problem for software developers and computer users is the lack of portability of software across operating system platforms. Attempts to address this 15 problem must include means of ensuring security as computers are linked together in ever expanding networks, such as the World Wide Web. As a response to both of these concerns, the JAVA progr~mming language was developed at Sun Microsystems as a platform independent, object oriented computer language designed to include several layers of security protection.
_ .
Java achieves its operating system independence by being both a compiled and interpreted language. First, Java source code, which consists of Java classfiles, is compiled into a generic intermediate format called Java bytecode. Java's bytecodes consist of a sequence of single byte opcodes, each of which identify a particular 5 operation to be carried out. Additionally, some of the opcodes have parameters. For example, opcode number 21, iload <varnum>, takes the single-word integer value stored in the local variable, varnum, and pushes it onto a stack.
Next, the bytecodes are interpreted by a Java Virtual Machine (JVM) which translates the bytecodes into native machine code. The JVM is a stacked-based 10 implementation of a "virtual" processor that shares many characteristics with physical microprocessors. The bytecodes executed by the JVM are essentially a machine instruction set, and as will be appreciated by those of ordinary skill in the art, are similar to the assembly language of a computing machine. Accordingly, every hardware platform or operating system may have a unique implementation of the JVM, called a 15 Java Runtime System, to route the universal bytecode calls to the underlying native system.
When developing the JAVA bytecode instruction set, the designers sought to ensure that it was sirnple enough for hardware optimi~tion and also included verification means to provide security protection and to prevent the execution errors or 20 system crashes that can result from improperly formatted bytecode. As Java's bytecodes contain significant type information, the verification means are able to do extensive type ..
checking when the bytecodes are first retrieved from the internet or a local disk. As a result, the interpreter of the native machine need only perform minim~l type checking at run time. Unlike languages such as SmallTalk that provide protection by performing extensive runtime checks, Java executes more quickly at run time.
Although Java provides security through verification means and portability through bytecodes, Java programs lag natively compiled programs, written in languages like C/C~, in their execution time. When a user activates a Java progr~m on a Web Page, the user must wait not only for the program to download but also to be interpreted. To improve Java's execution time, optimi7~tions can be introduced into the processing of Java bytecodes. These optimi7~tions can be irnplemented in a variety of m~nners including as Stand-Alone Optimizers (SAO) or as part of Just-in-Time (JIT) compilers.
A SAO transforms an input classfile cont~ining bytecode into an output classfilecontaining bytecodes that more efficiently perform the same operations. A JIT
transforms an input classfile containing bytecode into an executable program. Prior to the development of JITs, a JVM would step through all the bytecode instructions in a program and mechanically perform the native code calls. With a JIT compiler, however, the JVM first makes a call to the JIT which compiles the instructions into native code that is then run directly on the native operating system. The JIT compiler permits natively complied code to run faster and makes it so that the code only needs to be compiled once. Further, JIT compilers offer a stage at wnich the executable code can be op~imi7e-1 To either optimize or compile bytecodes involves the translation of the source bytecodes into what is known in the art as an intermediate representation (IR). The IR
provides information about two essential components of a program: the control flow 5 graph (CFG) and the data flow graph (DFG). Subsequently, the IR is transformed for compilers into object code and for optimizers into an improved version of the source code format.
The CFG breaks the code into blocks of bytecode that are always performed as an uninterrupted group and establishes the connections that link the blocks together.
10 The DFG maps the connections between where values are produced and where they are used. This includes connections within blocks of bytecodes and also connections between blocks of bytecodes. Because Java programs frequently use stack locations as implicit variables, tracking the propagation of values is a difficult process. When extracting the data flow information to generate the DFG for the IR, the prior art 15 approach has been to perform a complete simulation of both the stack and iterations through all possible flow paths .
In contrast to traditional compilers where end users only interact with compiledprograms, the run time nature of Java creates a significant incentive to optimize the speed and efficiency of Java optimizers and JIT compilers. Accordingly, it is an object of 20 the present invention to provide a method for generating a DFG from the source bytecodes to form an IR that optimizes the speed and efficiency of Java optimizers and Jlrr compilers.
These and many other objects and advantages of the present invention will become apparent to those of ordinary skill in the art from a consideration of the 5 drawings and ensuing description of the invention.
SUMMARY OF THE INVENTION
The present invention is directed to the optimi7~tion of Java class files by improving the efficiency of generating a DFG for the IR.
According to a first aspect of the present invention, a forward scan of an uninterrupted bytecode block from a bytecode source file is performed to identify the start of each bytecode in the llnint~rrupted block. Next, a backwards scan is performed.
For each bytecode in the block, a DFG node is created, links to all the values used by the bytecode in the block are established, and links to preceding or subsequent nodes in the 15 file are created.
According to a second aspect of the invention, the bytecode blocks are linked in the file's order of execution and a stack state is generated for each block of code. For each join statement generated by the CFG, one path of the CFG is stepped through.
Next, links are established in the DFG between locations where values are used and 20 where the values are produced. Finally, for all blocks parallel to the blocks producing values the links for bytecodes occupying the same stack state location are duplicated.
BRIEF DESCRIPIION OF THE DRAWINGS
FIG. lA is a flow diagrarn of the optimi7~tion of a JAVA bytecode source file using a stand alone optimizer according to the present invention.
FIG. lB is a flow diagram of the optimi7ation of JAVA bytecode source file usinga just in time compiler according to the present invention.
FIG. 2 is a flow diagram illustrating the generation of control flow graph from a bytecode source file suitable for use in the present invention.
FIG. 3 is a flow diagram of the generation of data flow graph according to the prior art.
FIG. 4 is a flow diagram of a first aspect of the generation of a data flow graph for the links in a block of bytecode according to the present invention.
FIG. SA is a block diagram for the generation of a node in a data flow graph forthe instruction IADD according to the first aspect of the present invention.
FIG. 5B is a block diagram for the generation of several nodes in a data flow graph for a plurality of instructions according to the first aspect of the present invention.
FIG. 6 is a flow diagram of a control flow graph suitable for illustrating a second aspect of the generation of a data flow graph for the links between blocks of bytecode according to the present invention.
FIG. 7A is a block diagram of the steps in the method according to the second 5 aspect of the present invention.
FIG. 7B is a block diagram for the generation of nodes in a data flow graph according to the second aspect of the present invention.
DESCRIPIION OF THE PREFERRED EMBODIMENTS
Those of ordinary skill in the art will realize that the following description of the 10 present invention is illustrative only and is not intended to be in any way limiting. Other embodiments of the invention will readily suggest themselves to such skilled persons from an ex~min~tion of the within disclosure.
Referring first to FIGS. lA and lB, simplified flow diagrams 10 and 20 of the optimi7~tion of a Java bytecode source file are illustrated. In both flow diagrams 10 and 15 20, Java source code file 12 is compiled by a Java compiler 14 into Java bytecode classfiles 16. In flow diagram 10, the classfiles are operated on by a SAO 18, and in flow diagram 20, the classfiles are passed through a Java Runtime System 22 to a JIT compiler 24. The Java SAO 18 outputs Java classfiles 26 containing bytecodes that perforrn the same operations as the input classfiles, only in an optimi~e~ manner. The JIT 24 outputs executable code 28 that can run directly on the native operating system 30. Those of ordinary skill in the art will recognize that the procedures described in FIG. l are merely illustrative and that there exist other structures within which classfiles may be optimized.
In processing an input bytecode source classfile, both an SAO and a JIT form an IR. As described above, an IR is a succinct and straightforward structuring of the control and data flow information of a program into a CFG and DFG. The CFG
represents the information regarding the sequence and order of the execution of the bytecode instructions as blocks of code linked in the order of execution of the program.
The blocks of code are sections of bytecode that are always performed as an uninterrupted group, and the links between the blocks of code are bytecode branch, conditional, or jump instructions.
FIG. 2 is a flow diagram that illustrates the generation of the CFG from a bytecode classfile 40. It should be appreciated that there are several known methods for generating a CFG. The specifics of any such method will not be disclosed herein to avoid overcomplicating the disclosure and thereby obscuring the present invention.
The procedure begins with a classfile 40 containing an ordered sequence of bytecode instructions numbered from l through N. The numbers l through N are analogous to the numbering of lines in a computer program as is known in the art. Next, an optimizer 42 processes the bytecode classfile 40 to extract the control flow information from the bytecodes.
The control flow information is illustrated by the CFG 44. For example, the CFG
44 may indicate that for classfile 40 that bytecode instructions l through 3 are first executed, instructions lO0 through 103 are next executed, either instructions lO through 14 or 15 through l9 are next executed, and finally instructions 4 through 8 are 5 executed before the remainder of the bytecode instructions execute. It will beappreciated that the CFG 44is an example only, and that any number of CFGs may be generated from the classfile 40 by the optimizer 42.
As described above, once the CFG has been generated, the DFG will be generated. According to the present invention, two aspects of the DFG are generated 10 from the CFG. In one aspect, the propagation of values within blocks of bytecode is determined. As is known in a typical JAVA program, data values are produced in one location and consumed in another. The first aspect of the present invention relates to establishing the connections between the production and consumption points that occur within uninterrupted blocks of code. The present invention allows implicit15 variables to be easily recognized and for their values to be irnmediately linked in the DFG to the bytecode(s) using them.
Unlike the prior art, the present invention avoids the approach taken in the prior art of constructing a stack to determine the values used by bytecodes. For example, in FIG. 3, a block diagram of a known method for generating links within a code block of a 20 CFG is illustrated. The diagram demonstrates the principle stages employed to determine the value of implicit stack location variables when generating a DFG. During stage 60, the operations of an input sequence of bytecodes 62 are simulated to create a version of the stack 64 that they represent. The stack shown 64 presents only a portion 66 of the input sequence of bytecodes 62. During stage 68, the stack 64 is executed, and it is 5 determined that the POP instruction 70 is associated with the value "2" due to the preceding B~PUSH "2" 72 instruction. This information is stored in a DFG node represented by reference numerals 74 and 76.
According to the preferred embodiment of the present invention, a node tree is employed. When values are produced by the bytecode classfile, a new node is created 1 0 in the tree. This node is then connected to the rest of the tree by linking it to the value's production and consumption points, as they become known. In this manner, the propagation of data values through a program can be readily traced. Those of ordinary skill in the art will recognize that a variety of data structures could be used.
Turning now to FIG. 4, a flow diagram of a method for generating links within a 1 5 bytecode block according to the present invention is illustrated. In a first step 100, a forward scan of a bytecode source file 102 is performed in order to determine the starts 106, 108, and 110 of the bytecodes 112, 114, and 116, respectively, because as is known, bytecodes can be of different lengths. Next, at step 118 a backward scan of the bytecode source file 102 is performed. During the backward scan step 118, the nodes of 20 the DFG are generated as they occur. For example, if bytecode 116 is the instruction POP, as POP is read, a node 120 is created in the DFG including a POP instruction 122.
If next, the instruction BIPUSH "2" is read at bytecode 108, the value "2" at 124 is linked to the POP instruction 122 that consumes it.
The present invention provides a significant increase in the efficiency in the generation of the DFG because the entire process of constructing a copy of the stack 5 has been elimin~ted. The invention recognizes that because the stream of bytecodes are the instructions for a stack machine, the operands or values consumed by a bytecode instruction precede the instruction. When the bytecode file is read in reverse order, the step of creating a node in the DFG can be immediately performed after the bytecode is read.
1 0 Further examples, not intended to be exhaustive, are illustrated in FIGS. 5A and 5B of the nodes in a DFG created from bytecode instructions according to the present invention. FIGS. 5A and 5B respectively are examples of a single instruction with two links, and a series of instructions with multiple links.
In FIG. 5A, a bytecode source block 150 has been first differentiated by a forward 1 5 scan into bytecodes 152, 154 and 158. When the backward scan step is performed, an integer addition (IAPD) instruction is read from bytecode 158, and a node 160 is created in the DFG. From the definition of the instruction IADD it is known that node 160 will consume two values. As the backward scan continues, these two values are read from bytecodes 154 and 152, created as nodes 162 and 164 in the node tree of the DFG, and 20 then linked to node 160.
_ , In FIG. SB, a bytecode source block 166 has been first differentiated by a forward scan into bytecodes 168, 170 and 172. The sequence of bytecodes 166 implements the statement (X + X). In the backwards scan step the first bytecode 172 encountered is an IADD instruction. As explained with respect to the example of FIG. SA, the IADD
5 instruction generates a node 174 in the DFG with links to two values. Since the next bytecode 170 is a duplicate (DUP) instruction both of the links from node 174 are made to the node 176 for the DUP instruction. Next, bytecode 168 having an integer load X
(ILOADX) instruction is read, and a node 178 with a link to node 176 is created. In this sequence in the node tree, the value in node 178, will be duplicated in node 176, and 1 0 both values will be consumed in node 174. As will be appreciated by those of ordinary skill in the art from the above recited examples, when performing the backwards scan step, the particular DFG created will depend upon the sequence of bytecodes in the blocks generated by the CFG.
According to a second aspect of the present invention, the propagation of values 1 5 between blocks of bytecode in the CFG is determined. FIG. 6 illustrates a CFG 180 having several blocks of linked code 200, 202, 204, and 206. In the CFG 180, the blocks 202 and 206, that precede a join 208 are considered parallel. It should be appreciated that a join may connect a plurality of parallel blocks. When the CFG is generated, stack states, 210, 212, 214, and 216 are created for each block of bytecode 20 200, 202, 204, and 206, respectively. The stack states includes all the values still present on the stack after the bytecodes in the block associated with that stack have been _ .
executed. It should be appreciated that values on the stack are produced by instructions in the bytecode blocks. This is shown by the mapping of the instructions 218 and 220 to the stack states 222 and 224, respectively. For purposes of illustration to be described below, instruction 218 is PUSH "1", instruction 220 is PUSH "0", and 5 instruction 226 is POP.
To determine when a value produced in an early block of bytecode is used or consumed by a subsequent block of bytecode to generate a link in the DFG betweenblocks of bytecode, an execution of the blocks is made while noting the consumption of a prior stack state value and identifying its source. This inforrnation is represented in the 1 0 DFG as a link between the nodes of the consumption and production of the bytecodes.
To establish links for all parallel blocks, the method in the prior art relied upon iterating through all possible control flow paths in the CFG. For example, to generate the DFG
for links between blocks in the CFG 180, a first pass would be made through the path including blocks 200, 202 and 204, and then a second pass would be made through the 1 5 path including blocks 200, 206 and 204.
According to the present invention, not all control flow paths must be traversedto form the DFG for links between parallel blocks of bytecode. Rather, the links in the DFG between blocks 200, 202, 204 and 206 can be generated simply by stepping 20 through blocks 200, 202, 204 and then applying the information from the pass through blocks 200, 202, 204 to establish the links to block 206. The present invention exploits the fact that Java standards' require and the verification described above ensures that in _ .
properly formatted code, the stack states for any of the blocks preceding a join are the same.
For example, in CFG 180, both of the stack states 212 and 216 that precede the join 208 must be the same in both size and relative type. During execution, the 5 consumption of any value in block 202 will be paralleled by a consumption of a value in block 206. As a result, for example, if the value corresponding to the stack state location 222 is used by the bytecode instruction in 226 of code block 204, then the bytecode instruction 226 also uses the value corresponding to the stack state location 224.
The following lines of pseudocode illustrate the point.
1 0 IF (some condition occurs) X=l;
ELSE
X=O;
A = X + 2;
The assignment of a value to "A" in the expression "A = X + 2" uses the value from either expression "X = 1" or X = 0" that has been assigned to the implicit stack 20 variable "X" as determined by the "IF (some condition occurs)" statement.
In FIG. 7A, a block diagram outlining the steps employed to generate a DFG
according to the second aspect of the present invention is illustrated.
At step 250, a first branch of a CFG graph is scanned. Applied to CFG 180 in FIG. 6, a first pass through blocks 200, 202 and 204 is performed.
Next at step 252, links between the place a value is created and the place a value is consumed are made. As illustrated m FIG. 7B, a link 254 is made between the PUSH "1" instruction at location 218 in the CFG 180 that the POP instruction consumes at location 226 in the CFG 180.
Next at step 256, a link 258 is made between the PUSH 0 instruction at location 1 0 220 that the POP instruction consumes at location 226, because it is known that the data for this instruction occupies the same respective stack state location as the PUSH 1 instruction at location 218 in the CFG 180. As such, without traversing all paths in the CFG as relied upon by the prior art, according to the second aspect of the present invention, the links in a DFG between blocks of bytecodes can be more efficiently made.
1 5 As joins are quite common throughout bytecode source code, the present invention represents a significant increase in efficiency. Where multiple joins exist, the increase in efficiency is even greater.
While illustrative embodiments and applications of this invention have been shown and described, it would be apparent to those skilled in the art that many more _ .
modifications than have been mentioned above are possible without departing from the inventive concepts set forth herein. The invention, therefore, is not to be limited except in the spirit of the appended claims.
_ .
Java achieves its operating system independence by being both a compiled and interpreted language. First, Java source code, which consists of Java classfiles, is compiled into a generic intermediate format called Java bytecode. Java's bytecodes consist of a sequence of single byte opcodes, each of which identify a particular 5 operation to be carried out. Additionally, some of the opcodes have parameters. For example, opcode number 21, iload <varnum>, takes the single-word integer value stored in the local variable, varnum, and pushes it onto a stack.
Next, the bytecodes are interpreted by a Java Virtual Machine (JVM) which translates the bytecodes into native machine code. The JVM is a stacked-based 10 implementation of a "virtual" processor that shares many characteristics with physical microprocessors. The bytecodes executed by the JVM are essentially a machine instruction set, and as will be appreciated by those of ordinary skill in the art, are similar to the assembly language of a computing machine. Accordingly, every hardware platform or operating system may have a unique implementation of the JVM, called a 15 Java Runtime System, to route the universal bytecode calls to the underlying native system.
When developing the JAVA bytecode instruction set, the designers sought to ensure that it was sirnple enough for hardware optimi~tion and also included verification means to provide security protection and to prevent the execution errors or 20 system crashes that can result from improperly formatted bytecode. As Java's bytecodes contain significant type information, the verification means are able to do extensive type ..
checking when the bytecodes are first retrieved from the internet or a local disk. As a result, the interpreter of the native machine need only perform minim~l type checking at run time. Unlike languages such as SmallTalk that provide protection by performing extensive runtime checks, Java executes more quickly at run time.
Although Java provides security through verification means and portability through bytecodes, Java programs lag natively compiled programs, written in languages like C/C~, in their execution time. When a user activates a Java progr~m on a Web Page, the user must wait not only for the program to download but also to be interpreted. To improve Java's execution time, optimi7~tions can be introduced into the processing of Java bytecodes. These optimi7~tions can be irnplemented in a variety of m~nners including as Stand-Alone Optimizers (SAO) or as part of Just-in-Time (JIT) compilers.
A SAO transforms an input classfile cont~ining bytecode into an output classfilecontaining bytecodes that more efficiently perform the same operations. A JIT
transforms an input classfile containing bytecode into an executable program. Prior to the development of JITs, a JVM would step through all the bytecode instructions in a program and mechanically perform the native code calls. With a JIT compiler, however, the JVM first makes a call to the JIT which compiles the instructions into native code that is then run directly on the native operating system. The JIT compiler permits natively complied code to run faster and makes it so that the code only needs to be compiled once. Further, JIT compilers offer a stage at wnich the executable code can be op~imi7e-1 To either optimize or compile bytecodes involves the translation of the source bytecodes into what is known in the art as an intermediate representation (IR). The IR
provides information about two essential components of a program: the control flow 5 graph (CFG) and the data flow graph (DFG). Subsequently, the IR is transformed for compilers into object code and for optimizers into an improved version of the source code format.
The CFG breaks the code into blocks of bytecode that are always performed as an uninterrupted group and establishes the connections that link the blocks together.
10 The DFG maps the connections between where values are produced and where they are used. This includes connections within blocks of bytecodes and also connections between blocks of bytecodes. Because Java programs frequently use stack locations as implicit variables, tracking the propagation of values is a difficult process. When extracting the data flow information to generate the DFG for the IR, the prior art 15 approach has been to perform a complete simulation of both the stack and iterations through all possible flow paths .
In contrast to traditional compilers where end users only interact with compiledprograms, the run time nature of Java creates a significant incentive to optimize the speed and efficiency of Java optimizers and JIT compilers. Accordingly, it is an object of 20 the present invention to provide a method for generating a DFG from the source bytecodes to form an IR that optimizes the speed and efficiency of Java optimizers and Jlrr compilers.
These and many other objects and advantages of the present invention will become apparent to those of ordinary skill in the art from a consideration of the 5 drawings and ensuing description of the invention.
SUMMARY OF THE INVENTION
The present invention is directed to the optimi7~tion of Java class files by improving the efficiency of generating a DFG for the IR.
According to a first aspect of the present invention, a forward scan of an uninterrupted bytecode block from a bytecode source file is performed to identify the start of each bytecode in the llnint~rrupted block. Next, a backwards scan is performed.
For each bytecode in the block, a DFG node is created, links to all the values used by the bytecode in the block are established, and links to preceding or subsequent nodes in the 15 file are created.
According to a second aspect of the invention, the bytecode blocks are linked in the file's order of execution and a stack state is generated for each block of code. For each join statement generated by the CFG, one path of the CFG is stepped through.
Next, links are established in the DFG between locations where values are used and 20 where the values are produced. Finally, for all blocks parallel to the blocks producing values the links for bytecodes occupying the same stack state location are duplicated.
BRIEF DESCRIPIION OF THE DRAWINGS
FIG. lA is a flow diagrarn of the optimi7~tion of a JAVA bytecode source file using a stand alone optimizer according to the present invention.
FIG. lB is a flow diagram of the optimi7ation of JAVA bytecode source file usinga just in time compiler according to the present invention.
FIG. 2 is a flow diagram illustrating the generation of control flow graph from a bytecode source file suitable for use in the present invention.
FIG. 3 is a flow diagram of the generation of data flow graph according to the prior art.
FIG. 4 is a flow diagram of a first aspect of the generation of a data flow graph for the links in a block of bytecode according to the present invention.
FIG. SA is a block diagram for the generation of a node in a data flow graph forthe instruction IADD according to the first aspect of the present invention.
FIG. 5B is a block diagram for the generation of several nodes in a data flow graph for a plurality of instructions according to the first aspect of the present invention.
FIG. 6 is a flow diagram of a control flow graph suitable for illustrating a second aspect of the generation of a data flow graph for the links between blocks of bytecode according to the present invention.
FIG. 7A is a block diagram of the steps in the method according to the second 5 aspect of the present invention.
FIG. 7B is a block diagram for the generation of nodes in a data flow graph according to the second aspect of the present invention.
DESCRIPIION OF THE PREFERRED EMBODIMENTS
Those of ordinary skill in the art will realize that the following description of the 10 present invention is illustrative only and is not intended to be in any way limiting. Other embodiments of the invention will readily suggest themselves to such skilled persons from an ex~min~tion of the within disclosure.
Referring first to FIGS. lA and lB, simplified flow diagrams 10 and 20 of the optimi7~tion of a Java bytecode source file are illustrated. In both flow diagrams 10 and 15 20, Java source code file 12 is compiled by a Java compiler 14 into Java bytecode classfiles 16. In flow diagram 10, the classfiles are operated on by a SAO 18, and in flow diagram 20, the classfiles are passed through a Java Runtime System 22 to a JIT compiler 24. The Java SAO 18 outputs Java classfiles 26 containing bytecodes that perforrn the same operations as the input classfiles, only in an optimi~e~ manner. The JIT 24 outputs executable code 28 that can run directly on the native operating system 30. Those of ordinary skill in the art will recognize that the procedures described in FIG. l are merely illustrative and that there exist other structures within which classfiles may be optimized.
In processing an input bytecode source classfile, both an SAO and a JIT form an IR. As described above, an IR is a succinct and straightforward structuring of the control and data flow information of a program into a CFG and DFG. The CFG
represents the information regarding the sequence and order of the execution of the bytecode instructions as blocks of code linked in the order of execution of the program.
The blocks of code are sections of bytecode that are always performed as an uninterrupted group, and the links between the blocks of code are bytecode branch, conditional, or jump instructions.
FIG. 2 is a flow diagram that illustrates the generation of the CFG from a bytecode classfile 40. It should be appreciated that there are several known methods for generating a CFG. The specifics of any such method will not be disclosed herein to avoid overcomplicating the disclosure and thereby obscuring the present invention.
The procedure begins with a classfile 40 containing an ordered sequence of bytecode instructions numbered from l through N. The numbers l through N are analogous to the numbering of lines in a computer program as is known in the art. Next, an optimizer 42 processes the bytecode classfile 40 to extract the control flow information from the bytecodes.
The control flow information is illustrated by the CFG 44. For example, the CFG
44 may indicate that for classfile 40 that bytecode instructions l through 3 are first executed, instructions lO0 through 103 are next executed, either instructions lO through 14 or 15 through l9 are next executed, and finally instructions 4 through 8 are 5 executed before the remainder of the bytecode instructions execute. It will beappreciated that the CFG 44is an example only, and that any number of CFGs may be generated from the classfile 40 by the optimizer 42.
As described above, once the CFG has been generated, the DFG will be generated. According to the present invention, two aspects of the DFG are generated 10 from the CFG. In one aspect, the propagation of values within blocks of bytecode is determined. As is known in a typical JAVA program, data values are produced in one location and consumed in another. The first aspect of the present invention relates to establishing the connections between the production and consumption points that occur within uninterrupted blocks of code. The present invention allows implicit15 variables to be easily recognized and for their values to be irnmediately linked in the DFG to the bytecode(s) using them.
Unlike the prior art, the present invention avoids the approach taken in the prior art of constructing a stack to determine the values used by bytecodes. For example, in FIG. 3, a block diagram of a known method for generating links within a code block of a 20 CFG is illustrated. The diagram demonstrates the principle stages employed to determine the value of implicit stack location variables when generating a DFG. During stage 60, the operations of an input sequence of bytecodes 62 are simulated to create a version of the stack 64 that they represent. The stack shown 64 presents only a portion 66 of the input sequence of bytecodes 62. During stage 68, the stack 64 is executed, and it is 5 determined that the POP instruction 70 is associated with the value "2" due to the preceding B~PUSH "2" 72 instruction. This information is stored in a DFG node represented by reference numerals 74 and 76.
According to the preferred embodiment of the present invention, a node tree is employed. When values are produced by the bytecode classfile, a new node is created 1 0 in the tree. This node is then connected to the rest of the tree by linking it to the value's production and consumption points, as they become known. In this manner, the propagation of data values through a program can be readily traced. Those of ordinary skill in the art will recognize that a variety of data structures could be used.
Turning now to FIG. 4, a flow diagram of a method for generating links within a 1 5 bytecode block according to the present invention is illustrated. In a first step 100, a forward scan of a bytecode source file 102 is performed in order to determine the starts 106, 108, and 110 of the bytecodes 112, 114, and 116, respectively, because as is known, bytecodes can be of different lengths. Next, at step 118 a backward scan of the bytecode source file 102 is performed. During the backward scan step 118, the nodes of 20 the DFG are generated as they occur. For example, if bytecode 116 is the instruction POP, as POP is read, a node 120 is created in the DFG including a POP instruction 122.
If next, the instruction BIPUSH "2" is read at bytecode 108, the value "2" at 124 is linked to the POP instruction 122 that consumes it.
The present invention provides a significant increase in the efficiency in the generation of the DFG because the entire process of constructing a copy of the stack 5 has been elimin~ted. The invention recognizes that because the stream of bytecodes are the instructions for a stack machine, the operands or values consumed by a bytecode instruction precede the instruction. When the bytecode file is read in reverse order, the step of creating a node in the DFG can be immediately performed after the bytecode is read.
1 0 Further examples, not intended to be exhaustive, are illustrated in FIGS. 5A and 5B of the nodes in a DFG created from bytecode instructions according to the present invention. FIGS. 5A and 5B respectively are examples of a single instruction with two links, and a series of instructions with multiple links.
In FIG. 5A, a bytecode source block 150 has been first differentiated by a forward 1 5 scan into bytecodes 152, 154 and 158. When the backward scan step is performed, an integer addition (IAPD) instruction is read from bytecode 158, and a node 160 is created in the DFG. From the definition of the instruction IADD it is known that node 160 will consume two values. As the backward scan continues, these two values are read from bytecodes 154 and 152, created as nodes 162 and 164 in the node tree of the DFG, and 20 then linked to node 160.
_ , In FIG. SB, a bytecode source block 166 has been first differentiated by a forward scan into bytecodes 168, 170 and 172. The sequence of bytecodes 166 implements the statement (X + X). In the backwards scan step the first bytecode 172 encountered is an IADD instruction. As explained with respect to the example of FIG. SA, the IADD
5 instruction generates a node 174 in the DFG with links to two values. Since the next bytecode 170 is a duplicate (DUP) instruction both of the links from node 174 are made to the node 176 for the DUP instruction. Next, bytecode 168 having an integer load X
(ILOADX) instruction is read, and a node 178 with a link to node 176 is created. In this sequence in the node tree, the value in node 178, will be duplicated in node 176, and 1 0 both values will be consumed in node 174. As will be appreciated by those of ordinary skill in the art from the above recited examples, when performing the backwards scan step, the particular DFG created will depend upon the sequence of bytecodes in the blocks generated by the CFG.
According to a second aspect of the present invention, the propagation of values 1 5 between blocks of bytecode in the CFG is determined. FIG. 6 illustrates a CFG 180 having several blocks of linked code 200, 202, 204, and 206. In the CFG 180, the blocks 202 and 206, that precede a join 208 are considered parallel. It should be appreciated that a join may connect a plurality of parallel blocks. When the CFG is generated, stack states, 210, 212, 214, and 216 are created for each block of bytecode 20 200, 202, 204, and 206, respectively. The stack states includes all the values still present on the stack after the bytecodes in the block associated with that stack have been _ .
executed. It should be appreciated that values on the stack are produced by instructions in the bytecode blocks. This is shown by the mapping of the instructions 218 and 220 to the stack states 222 and 224, respectively. For purposes of illustration to be described below, instruction 218 is PUSH "1", instruction 220 is PUSH "0", and 5 instruction 226 is POP.
To determine when a value produced in an early block of bytecode is used or consumed by a subsequent block of bytecode to generate a link in the DFG betweenblocks of bytecode, an execution of the blocks is made while noting the consumption of a prior stack state value and identifying its source. This inforrnation is represented in the 1 0 DFG as a link between the nodes of the consumption and production of the bytecodes.
To establish links for all parallel blocks, the method in the prior art relied upon iterating through all possible control flow paths in the CFG. For example, to generate the DFG
for links between blocks in the CFG 180, a first pass would be made through the path including blocks 200, 202 and 204, and then a second pass would be made through the 1 5 path including blocks 200, 206 and 204.
According to the present invention, not all control flow paths must be traversedto form the DFG for links between parallel blocks of bytecode. Rather, the links in the DFG between blocks 200, 202, 204 and 206 can be generated simply by stepping 20 through blocks 200, 202, 204 and then applying the information from the pass through blocks 200, 202, 204 to establish the links to block 206. The present invention exploits the fact that Java standards' require and the verification described above ensures that in _ .
properly formatted code, the stack states for any of the blocks preceding a join are the same.
For example, in CFG 180, both of the stack states 212 and 216 that precede the join 208 must be the same in both size and relative type. During execution, the 5 consumption of any value in block 202 will be paralleled by a consumption of a value in block 206. As a result, for example, if the value corresponding to the stack state location 222 is used by the bytecode instruction in 226 of code block 204, then the bytecode instruction 226 also uses the value corresponding to the stack state location 224.
The following lines of pseudocode illustrate the point.
1 0 IF (some condition occurs) X=l;
ELSE
X=O;
A = X + 2;
The assignment of a value to "A" in the expression "A = X + 2" uses the value from either expression "X = 1" or X = 0" that has been assigned to the implicit stack 20 variable "X" as determined by the "IF (some condition occurs)" statement.
In FIG. 7A, a block diagram outlining the steps employed to generate a DFG
according to the second aspect of the present invention is illustrated.
At step 250, a first branch of a CFG graph is scanned. Applied to CFG 180 in FIG. 6, a first pass through blocks 200, 202 and 204 is performed.
Next at step 252, links between the place a value is created and the place a value is consumed are made. As illustrated m FIG. 7B, a link 254 is made between the PUSH "1" instruction at location 218 in the CFG 180 that the POP instruction consumes at location 226 in the CFG 180.
Next at step 256, a link 258 is made between the PUSH 0 instruction at location 1 0 220 that the POP instruction consumes at location 226, because it is known that the data for this instruction occupies the same respective stack state location as the PUSH 1 instruction at location 218 in the CFG 180. As such, without traversing all paths in the CFG as relied upon by the prior art, according to the second aspect of the present invention, the links in a DFG between blocks of bytecodes can be more efficiently made.
1 5 As joins are quite common throughout bytecode source code, the present invention represents a significant increase in efficiency. Where multiple joins exist, the increase in efficiency is even greater.
While illustrative embodiments and applications of this invention have been shown and described, it would be apparent to those skilled in the art that many more _ .
modifications than have been mentioned above are possible without departing from the inventive concepts set forth herein. The invention, therefore, is not to be limited except in the spirit of the appended claims.
Claims (2)
1. A method for linking bytecodes of an uninterrupted block of bytecodes in the formation of a data flow graph comprising the steps of:
scanning said uninterrupted block of bytecodes in a forward manner to identify the start of each of said bytecodes;
scanning in a backward manner bytecodewise each of said bytecodes in said uninterrupted block of bytecodes; and generating a link in said data flow graph that links each of said bytecodes to all other of said bytecodes used by said each of said bytecodes.
scanning said uninterrupted block of bytecodes in a forward manner to identify the start of each of said bytecodes;
scanning in a backward manner bytecodewise each of said bytecodes in said uninterrupted block of bytecodes; and generating a link in said data flow graph that links each of said bytecodes to all other of said bytecodes used by said each of said bytecodes.
2. A method for linking bytecodes between uninterrupted blocks of bytecodes in the formation of a data flow graph, said uninterrupted blocks of bytecodes having links according to an order of execution of said uninterrupted blocks and wherein a stack state has been generated for each of said uninterrupted blocks of bytecodes, comprising the steps of:
stepping through a first path of a plurality of paths of said order of execution that terminates in a join to generate a link in said data flow graph between each bytecode producing a value in one of said uninterrupted blocks and each bytecode consuming said value in another of said uninterrupted blocks in said first path; and duplicating each link in said first path with a link for each bytecode in all of said plurality of paths other than said first path for each bytecode producing a value having a similar stack location to each bytecode producing a value in one of said uninterrupted blocks in said first path.
stepping through a first path of a plurality of paths of said order of execution that terminates in a join to generate a link in said data flow graph between each bytecode producing a value in one of said uninterrupted blocks and each bytecode consuming said value in another of said uninterrupted blocks in said first path; and duplicating each link in said first path with a link for each bytecode in all of said plurality of paths other than said first path for each bytecode producing a value having a similar stack location to each bytecode producing a value in one of said uninterrupted blocks in said first path.
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| US08/940,212 | 1997-09-30 | ||
| US08/940,212 US6233733B1 (en) | 1997-09-30 | 1997-09-30 | Method for generating a Java bytecode data flow graph |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CA2249042A1 true CA2249042A1 (en) | 1999-03-30 |
Family
ID=25474426
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CA002249042A Abandoned CA2249042A1 (en) | 1997-09-30 | 1998-09-29 | Method for generating a java bytecode data flow graph |
Country Status (5)
| Country | Link |
|---|---|
| US (1) | US6233733B1 (en) |
| EP (1) | EP0905617B1 (en) |
| JP (1) | JPH11242597A (en) |
| CA (1) | CA2249042A1 (en) |
| DE (1) | DE69833617D1 (en) |
Families Citing this family (33)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1183449C (en) | 1996-10-25 | 2005-01-05 | 施卢默格系统公司 | using a high level programming language with a microcontroller |
| US6792600B1 (en) * | 1998-05-14 | 2004-09-14 | International Business Machines Corporation | Method and apparatus for just in time compilation of instructions |
| US6324688B1 (en) * | 1998-07-30 | 2001-11-27 | International Business Machines Corporation | Method and apparatus for optimizing execution of Java programs |
| US6412109B1 (en) * | 1999-01-29 | 2002-06-25 | Sun Microsystems, Inc. | Method for optimizing java bytecodes in the presence of try-catch blocks |
| US6421821B1 (en) * | 1999-03-10 | 2002-07-16 | Ronald J. Lavallee | Flow chart-based programming method and system for object-oriented languages |
| US6412108B1 (en) * | 1999-05-06 | 2002-06-25 | International Business Machines Corporation | Method and apparatus for speeding up java methods prior to a first execution |
| GB9920676D0 (en) * | 1999-09-01 | 1999-11-03 | Tao Group Ltd | Translating and executing object-oriented computer programs |
| US6560774B1 (en) * | 1999-09-01 | 2003-05-06 | Microsoft Corporation | Verifier to check intermediate language |
| US7165246B2 (en) * | 2003-01-16 | 2007-01-16 | Sun Microsystems, Inc. | Optimized representation of data type information in program verification |
| US7222331B2 (en) * | 2003-01-16 | 2007-05-22 | Sun Microsystems, Inc. | Linking of virtual methods |
| US20040143739A1 (en) * | 2003-01-16 | 2004-07-22 | Sun Mircosystems, Inc., A Delaware Corporation | Run time code integrity checks |
| US7272830B2 (en) * | 2003-01-16 | 2007-09-18 | Sun Microsystems, Inc. | Ordering program data for loading on a device |
| US7484095B2 (en) * | 2003-01-16 | 2009-01-27 | Sun Microsystems, Inc. | System for communicating program data between a first device and a second device |
| US8121955B2 (en) * | 2003-01-16 | 2012-02-21 | Oracle America, Inc. | Signing program data payload sequence in program loading |
| US7281244B2 (en) * | 2003-01-16 | 2007-10-09 | Sun Microsystems, Inc. | Using a digital fingerprint to commit loaded data in a device |
| KR100643268B1 (en) * | 2004-01-17 | 2006-11-10 | 삼성전자주식회사 | Method for improving performance of Java virtual machine and system employing the method |
| US7721275B2 (en) * | 2004-05-14 | 2010-05-18 | Sap Ag | Data-flow based post pass optimization in dynamic compilers |
| US20050272001A1 (en) * | 2004-06-03 | 2005-12-08 | Blain Christopher C | Oral care device |
| EP1622009A1 (en) * | 2004-07-27 | 2006-02-01 | Texas Instruments Incorporated | JSM architecture and systems |
| WO2006026681A2 (en) * | 2004-08-30 | 2006-03-09 | Sun Microsystems, Inc. | Mechanism for flowing local variables across a plurality of code blocks |
| US8108826B2 (en) * | 2004-09-29 | 2012-01-31 | Avaya Inc. | Code-coverage guided prioritized test generation |
| MY135555A (en) * | 2004-12-14 | 2008-05-30 | Axiomatic Solutions Sdn Bhd | Compile time linking via hashing technique |
| KR100763177B1 (en) * | 2005-04-21 | 2007-10-04 | 삼성전자주식회사 | Method for executing Java virtual machine instructions, and apparatus for the same |
| US8444416B2 (en) * | 2005-04-26 | 2013-05-21 | Braun Gmbh | Valves for personal care devices |
| US20070017582A1 (en) * | 2005-07-20 | 2007-01-25 | Chenvainu Alexander T | Fluid couplings |
| US8046202B1 (en) * | 2006-07-17 | 2011-10-25 | The Mathworks, Inc. | Generation of intermediate representations based on user specified elements in a graphical model that enable simulation, propagation and code generation |
| US8332827B2 (en) | 2006-12-01 | 2012-12-11 | Murex S.A.S. | Produce graph oriented programming framework with scenario support |
| US8307337B2 (en) | 2006-12-01 | 2012-11-06 | Murex S.A.S. | Parallelization and instrumentation in a producer graph oriented programming framework |
| US8191052B2 (en) | 2006-12-01 | 2012-05-29 | Murex S.A.S. | Producer graph oriented programming and execution |
| DE102007028184A1 (en) | 2007-06-20 | 2008-12-24 | Braun Gmbh | Brush head for a toothbrush |
| US9152437B2 (en) * | 2010-10-28 | 2015-10-06 | Hewlett-Packard Development Company, L.P. | Dynamically installing image processing |
| JP6245573B2 (en) | 2013-11-25 | 2017-12-13 | インターナショナル・ビジネス・マシーンズ・コーポレーションＩｎｔｅｒｎａｔｉｏｎａｌ Ｂｕｓｉｎｅｓｓ Ｍａｃｈｉｎｅｓ Ｃｏｒｐｏｒａｔｉｏｎ | Method for obtaining execution frequency information of execution path on control flow graph, computer for obtaining the information, and computer program thereof |
| US11321218B1 (en) * | 2021-03-08 | 2022-05-03 | Correct Computation, Inc. | Automated generation of source code models from machine code for code analysis |
Family Cites Families (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO1990001738A1 (en) * | 1988-07-29 | 1990-02-22 | Hunter Systems Software, Inc. | Machine process for translating programs in binary machine language into another binary machine language |
| US5428786A (en) * | 1991-03-07 | 1995-06-27 | Digital Equipment Corporation | Branch resolution via backward symbolic execution |
| US5666296A (en) * | 1991-12-31 | 1997-09-09 | Texas Instruments Incorporated | Method and means for translating a data-dependent program to a data flow graph with conditional expression |
-
1997
- 1997-09-30 US US08/940,212 patent/US6233733B1/en not_active Expired - Lifetime
-
1998
- 1998-09-29 DE DE69833617T patent/DE69833617D1/en not_active Expired - Lifetime
- 1998-09-29 EP EP98307926A patent/EP0905617B1/en not_active Expired - Lifetime
- 1998-09-29 JP JP10313910A patent/JPH11242597A/en active Pending
- 1998-09-29 CA CA002249042A patent/CA2249042A1/en not_active Abandoned
Also Published As
| Publication number | Publication date |
|---|---|
| EP0905617A2 (en) | 1999-03-31 |
| EP0905617B1 (en) | 2006-03-01 |
| JPH11242597A (en) | 1999-09-07 |
| DE69833617D1 (en) | 2006-04-27 |
| US6233733B1 (en) | 2001-05-15 |
| EP0905617A3 (en) | 2002-08-14 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| EP0905617B1 (en) | Method for generating a java bytecode data flow graph | |
| US6412109B1 (en) | Method for optimizing java bytecodes in the presence of try-catch blocks | |
| US7380242B2 (en) | Compiler and software product for compiling intermediate language bytecodes into Java bytecodes | |
| US7725883B1 (en) | Program interpreter | |
| EP1258805B1 (en) | Placing exception throwing instruction in compiled code | |
| Smith et al. | An introduction to Machine SUIF and its portable libraries for analysis and optimization | |
| JP4183399B2 (en) | Multiple language compilation method and system | |
| US6078744A (en) | Method and apparatus for improving compiler performance during subsequent compilations of a source program | |
| US6874140B1 (en) | Debug annotations | |
| US20070006192A1 (en) | Intermediate representation for multiple exception handling models | |
| Miecznikowski et al. | Decompiling Java using staged encapsulation | |
| WO2013191852A1 (en) | Adaptive portable libraries | |
| US7124407B1 (en) | Method and apparatus for caching native code in a virtual machine interpreter | |
| JP2000347871A (en) | Automatic stub/adapter generator | |
| KR20010086159A (en) | Method for platform specific efficiency enhancement of java programs and software product therefor | |
| US6625807B1 (en) | Apparatus and method for efficiently obtaining and utilizing register usage information during software binary translation | |
| Cifuentes et al. | Experience in the design, implementation and use of a retargetable static binary translation framework | |
| CN113220326B (en) | Intelligent contract upgrading method and block chain system | |
| CN113220327B (en) | Intelligent contract upgrading method and block chain system | |
| Attardi et al. | CodeBricks: code fragments as building blocks | |
| Ung et al. | Dynamic re-engineering of binary code with run-time feedbacks | |
| Saleil | Simple Optimizing JIT Compilation of Higher-Order Dynamic Programming Languages | |
| Proebsting et al. | A new implementation of the Icon language | |
| Ben Asher et al. | The effect of unrolling and inlining for Python bytecode optimizations | |
| Klimiankou | Interpretizer: A Compiler-Independent Conversion of Switch-Based Dispatch into Threaded Code |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| EEER | Examination request | ||
| FZDE | Discontinued |