CN112631724A - Byte code instruction set simplifying method and system - Google Patents
Byte code instruction set simplifying method and system Download PDFInfo
- Publication number
- CN112631724A CN112631724A CN202011553334.3A CN202011553334A CN112631724A CN 112631724 A CN112631724 A CN 112631724A CN 202011553334 A CN202011553334 A CN 202011553334A CN 112631724 A CN112631724 A CN 112631724A
- Authority
- CN
- China
- Prior art keywords
- instruction
- instructions
- macro
- static method
- method call
- 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.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 162
- 230000003068 static effect Effects 0.000 claims description 80
- 230000006870 function Effects 0.000 claims description 31
- 238000005056 compaction Methods 0.000 claims description 14
- 230000009467 reduction Effects 0.000 claims description 6
- 239000008186 active pharmaceutical agent Substances 0.000 description 8
- 230000000694 effects Effects 0.000 description 4
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 238000007619 statistical method Methods 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 230000008569 process Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45504—Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
- G06F9/45516—Runtime code conversion or optimisation
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The invention discloses a method and a system for simplifying a byte code instruction set, which are suitable for an instruction set based on an operand stack and a register, wherein the method for simplifying the byte code instruction set comprises the following steps: converting an existing instruction into a macro instruction or merging instructions into a macro instruction. The invention replaces the existing instruction or combines a plurality of instructions into a macro instruction, thereby reducing the storage space of byte codes and improving the execution performance.
Description
Technical Field
The invention relates to the technical field of virtual machine instruction sets, in particular to a method and a system for simplifying a byte code instruction set.
Background
The virtual machine is an abstract computer generated by a software application or an instruction sequence executed by a processor, the virtual machine can execute an instruction set supported by the virtual machine, the instruction set comprises an operand stack-based instruction set and a register-based instruction set, the Java Card instruction set is based on the operand stack, and the Dalvik virtual machine instruction set is based on the register. The method for simplifying the instructions is simultaneously suitable for the two instruction sets.
Disclosure of Invention
Aiming at the defects in the prior art, the invention aims to provide a bytecode instruction set simplifying method and a bytecode instruction set simplifying system, so that the virtual machine bytecode is simplified, the storage space of the bytecode is reduced, and the execution performance of the bytecode is improved.
In order to achieve the purpose, the technical scheme adopted by the invention is as follows:
the invention provides a byte code instruction set simplifying method, which is suitable for an instruction set based on an operand stack and a register, and comprises the following steps:
converting an existing instruction into a macro instruction or merging instructions into a macro instruction.
Further, as described above, the method for compacting, wherein converting the existing instruction into a macro instruction comprises:
a1, counting the times of occurrence of each existing method call instruction in the API in SE applications of different industry types, and putting the existing method call instruction with the times reaching a first preset threshold value into a candidate list;
step A2, analyzing whether each existing method call instruction in the candidate list meets the applicable condition of being converted into a macro instruction, and putting the existing method call instruction meeting the applicable condition into a list to be converted;
step A3, putting the list to be converted into a configuration file;
step A4, searching the information of the static method from the constant pool based on the constant pool index of the static method call instruction, searching whether the corresponding static method call instruction exists in the configuration file based on the information of the static method, and converting the static method call instruction into the corresponding macro instruction when determining that the static method call instruction exists in the list to be converted.
Further, in the above simplification method, the applicable conditions include:
1) the existing method call instruction is a static method call instruction;
2) the frequency of the static method calling instruction reaches the first preset threshold value;
3) the function of the static method call instruction is realized by processing input parameters without depending on other methods or domains, feeding back the result of instruction execution by a method of outputting parameters or returning values, and realizing the function in the form of byte codes or native methods.
Further, in the compaction method, the merging the instructions into one macro-instruction includes:
step B1, counting and analyzing different byte code instruction sets converted by SE applications of different industry types, and identifying at least more than two instructions which can be merged and putting the instructions into a list to be merged;
step B2, determining whether to merge based on the frequency of the at least two instructions which can be merged in the list to be merged;
step B3, merging the at least two instructions which can be merged and have the times reaching a second preset threshold into a macro instruction;
wherein, the at least two instructions which can be merged include at least two instructions which can complete specific functions or have the same function.
Further, in the simplification method, the at least two or more instructions for completing the specific function are:
constant assignment instructions and group member access instructions for implementing access of the array members of the constant index; or
A constant assignment instruction and a static method invocation instruction for implementing a static method invocation of a constant parameter.
A bytecode instruction set compaction system adapted for operand stack-based and register-based instruction sets, the compaction system being configured to:
converting an existing instruction into a macro instruction or merging instructions into a macro instruction.
Further, as described above in the compaction system, the converting the existing instruction into a macro instruction includes:
counting the occurrence frequency of each existing method calling instruction in the API in SE applications of different industry types, and putting the existing method calling instruction with the frequency reaching a first preset threshold value into a candidate list;
analyzing whether each existing method call instruction in the candidate list meets the applicable condition of being converted into the macro instruction or not, and putting the existing method call instruction meeting the applicable condition into a list to be converted;
putting the list to be converted into a configuration file;
and searching information of the static method from a constant pool based on a constant pool index of the static method call instruction, searching whether a corresponding static method call instruction exists in the configuration file based on the information of the static method, and converting the static method call instruction into a corresponding macro instruction when the static method call instruction is determined to exist in the list to be converted.
Further, in the streamlined system as described above, the applicable conditions include:
1) the existing method call instruction is a static method call instruction;
2) the called times of the static method calling instruction reach the first preset threshold;
3) the function of the static method call instruction is realized by processing input parameters without depending on other methods or domains, feeding back the result of instruction execution by a method of outputting parameters or returning values, and realizing the function in the form of byte codes or native methods.
Further, as described above in the compaction system, the merging the instructions into one macro-instruction includes:
counting and analyzing different byte code instruction sets converted by SE applications of different industry types, and identifying at least more than two instructions which can be merged and putting the instructions into a list to be merged;
determining whether to merge based on the frequency of the at least two instructions which can be merged in the list to be merged;
merging the at least two instructions which can be merged and have the times reaching a second preset threshold value into a macro instruction;
wherein, the at least two instructions which can be merged include at least two instructions which can complete specific functions or have the same function.
Further, in the compaction system described above, the at least two instructions for performing specific functions are:
constant assignment instructions and group member access instructions for implementing access of the array members of the constant index; or
A constant assignment instruction and a static method invocation instruction for implementing a static method invocation of a constant parameter.
The invention has the beneficial effects that: the invention is suitable for an instruction set based on an operand stack and a register, can combine adjacent instructions with the same function, which appear for multiple times, into one macro instruction, combine multiple adjacent instructions which finish specific functions, which appear for multiple times, into one macro instruction, replace static method calls, which appear for multiple times, into one macro instruction, and reduce the storage space of byte codes and improve the execution performance by replacing the existing instruction or combining multiple instructions into one macro instruction.
Drawings
FIG. 1 is a flow chart illustrating a sub-step of a method for reducing a bytecode instruction set according to an embodiment of the invention;
fig. 2 is a schematic flowchart illustrating a partial step of a bytecode instruction set reduction method according to an embodiment of the present invention.
Detailed Description
The invention is described in further detail below with reference to the drawings and the detailed description.
The macro instruction provided by the invention is an extension of a standard instruction set, has one byte of independent operation code, can have one or more operands, and can convert the existing instruction or combine a plurality of instructions into one macro instruction, thereby reducing the storage space of byte codes and improving the execution performance. Because the macro instruction and the normal instruction need to use one operation code, the operation code of the existing instruction set uses the size of one byte, the number is limited, the instruction interpreter of the virtual machine is complicated to realize by excessively increasing the number of the instructions, and the codes of the virtual machine are increased, so that more storage space is occupied. Therefore, the design priority condition of the macro instruction is that the use frequency is high, and only the high frequency can achieve the purposes of not obviously increasing the complexity of realizing the virtual machine, reducing the size of the byte code of the application and improving the execution performance of the application.
The method of the present invention is applicable to the Java Card instruction set, the Dalvik instruction set, and the TGoMOS instruction set, and the method of the present invention is described below in terms of the TGoMOS instruction set. The TGoMOS instruction set, a reduced instruction set of micro-operating system bytecodes, includes six instructions.
The first instruction consists of an operation code, and the operation code contains parameter information of the first instruction in a hidden way; the first instructions include: instructions that imply both operands and register numbers into the opcode; instructions that imply register numbers into the opcodes; instructions to imply constant operands into opcodes; an array member access instruction for hiding the member type of the array member into the operation code; the type and parameters of the method call are implicit to the instruction in the opcode.
The second instruction is a high-frequency instruction with multiple instruction formats; the second instructions include: common arithmetic operation instructions having a plurality of operation formats; an array member access instruction in a 4-bit register format is adopted; an array creating instruction for hiding the member type of the array member into the operation code; based on the equal and unequal comparison results, branch instructions having multiple instruction formats.
A third instruction, wherein the third instruction comprises instructions with different instruction formats based on different parameter numbers; the third instructions include: based on different parameter numbers, static method call instructions with different instruction formats; virtual method call instructions with different instruction formats based on different parameter numbers; based on the number of different parameters, private instance method call instructions with different instruction formats.
The fourth instruction comprises an instruction of a common data type and an instruction of an uncommon data type, wherein the instruction of the common data type has a plurality of instruction formats, and the instruction of the uncommon data type has one instruction format; instructions of common data types include instructions of short data types, and instructions of less common data types include instructions of int data types.
A fifth instruction, the fifth instruction being an instruction having a single-byte constant pool index; the fifth instructions include: a static method call instruction with a single-byte constant pool index; a virtual method call instruction with a single-byte constant pool index; a static domain access instruction with a single-byte constant pool index; example Domain Access instructions with a one-byte constant pool index.
And the sixth instruction is a macro instruction. The sixth instruction includes: the method comprises the steps of converting a formed macro instruction based on a static method calling instruction and merging a plurality of instructions to form the macro instruction.
The embodiment of the invention provides a byte code instruction set simplifying method, which is suitable for an instruction set based on an operand stack and a register, and comprises a Java Card instruction set, a Dalvik instruction set and the TGoMOS instruction set (such as a sixth instruction), wherein the simplifying method comprises the following steps:
converting an existing instruction into a macro instruction or merging instructions into a macro instruction.
As shown in fig. 1, the step a of converting the existing instruction into a macro instruction includes:
a1, counting the frequency of the static method call instructions in the API appearing in SE applications of different industry types, and putting the static method call instructions with the frequency reaching a first preset threshold value into a candidate list;
step A2, analyzing whether each static method call instruction in the candidate list meets the applicable condition of being converted into the macro instruction, and putting the static method call instruction meeting the applicable condition into the list to be converted;
step A3, putting the list to be converted into a configuration file;
step A4, searching the information of the static method from the constant pool based on the constant pool index of the static method call instruction, searching whether the corresponding static method call instruction exists in the configuration file based on the information of the static method, and converting the static method call instruction into the corresponding macro instruction when determining that the static method call instruction exists in the list to be converted.
SE applications of different industries such as finance, telecommunication and traffic are selected, the applications accord with various industrial standards, different APIs are called to realize business logic, and then different byte code instruction sets are converted, so that the difficulty is moderate, and sufficient application scene coverage and representativeness are achieved; and then carrying out statistical analysis on the converted byte code instruction set to identify the instruction with high frequency capable of being replaced by the macroinstruction. Whether the macro instruction is implemented or not needs to be evaluated and replaced based on the occurrence frequency and the number of instructions to be increased, and the effect determination can be judged by setting a threshold value, for example, if a certain static method calling instruction appears more than 100 times in a plurality of typical applications, the static method called by the application is put into a candidate list. Placing static method call instructions which accord with applicable conditions in the candidate list into a list to be converted, wherein the applicable conditions comprise: 1) a static method in the API is required; 2) the application calling times of the static method are high; 3) the function of the static method is realized in the form of byte code or native method by processing input parameters, outputting parameters or returning values and feeding back the result of instruction execution. native methods, generally referred to as native methods implemented in C or assembly language. Based on the above applicable conditions, the following static method is preferably converted into macro instructions as shown in Table 1.
TABLE 1
As can be seen from table 1, the advantages of converting static method call instructions in the API into macro instructions include that the number of calls of these instructions is high, the execution performance of the application can be improved, and the size of the bytecode can be reduced, so as to save the storage space of the application, and the application developer need not pay attention to the implementation details of the macro instructions. In terms of instruction storage, a constant pool index is not required, and the size of an instruction can be reduced by 1 or 2 bytes every time the instruction occurs, or by N or 2N bytes if the instruction occurs N times. In the aspect of instruction execution, the method reduces the overhead of method calling and improves the speed of instruction execution.
As shown in fig. 2, the merging the instructions into one macro instruction in step B includes:
step B1, counting and analyzing different byte code instruction sets converted by SE applications of different industry types, and identifying at least more than two instructions which can be merged and putting the instructions into a list to be merged;
step B2, determining whether to merge based on the frequency of at least two instructions which can be merged in the list to be merged;
step B3, merging at least two instructions which can be merged and have the times reaching a second preset threshold into a macro instruction;
wherein, the at least two instructions which can be merged include at least two instructions which can complete specific functions or have the same function.
SE applications in different industries such as finance, telecommunication and traffic are selected, the applications meet various industrial standards, different byte code instruction sets are converted, the difficulty is moderate, and sufficient application scene coverage and representativeness are achieved; and then, carrying out statistical analysis on the converted bytecode instruction set to identify two or more instructions which can be combined. Whether the macro instruction is implemented or not needs to be determined based on the occurrence frequency and the number of instructions to be increased, and the effect after replacement is evaluated and determined, and the determination can be determined by setting a threshold, for example, if the combinable instructions occur more than 30 times in a plurality of applications, two or more instructions are recognized to be implemented as one macro instruction.
Aiming at the step B, the following instructions are included:
1. instructions for implementing array member access of constant indices are merged into a macro instruction.
The access to a given member of the array is typically implemented by two instructions, namely a constant assignment instruction and a group member access instruction. The two left-hand instructions are merged into the right-hand one-instruction implementation, as in table 2.
TABLE 2
As can be seen from table 2, the const instruction can be removed, and 2 or 3 bytes can be reduced, and the performance of the method can be improved due to the reduction of executing one instruction.
2. Instructions for implementing static method calls for a constant parameter are merged into a macroinstruction.
For example, in the aforementioned TGoMOS micro-operating system, an application calls the API of table 3 below to throw an exception.
TABLE 3
| Name of method | Function(s) |
| tgo.core.ISOException.throwIt(short reason) | Throw out exception |
| tgo.core.SystemException.throwIt(short reason) | Throw out exception |
| tgo.core.UserException.throwIt(short reason) | Throw out exception |
| tgo.core.TransactionException.throwIt(short reason) | Throw out exception |
| tgo.core.CryptoException.throwIt(short reason) | Throw out exception |
The method in Table 3 generally translates into two instructions: the constant assignment instruction and the class-specific throwIt method call instruction may be combined into a corresponding macro implementation, as shown in table 4.
TABLE 4
As can be seen from table 3, if an application makes 292 thwit method calls, the memory space can be saved 292 × 3-876 bytes, and the execution time can be saved 292 const instructions.
3. Adjacent functionally identical instructions are merged into a macro instruction, as in Table 5.
TABLE 5
As can be seen from table 5, the macro instruction can reduce the execution time of one instruction, in addition to one byte.
In addition, the virtual machine needs to support the following macro implementation, as shown in table 6.
TABLE 6
In order to verify that the compaction method of the invention has the technical effects of saving storage space and execution time, taking typical financial application as an example, the number of times of calling of the following method is counted. As can be seen from table 7, all the methods are invoked with a total memory space saving of 561 × 2 — 1122 bytes.
TABLE 7
| Name of method | Number of calls |
| makeShort | 15 |
| getShort | 98 |
| setShort | 67 |
| arrayCopy | 38 |
| arrayCopyNonAtomic | 258 |
| arrayCompare | 29 |
| arrayFillNonAtomic | 56 |
| Total up to | 561 |
In order to prove that the simplification method of the invention has more outstanding technical effects compared with the prior art, the TGoMOS instruction set and the Java Card instruction set are compared to call the macro instruction performance by the static method, other codes of the virtual machine system realized on the same chip are basically consistent except the byte code interpreter code, the average time of counting 1000 execution results is adopted for comparison, and the comparison result is shown in Table 8.
TABLE 8
From Table 8, it is clear that the performance of the macro instructions obtained using the reduction method of the present invention is better.
The invention also provides a byte code instruction set simplifying system, which is suitable for an instruction set based on an operand stack and a register, and comprises:
converting an existing instruction into a macro instruction or merging instructions into a macro instruction.
Converting the existing instruction into a macro instruction includes:
counting the occurrence frequency of each existing method calling instruction in the API in SE applications of different industry types, and putting the existing method calling instruction with the frequency reaching a first preset threshold value into a candidate list;
analyzing whether each existing method call instruction in the candidate list meets the applicable condition of being converted into the macro instruction or not, and putting the existing method call instruction meeting the applicable condition into a list to be converted;
putting the list to be converted into a configuration file;
searching the information of the static method from a constant pool based on a constant pool index of a static method call instruction, searching whether a corresponding static method call instruction exists from a configuration file based on the information of the static method, and converting the static method call instruction into a corresponding macro instruction when the static method call instruction is determined to exist in a list to be converted.
Applicable conditions include:
1) the existing method call instruction is a static method call instruction;
2) the calling times of the static method calling instruction reach a first preset threshold value;
3) the function realization of the static method call instruction does not depend on other methods or domains, only processes the input parameters, feeds back the result of instruction execution by a method of outputting parameters or returning values, and realizes the function realization in the form of byte codes or native methods.
Merging the plurality of instructions into one macro-instruction includes:
counting and analyzing different byte code instruction sets converted by SE applications of different industry types, and identifying at least more than two instructions which can be merged and putting the instructions into a list to be merged;
determining whether to merge based on the occurrence frequency of at least two instructions which can be merged in the list to be merged;
merging at least two instructions which can be merged and have the times reaching a second preset threshold value into a macro instruction;
wherein, the at least two or more than two instructions which can be merged comprise at least two or more than two instructions which can complete specific functions or at least two or more than two instructions with the same functions.
At least two instructions for completing specific functions are:
constant assignment instructions and group member access instructions for implementing access of the array members of the constant index; or
A constant assignment instruction and a static method invocation instruction for implementing a static method invocation of a constant parameter.
It will be apparent to those skilled in the art that various changes and modifications may be made in the present invention without departing from the spirit and scope of the invention. Thus, if such modifications and variations of the present invention fall within the scope of the claims of the present invention and their equivalents, the present invention is intended to include such modifications and variations.
Claims (10)
1. A byte code instruction set reduction method is suitable for an operand stack-based and register-based instruction set, and is characterized by comprising the following steps:
converting an existing instruction into a macro instruction or merging instructions into a macro instruction.
2. The compaction method of claim 1 wherein converting an existing instruction into a macro-instruction comprises:
a1, counting the times of occurrence of each existing method call instruction in the API in SE applications of different industry types, and putting the existing method call instruction with the times reaching a first preset threshold value into a candidate list;
step A2, analyzing whether each existing method call instruction in the candidate list meets the applicable condition of converting into macro instruction, and putting the existing method call instruction meeting the applicable condition into a list to be converted;
step A3, putting the list to be converted into a configuration file;
step A4, searching the information of the static method from the constant pool based on the constant pool index of the static method call instruction, searching whether the corresponding static method call instruction exists in the configuration file based on the information of the static method, and converting the static method call instruction into the corresponding macro instruction when determining that the static method call instruction exists in the list to be converted.
3. The compaction method of claim 2, wherein the applicable conditions comprise:
1) the existing method call instruction is a static method call instruction;
2) the called times of the static method calling instruction reach the first preset threshold;
3) the function of the static method call instruction is realized by processing input parameters without depending on other methods or domains, feeding back the result of instruction execution by a method of outputting parameters or returning values, and realizing the function in the form of byte codes or native methods.
4. The compaction method of claim 1 wherein merging the plurality of instructions into one macro-instruction comprises:
step B1, counting and analyzing different byte code instruction sets converted by SE applications of different industry types, and identifying at least more than two instructions which can be merged and putting the instructions into a list to be merged;
step B2, determining whether to merge based on the frequency of the at least two instructions which can be merged in the list to be merged;
step B3, merging the at least two instructions which can be merged and have the times reaching a second preset threshold into a macro instruction;
wherein, the at least two instructions which can be merged include at least two instructions which can complete specific functions or have the same function.
5. The compaction method of claim 4 wherein the at least two instructions that perform a particular function are:
constant assignment instructions and group member access instructions for implementing access of the array members of the constant index; or
A constant assignment instruction and a static method invocation instruction for implementing a static method invocation of a constant parameter.
6. A bytecode instruction set reduction system adapted for operand stack-based and register-based instruction sets, the reduction system being configured to:
converting an existing instruction into a macro instruction or merging instructions into a macro instruction.
7. The compaction system of claim 6 wherein converting an existing instruction into a macro instruction comprises:
counting the occurrence frequency of each existing method calling instruction in the API in SE applications of different industry types, and putting the existing method calling instruction with the frequency reaching a first preset threshold value into a candidate list;
analyzing whether each existing method call instruction in the candidate list meets the applicable condition of being converted into the macro instruction or not, and putting the existing method call instruction meeting the applicable condition into a list to be converted;
putting the list to be converted into a configuration file;
and searching information of the static method from a constant pool based on a constant pool index of the static method call instruction, searching whether a corresponding static method call instruction exists in the configuration file based on the information of the static method, and converting the static method call instruction into a corresponding macro instruction when the static method call instruction is determined to exist in the list to be converted.
8. The streamlining system of claim 7, wherein said applicable conditions include:
1) the existing method call instruction is a static method call instruction;
2) the called times of the static method calling instruction reach the first preset threshold;
3) the function of the static method call instruction is realized by processing input parameters without depending on other methods or domains, feeding back the result of instruction execution by a method of outputting parameters or returning values, and realizing the function in the form of byte codes or native methods.
9. The compaction system of claim 6 wherein merging the plurality of instructions into one macro-instruction comprises:
counting and analyzing different byte code instruction sets converted by SE applications of different industry types, and identifying at least more than two instructions which can be merged and putting the instructions into a list to be merged;
determining whether to merge based on the frequency of the at least two instructions which can be merged in the list to be merged;
merging the at least two instructions which can be merged and have the times reaching a second preset threshold value into a macro instruction;
wherein, the at least two instructions which can be merged include at least two instructions which can complete specific functions or have the same function.
10. The compaction system of claim 9 wherein the at least two or more instructions that perform a particular function are:
constant assignment instructions and group member access instructions for implementing access of the array members of the constant index; or
A constant assignment instruction and a static method invocation instruction for implementing a static method invocation of a constant parameter.
Priority Applications (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011553334.3A CN112631724A (en) | 2020-12-24 | 2020-12-24 | Byte code instruction set simplifying method and system |
| PCT/CN2021/104735 WO2022134536A1 (en) | 2020-12-24 | 2021-07-06 | Bytecode instruction set simplification method and system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011553334.3A CN112631724A (en) | 2020-12-24 | 2020-12-24 | Byte code instruction set simplifying method and system |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN112631724A true CN112631724A (en) | 2021-04-09 |
Family
ID=75324548
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011553334.3A Pending CN112631724A (en) | 2020-12-24 | 2020-12-24 | Byte code instruction set simplifying method and system |
Country Status (2)
| Country | Link |
|---|---|
| CN (1) | CN112631724A (en) |
| WO (1) | WO2022134536A1 (en) |
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2022134536A1 (en) * | 2020-12-24 | 2022-06-30 | 北京握奇数据股份有限公司 | Bytecode instruction set simplification method and system |
| WO2022134538A1 (en) * | 2020-12-24 | 2022-06-30 | 北京握奇数据股份有限公司 | Micro-operating system bytecode reduced instruction set and resource restriction apparatus |
| CN116466995A (en) * | 2023-06-16 | 2023-07-21 | 紫光同芯微电子有限公司 | Instruction based on compound instruction and operand optimization method and device thereof |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20030041322A1 (en) * | 2001-08-24 | 2003-02-27 | Sun Microsystems, Inc. | Frameworks for generation of java macro instructions for instantiating java objects |
| CN101329622A (en) * | 2008-02-08 | 2008-12-24 | 威盛电子股份有限公司 | Microprocessor and method for implementing macro instructions |
Family Cites Families (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6988261B2 (en) * | 2001-08-24 | 2006-01-17 | Sun Microsystems, Inc. | Frameworks for generation of Java macro instructions in Java computing environments |
| US7039904B2 (en) * | 2001-08-24 | 2006-05-02 | Sun Microsystems, Inc. | Frameworks for generation of Java macro instructions for storing values into local variables |
| CN101316201A (en) * | 2008-07-18 | 2008-12-03 | 中国工商银行股份有限公司 | Multi-terminal mode script device and data processing method and automatization test system |
| US20130013895A1 (en) * | 2011-07-06 | 2013-01-10 | Fs-Semi Co., Ltd. | Byte-oriented microcontroller having wider program memory bus supporting macro instruction execution, accessing return address in one clock cycle, storage accessing operation via pointer combination, and increased pointer adjustment amount |
| CN105892944B (en) * | 2016-03-30 | 2019-11-12 | 深圳忆联信息系统有限公司 | A kind of information processing method and electronic equipment |
| CN107358125B (en) * | 2017-06-14 | 2020-12-08 | 北京多思科技工业园股份有限公司 | Processor |
| CN112631724A (en) * | 2020-12-24 | 2021-04-09 | 北京握奇数据股份有限公司 | Byte code instruction set simplifying method and system |
-
2020
- 2020-12-24 CN CN202011553334.3A patent/CN112631724A/en active Pending
-
2021
- 2021-07-06 WO PCT/CN2021/104735 patent/WO2022134536A1/en active Application Filing
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20030041322A1 (en) * | 2001-08-24 | 2003-02-27 | Sun Microsystems, Inc. | Frameworks for generation of java macro instructions for instantiating java objects |
| CN101329622A (en) * | 2008-02-08 | 2008-12-24 | 威盛电子股份有限公司 | Microprocessor and method for implementing macro instructions |
Non-Patent Citations (1)
| Title |
|---|
| 张中锋: ""手持式气体检测仪的设计"", 《硕士电子期刊》, no. 2013, 15 July 2013 (2013-07-15), pages 7 * |
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2022134536A1 (en) * | 2020-12-24 | 2022-06-30 | 北京握奇数据股份有限公司 | Bytecode instruction set simplification method and system |
| WO2022134538A1 (en) * | 2020-12-24 | 2022-06-30 | 北京握奇数据股份有限公司 | Micro-operating system bytecode reduced instruction set and resource restriction apparatus |
| CN116466995A (en) * | 2023-06-16 | 2023-07-21 | 紫光同芯微电子有限公司 | Instruction based on compound instruction and operand optimization method and device thereof |
| CN116466995B (en) * | 2023-06-16 | 2024-06-11 | 紫光同芯微电子有限公司 | Instruction based on compound instruction and operand optimization method and device thereof |
Also Published As
| Publication number | Publication date |
|---|---|
| WO2022134536A1 (en) | 2022-06-30 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN112631724A (en) | Byte code instruction set simplifying method and system | |
| US7434030B2 (en) | Processor system having accelerator of Java-type of programming language | |
| EP0817996B1 (en) | Software emulation system with dynamic translation of emulated instructions for increased processing speed | |
| US20020013691A1 (en) | Method and apparatus for processor code optimization using code compression | |
| EP1253515A2 (en) | Method for verifying basic instruction arrangement in VLIW instructions for variable length VLIW processor | |
| CN112631722A (en) | Byte code instruction set simplifying method and system | |
| US20010029577A1 (en) | Microprocessor employing branch instruction to set compression mode | |
| US9021454B2 (en) | Operand and limits optimization for binary translation system | |
| CN114428639A (en) | Instruction simplification method and system of byte code instruction set | |
| US20090049431A1 (en) | Method and compiler of compiling a program | |
| WO2022134538A1 (en) | Micro-operating system bytecode reduced instruction set and resource restriction apparatus | |
| US7552313B2 (en) | VLIW digital signal processor for achieving improved binary translation | |
| US10216499B2 (en) | Method, program, and system for code optimization | |
| EP3931689A1 (en) | Device, processor, and method for splitting instructions and register renaming | |
| US7725692B2 (en) | Compact representation of instruction execution path history | |
| CN116610362B (en) | Method, system, equipment and storage medium for decoding instruction set of processor | |
| US10802854B2 (en) | Method and apparatus for interpreting bytecode instruction stream | |
| CN114816532B (en) | Register allocation method for improving RISC-V binary code density | |
| GB2378537A (en) | Power reduction in microprocessor systems | |
| US8583897B2 (en) | Register file with circuitry for setting register entries to a predetermined value | |
| JP2011501286A (en) | Java byte code conversion method | |
| US7194606B2 (en) | Method and apparatus for using predicates in a processing device | |
| JP3698949B2 (en) | Function allocation optimization apparatus for instruction cache, function allocation optimization method, and recording medium recording function allocation optimization procedure | |
| US9032187B2 (en) | Instruction execution | |
| CN112130899A (en) | Stack computer |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |