JP2000035893A - Method for statically initializing arrangement of data processing system, data processing method, data processing system and computer readable storage medium storing program making computer execute its control procedure - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a data processing system which economizes memory use quantity that is needed to statically initialize arrangement by reducing code quantity that is carried out by a virtual machine. SOLUTION: A preloader identifies the whole special methods (step 308) at the time of combining class files, executes the methods and decides static initialization to be executed (step 310). Next, the preloader produces an expression formula that shows the static initialization executed by the special method, stores the expression formula in m class file and replaces the special method with it (step 318). Thus, the code of a special method including many instructions is replaced with single expression that instructs the virtual machine to execute static initialization. Much memory capacity can be economized. The virtual machine is corrected so as to recognize the expression and performs appropriate static initialization of arrangement.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to a data processing system, and more particularly to a static initialization method and system.

[0002]

2. Description of the ^Related Art Java ^™ describes both a programming language and a programming environment in order to generate and execute platform-independent code. This platform-independent code runs on a Java ^™ virtual machine. The Java ^™ virtual machine is an abstract computer machine that interprets platform-independent code. For more information on the Java ^™ virtual machine, see Tim Lindholm and Frank Yellin: Addison Wesley Publishing (1997) “The Java ^™ Virtual Machine Specification”. The Java ^™ virtual machine does not specifically identify the Java ^™ programming language or any other programming language, but instead
The Java virtual machine recognizes a specific file format, that is, a class file format. The class file holds the instructions (or bytecode) of the Java virtual machine that constitutes the platform-independent code.

When executing a Java program, a developer
The work proceeds in the process shown in FIG. First, the developer compiles the computer program (step 10
2). In high-level languages such as the Java programming language,
The developer develops a computer program holding the source code, activates a Java ^™ compiler, and compiles the code. The Java compiler is part of the Java ^™ software developer kit available from Sun Microsystems of Mountain View, California. The Java compiler outputs one or more class files containing bytecode suitable for execution on a Java virtual machine. Each class file holds one type of class or interface. For more information on the class file format, see "The Java
^{According to the TM} Virtual Machine Specification, pages 83-137. According to this, the class file format is a robust file format.

[0004]

However, this class file format cannot instruct a virtual machine to efficiently perform static initialization of arrays. Hereinafter, this disadvantage will be described in detail. After compiling the program, the developer integrates the output of the class file in step 102 into a single file called an .m class file using a preloader (step 10).
Four). A preloader, available from Sun Microsystems, combines the class files and performs preprocessing that facilitates the execution of the class files. After integrating the class files, the developer loads the .m class file into the virtual machine (step 106). In this step, the Java virtual machine saves the .m class file in memory. Then, the Java virtual machine reads the bytecodes, interprets the bytecodes held in the .m class file, and processes and executes them. Until the bytecode interpretation is complete, the .m class file is stored in memory. Details of bytecodes recognized by the Java virtual machine are described in "The Java ^™ Virtual Machine Specification", pp. 151-338.

[Specifications] As described above, the class file format cannot instruct a virtual machine to perform static initialization of an array. In order to solve this problem, the Java ^™ compiler generates a special method <clinit> including a method for initializing a static array and initializes the class. An example of the initialization of the static array is shown in code table # 1 of Table 1.

[0006]

[Table 1]

In this example, the array "setup" holds the four statically initialized integers -1, 2, 3, 4. When the predetermined static initialization is performed, the Java ^™ compiler generates a <special> method for performing static initialization. This static initialization is functionally described by provisional code, and an example is shown in Code Table # 2 of Table 2.

[0008]

[Table 2]

As described in the above code table, when a <special> method is described functionally, several statements are required. However, the actual processing of the <special> method performed by the bytecode requires more statements. These bytecodes perform the required static initialization by processing the stack. A stack is a piece of memory used by many methods in the Java programming environment. Each step performed by the <special> method used in an example of the stack initialization described above is shown in a code table # 3 of Table 3.

[0010]

[Table 3]

The use of the <special> method provides a way to instruct the Java virtual machine to initialize a static array, but the amount of code required to initialize the array is Doing so many times will require a significant amount of memory. Therefore, it is necessary to improve the method of static initialization.

An object of the present invention is to provide a method for statically initializing an array, a data processing method, and a data processing system for a data processing system capable of saving a memory usage required for statically initializing an array. And a computer-readable storage medium storing a program for causing a computer to execute the control procedure.

[0013]

According to a first aspect of the present invention, there is provided a method for statically initializing an array of a data processing system, comprising the steps of: A compiling step of compiling a source code holding the static array to generate a class file with a special method that holds a bytecode to be a static value; and a receiving step of receiving the class file by a preloader. A pseudo-execution step of pseudo-executing the bytecode of the special method on a memory to identify static initialization of the array by the preloader;
A gist comprising a saving step of saving an instruction requesting static initialization of the array in an output file, and an interpreting step of causing a virtual machine to interpret the instruction in order to perform static initialization of the array. Is what you do.

[0014] In this case, the storing step may include a storing step of storing a constant pool entry in a constant pool.

The pseudo execution step may include a stack allocating step, a reading step of reading a bytecode from a special method for processing the stack, and a processing of the stack on the allocated stack. And a stack processing step. Alternatively, the pseudo execution step includes, as described in claim 4, a variable assignment step, a reading step of reading a bytecode from the special method for processing a local variable of the special method, and a local step on the assignment variable. A local variable processing step of processing a variable. Further alternatively, the pseudo-execution step may include, as described in claim 5, an acquisition step of acquiring a reference to a constant pool of the special method, and a special method of processing the constant pool. The method may include a reading step of reading a bytecode and a constant pool processing step of processing the constant pool.

Next, a data processing method according to claim 6 of the present invention includes a receiving step of receiving a code executed on a processing component to perform an operation;
A pseudo-execution step of pseudo-executing the code without executing the code on the processing component to identify the operation when the code is executed by the processing component; and And a creating step of creating an instruction for the processing component.

According to the data processing method of the sixth aspect having the above configuration, first, a code to be executed is received on a processing component that performs an operation. Next, the code is simulated on the memory, but the simulated execution is performed without executing the code on the processing component, and thus, the code is executed by the processing component. Will be identified. Thereafter, a command for the processing component is created, and the operation is performed.

If the operation is to initialize a data structure, the simulated execution step may include simulating the code to identify initialization of the data structure. It is good to execute. Alternatively, if the operation is to perform a static initialization of the array, the pseudo-execution step may include executing the code to identify the static initialization of the array, as described in claim 8. Should be executed.

Further, as described in claim 9, execution for executing the created instruction on the processing component for performing the operation (initialization of a data structure, static initialization of an array, and the like). Steps may be included.

Further, the present invention includes an interpretation step for causing the virtual machine to interpret the created instruction in order to perform the operation (initialization of a data structure, static initialization of an array, and the like). Good.

In the case where the operation (initialization of a data structure or static initialization of an array) has a memory effect, the pseudo-execution step may include the memory effect. Preferably, the code is simulated for identification.

Next, a data processing system according to a twelfth aspect of the present invention includes a storage device and a memory,
The storage device holds a program including a source code for performing static initialization of a data structure, and a class file including at least one class file holding a special method for performing static initialization of the data structure, The memory integrates the class file with a compiler that compiles the program to generate the class file, and simulates the special method to determine static initialization performed by the special method. The present invention comprises a preloader for creating an instruction for performing dynamic initialization, and a processor for operating the compiler and the preloader.

According to the data processing system having the above configuration, when the class files are integrated, all the <special> methods are identified by the preloader, and these methods are pseudo-executed. This determines the static initialization performed by those methods. Next, an expression indicating the static initialization performed by the <special> method is created by the preloader, and the expression is stored in the .m class file and replaced with the <special> method.
In this way, the code for the <special> method, which holds many instructions, is replaced by a single expression that instructs the virtual machine to perform static initialization. This saves a significant amount of memory and reduces the amount of code executed by the virtual machine. in this case,
The virtual machine has been modified to recognize this expression,
The appropriate array static initialization will be performed by this virtual machine.

[0024] In this case, the preloader is provided in claim 1.
Preferably, the memory comprises a mechanism for generating an output file containing the generated instructions, as described in claim 3, and the memory for performing its static initialization, as described in claim 14. And a virtual machine that interprets the created instruction.

Further, the data structure may be an array. The special method may include a bytecode for performing static initialization of the data structure. Further, the created instruction may include an entry to a constant pool, as described in claim 17.

[0026]

BEST MODE FOR CARRYING OUT THE INVENTION A system and method according to the present invention includes a <special> method and one or a plurality of instructions (by the virtual machine) for causing a virtual machine to perform the same static initialization as the <special> method. (When read) to provide an improved system and method for performing static initialization of arrays in the Java programming environment. The improved system and method requires less memory and requires less time. As a result, the memory can be removed when performing the static initialization of the array, and the memory can be effectively used.

[Overview] The system and method according to the present invention eliminates the need for a <special> method by performing a predetermined preprocessing in a preloader. In particular, the preloader receives the integration class files and scans them while searching for <special> methods. When the preloader finds the <special> method, it performs a simulation of the <special> method execution (ie, "pseudo execution") on the memory. This is to determine the memory effect of the <special> method if interpreted by the Java virtual machine. That is, the preloader is executed by the Java virtual machine <special>
It simulates the execution of the <special> method to identify any static initialization that might result in the method. After identifying this static initialization, the preloader generates one or more directives (or instructions) to perform the same static initialization as its <special> method and And replace it with the <special> method. These directives are then read by the Java virtual machine at run time,
Causes the virtual machine to perform the same static initialization done by the <special> method. The directive requires significantly less memory space than the <special> method. For example, the bytecode described in the above code table # 3 is reduced to the next command held in the .m class file. The .m class is an array of four integers, holding initial values 1, 2, 3, and 4. CONSTANT_Array T_INT 4 1 2 3 4 The virtual machine of this embodiment recognizes this expression and
The array is statically initialized, and the array is set to a predetermined value. As a result, the virtual machine according to the embodiment can eliminate the memory consumption required at the time of initialization of the static array as compared with the conventional virtual machine.

[Details of Implementation] FIG. 2 shows a configuration of a data processing system 200 according to the present invention. The data processing system 200 includes a computer system 202,
This computer system 202 is connected to the Internet 204. Computer system 202 has memory 2
06, auxiliary storage device 208, central processing unit (CPU) 21
0, an input device 212, and a video display 214. The memory 206 further includes a Java ^™ compiler 2
18, including a Java ^™ preloader 220 and a Java ^™ runtime system 221. Java ^TM runtime system 2
21 includes a Java ^™ virtual machine 222. The auxiliary storage device 208 includes a program 224 in the form of a source code,
Various class files 226 and .m class files 228 are included. Java ^TM Compiler 218
24 is compiled into one or more class files 226. Next, the preloader 220
And generates an .m class file 228. The .m class file is the union of all the class files. With this integration, the .m class file 228
Can be executed on the virtual machine 222.

The processing according to the present invention is performed by the preloader 220, and the preloader 220 searches for a <special> method. Then, when the <special> method is found, the preloader 200 performs (1) the <special> method when the <special> method is interpreted by the virtual machine 222.
> To determine the memory effect of the method
> Simulate the execution of a method, (2) generate static initialization directives that duplicate these memory effects, and (3)
> Output these directives to a .m class file to replace the methods. This will save a considerable amount of memory.

In addition, the processing according to the present invention is a virtual machine
This is performed by the virtual machine 222 so as to recognize the static initialization command of the preloader 200.
Is to correct. Although the preferred embodiment of the present invention is described as being stored in memory 206, as will be apparent to those skilled in the art, other computer readable media, such as auxiliary storage devices (hard disks, Floppy disk or CD-ROM
Etc.), carrier wave from the Internet 204, or
You may make it memorize | store in other forms of storage devices, such as RAM and ROM. Further, computer 202 may include additional or different components, as will be apparent to those skilled in the art.

[Preloader] FIG. 3 is a flowchart showing the steps performed by the preloader 220 according to the present invention to initialize the static array. In the first step performed by the preloader 220, the preloader 220
Reads a class file to obtain a <special> method (step 302). After obtaining the <special> method, the preloader 220 assigns various variables to be used during the pseudo execution (step 304). At the time of pseudo execution,
As described below, the preloader 220 simulates execution of the bytecode held in the <special> method by the virtual machine. These bytecodes handle the various data structures associated with the <special> method. Various data structures include constant pools, stacks or local variables (or registers)
Is included.

The constant pool is a table of variable length structure, and represents various string constants, class names, field names, and other constants referred to in the class file. The stack is the portion of memory used to store operands during the execution of the method. Therefore, the stack size is always the maximum space occupied by the operand during execution of this method. Local variables are the variables used by this method.

At the time of variable assignment, the preloader 220
Get a pointer to the method's constant pool, allocate an appropriate size for the stack, and allocate an array. The array assignment is made such that each entry of each array corresponds to each local variable. Pseudo execution operates on these variables as described below.

After assigning the variables, the preloader 220
> Read the bytecode from the method (step 306).
Next, the preloader 220 determines whether to recognize the bytecode (step 308). In this step, the preloader 220 recognizes a subset of all bytecodes. Here, this subset holds only byte codes that are normally used for performing static initialization of the array. The following is a list of bytecodes recognized by the preloader 220 according to the preferred embodiment.

[0035]

[Table 4]

Bytecodes other than those listed above are not recognized. Other bytecodes other than those described above indicate that the <special> method performs an additional function for static initialization of the array. In this case, the <special> method cannot be optimized. If the bytecode is not recognized, the preloader 220 determines that the bytecode is not suitable for optimization (pseudo execution), and the processing continues to step 316.

If the preloader 220 recognizes the bytecode, the preloader 220 simulates the operation reflected by the bytecode (step 31).
0). In this step, the preloader 220 simulates the bytecode based on the variable assigned in step 304. As a result, a value is popped off the stack, a local variable is updated, or a value is retrieved from the constant pool. In addition, the preloader 220 will encounter a "put static" bytecode indicating that a particular static variable should be initialized in a particular manner. If the preloader 220 receives such a bytecode, the preloader 220
Saves the requested initialization instructions in a hash table for later use. The hash table is as follows. Setup: = Array (1,2,3,4)

After performing the operation reflected by the bytecode, the preloader 220 determines whether there are any more bytecodes in the <special> method (step 314). If there is still a bytecode, the process returns to step 306. However, if there are no more bytecodes, the preloader 220 saves the instructions in the .m class file to perform static initialization of the array (step 31).
8). In this step, the preloader 220 saves the constant pool entry in the .m class file as follows.

This entry in the constant pool contains a specific array of four integers-each having an initial value of 1,
2, 3, 4 indicates that-is retained. At run time, the virtual machine encounters a reference to this constant pool when it initializes its class file to a .m class file and creates the appropriate array. as a result,
Many instructions held in the <special> method have been removed and will be represented as a single expression. This saves a considerable amount of memory and reduces the required time.

[Example of implementation of preloader]
The temporary code shown in Table 7 (code table # 5)
FIG. 4 illustrates an example of a preloader process according to the embodiment.
You. Preloader 220, "Java ^TMVirtual machine specification "104-106
Define a <special> method as described on the page
Receive the data structure of method information as a parameter
You. Then, the preloader 220
Performs bytecode simulation. It ’s worth explaining here.
Was noted as an example of an embodiment.
No. That is, a few bytecodes are
In the following, it is assumed that
You. However, all byte codes in code table # 4
That the code can be processed by this embodiment,
It is obvious to those skilled in the art.

[0041]

[Table 5]

[0042]

[Table 6]

[0043]

[Table 7]

[Virtual Machine According to Embodiment] As described above, the Java virtual machine 222 is a standard Java virtual machine defined in the "Java ^TM virtual machine specification" except that the following points are modified. Any machine is acceptable. Traditional virtual machines have various constant pool entries,
For example, CONSTANT_Integer, CONSTANT_String, and CON
STANT_Long, etc. These types of constant pool entries hold various types of variable information and also include their initial values. However, the virtual machine according to the embodiment also recognizes the CONSTANT_Array entry of the constant pool.

The format of the constant pool entry CONSTANT_Array in the class file format is as follows.

[0046]

[Table 8]

The u1 type field is one of the values listed in the table shown in Table 9.

[0048]

[Table 9]

The field ux object [length] is an array of values and provides the array elements. The number of elements in the array is given by the length field of the constant pool entry. The actual sizes of these values are as shown in Table 10 below.

[0050]

[Table 10]

The bytes shown in Table 10 are the actual values stored in the array elements for types other than T_CLASS. On the other hand, for T_CLASS, each u2 is itself an index to a constant pool entry. The referenced constant pool entry is CO
Must be one of NSTANT_Array, CONSTANT_Object, or a special constant pool entry 0 indicating a null value.

For example, to show the array int [] = {10, 20, 30, 40}; the constant pool entry would be as follows: Tag Type Size Initial value CONSTANT_Array T_INT 4 10 20 30 40

As another example, to indicate the array new Foo [3] / * all have been initialized to NULL * /, the constant pool entry would be: Tag Type Size Initial value Class CONSTANT_Array T_CLASS 3 0 0 0 xx Here, “xx” is an index of the constant pool indicating the class Foo in the constant pool.

The two-dimensional array is as follows. new byte [] [] = {{1, 2, 3, 4}, {5, 6, 7, 8}}; This two-dimensional array has two constant pool entries that encode the sub-arrays , And by holding two additional entries that indicate the association between the subsequences. This encoding corresponds to the array concept of Java ^™ as an object type and a multidimensional array as an array of arrays. The constant pool entry of the above two-dimensional array is as follows. Entry1: CONSTANT_Array T_BYTE 4 1 2 3 4 Entry2: CONSTANT_Array T_BYTE 4 5 6 7 8 Entry3: CONSTANT_Class with name "[[B" Tag type Size Initial value Class Entry 4: CONSTANT_Array T_CLASS 2 Entry1 Entry2 Entry2 Entry3 where Entry1, Entry2 and Entry3 are coded with 2 bytes of the index of the corresponding constant pool entry.

Although the system and method according to the present invention have been described based on the preferred embodiments, it is obvious to those skilled in the art that the present invention is not limited to the embodiments. Various modifications are possible in accordance with the spirit of the invention. The scope of the present invention is defined by the appended claims.

[0056]

As described above, according to the method for statically initializing an array of the data processing system according to the first aspect of the present invention, the array is statically initialized by the static initialization of the array. A compiling step of compiling a source code holding the static array to generate a class file with a special method for holding a bytecode to be executed; a receiving step of receiving the class file by a preloader; A pseudo-execution step of pseudo-executing the bytecode of the special method on a memory to identify a static initialization of an array, and a storage step of storing an instruction requesting the static initialization of the array in an output file And an interpretation step for causing a virtual machine to interpret the instruction in order to perform static initialization of the array, which is necessary for static initialization of the array. It is possible to save the memory usage.

According to the data processing method of claim 6 of the present invention, a receiving step of receiving a code executed on a processing component to perform an operation;
A pseudo-execution step of pseudo-executing the code without executing the code on the processing component to identify the operation when the code is executed by the processing component; and And a creating step of creating an instruction for the processing component, so that the memory usage required for static initialization of the array can be saved.

According to the data processing system of the present invention, when the class files are integrated, all the <special> methods are identified by the preloader, and these methods are pseudo-executed. Static initialization performed by the method is determined. Next, a single expression that indicates the static initialization performed by the <special> method is created by the preloader, and this single expression is saved in the .m class file and replaced with the <special> method. Can be This keeps many instructions
The code in the <special> method is replaced with a single expression that instructs the virtual machine to perform static initialization, thus reducing the amount of code executed by the virtual machine and The memory usage required for static initialization can be saved.

According to the method and system according to the present invention,
The present invention is extremely useful for the further development of the information and communication industry because the time required for processing is also reduced.

[Brief description of the drawings]

FIG. 1 is a flowchart of a program development process in a Java program environment.

FIG. 2 is a configuration diagram of a data processing system according to the present invention.

FIG. 3 is a flowchart of a process performed by a preloader shown in FIG. 2;

[Explanation of symbols]

 200 data processing system 202 computer system 204 internet 206 memory 208 auxiliary storage device 210 CPU 212 input device 214 video display 218 compiler 220 preloader 221 Java runtime system 224 program 226 class file 228 .m class file

 ────────────────────────────────────────────────── ─── Continued on the front page (72) Inventor Tuck Richard Dee United States 94114 California, Hill Street, San Francisco 343 (54) [Title of Invention] Static initialization method of array of data processing system, data -Data processing method, data processing system, and computer-readable storage medium storing a program for causing the computer to execute the control procedure

Claims (23)

[Claims] 1. A compile that compiles source code holding a static array in order to generate a class file with a special method that holds a bytecode having the array as a static value by statically initializing the array. A receiving step of receiving the class file by a preloader; and a pseudo execution step of pseudo executing the bytecode of the special method with respect to a memory in order to identify a static initialization of the array by the preloader. A storage step of storing an instruction requesting static initialization of the array in an output file; andan interpretation step of causing a virtual machine to interpret the instruction to perform static initialization of the array. Static initialization method of array of data processing system. 2. The method according to claim 1, wherein the storing step includes a storing step of storing a constant pool entry in a constant pool. 3. The pseudo execution step includes: a stack allocating step; a reading step of reading a bytecode from a special method for processing the stack; and a stack processing step of processing a stack on the allocated stack. The method for statically initializing an array of a data processing system according to claim 1, wherein: 4. The pseudo execution step includes: a variable assignment step; a reading step of reading a bytecode from the special method for processing a local variable of the special method; and a local variable processing for processing a local variable on the assignment variable. 2. The method according to claim 1, further comprising the steps of: 5. The quasi-execution step: an acquisition step of acquiring a reference to a constant pool of the special method; a reading step of reading a bytecode from the special method of processing the constant pool; 2. The method according to claim 1, further comprising a constant pool processing step of processing the data. 6. A receiving step for receiving code to be executed on a processing component to perform an operation; and on the processing component to identify the operation if the code was executed by the processing component. A data processing method, comprising: a pseudo-execution step of pseudo-executing the code without executing the code; and a creation step of creating an instruction for the processing component to perform the operation. 7. The method of claim 1, wherein the operation initializes a data structure, and the step of simulating includes simulating the code to identify the initialization of the data structure. Item 6. A data processing method according to Item 6. 8. The method of claim 1, wherein the operation performs a static initialization of the array, and the pseudo-execution step includes a pseudo-execution step of executing the code to identify the static initialization of the array. 7. The data processing method according to claim 6, wherein: 9. The data processing method according to claim 6, further comprising the step of executing the created instruction on the processing component to perform the operation. 10. The data processing method according to claim 6, further comprising an interpreting step of causing a virtual machine to interpret the created instruction to perform the operation. 11. The method of claim 6, wherein the operation has a memory effect, and wherein the pseudo-execution step includes a pseudo-execution step of pseudo-executing the code to identify the memory effect. Data processing method described. 12. A data processing system comprising a storage device and a memory, wherein the storage device includes a program including a source code for performing a static initialization of a data structure; and a static initialization of the data structure. A class file that includes at least one class file that holds a special method that performs a special method. The memory integrates the class file with a compiler that compiles the program to generate the class file. A preloader that simulates the special method to determine the static initialization to be performed and creates an instruction to perform the static initialization; and a processor that operates the compiler and the preloader. And a data processing system. 13. The data processing system according to claim 12, wherein the preloader includes a mechanism for generating an output file including the created instruction. 14. The data processing system according to claim 13, wherein the memory further includes a virtual machine that interprets the created instruction to perform the static initialization. 15. The data processing system according to claim 12, wherein said data structure is an array. 16. The data processing system according to claim 12, wherein the special method has a bytecode for performing static initialization of the data structure. 17. The data processing system according to claim 12, wherein the created instruction includes an entry to a constant pool. 18. A receiving procedure for receiving a code to be executed on a processing component to perform an operation, and on the processing component to identify the operation if the code was executed by the processing component. A program for causing a computer to execute a control procedure of a data processing system including a simulation procedure of simulating the code without executing the code and a creation procedure of creating an instruction for the processing component to perform the operation is stored. Computer readable storage medium. 19. The method according to claim 18, wherein the operation initializes a data structure, and wherein the simulation procedure includes a simulation procedure of simulating the code to identify the initialization of the data structure. A computer-readable storage medium according to claim 1. 20. The method of claim 20, wherein the operation performs a static initialization of the array, and wherein the simulation procedure includes a simulation procedure of simulating the code to identify the static initialization of the array. The computer-readable storage medium according to claim 18. 21. The computer-readable storage medium of claim 18, further comprising an execution step of executing the created instruction on the processing component to perform the operation. 22. The computer-readable storage medium according to claim 18, further comprising an interpretation step for causing a virtual machine to interpret the created instruction to perform the operation. 23. The method of claim 18, wherein the operation has a memory effect, and wherein the simulation procedure includes a simulation procedure of simulating the code to identify the memory effect. Computer-readable storage medium.