WO2021179697A1

WO2021179697A1 - Method and device for executing functional module in virtual machine

Info

Publication number: WO2021179697A1
Application number: PCT/CN2020/132824
Authority: WO
Inventors: 郭学鹏; 张磊
Original assignee: 支付宝(杭州)信息技术有限公司
Priority date: 2020-03-13
Filing date: 2020-11-30
Publication date: 2021-09-16
Also published as: CN111045793A

Abstract

A method and device for executing a functional module in a virtual machine. The method comprises: obtaining a WASM instruction sequence of the functional module; determining whether the WASM instruction sequence comprises predetermined continuous instructions, wherein corresponding combined instructions are preset for the predetermined continuous instructions; the predetermined continuous instructions have the same interpretation execution result as combined instructions corresponding to the predetermined continuous instructions; in the case where it is determined that the WASM instruction sequence comprises at least one group of predetermined continuous instructions, respectively combining each group of predetermined continuous instructions in the instruction sequence into corresponding combined instructions; and interpretating and executing the WASM instruction sequence subjected to instruction combination of the functional module.

Description

Method and device for executing function module in virtual machine

Technical field

One or more embodiments of this specification relate to the field of blockchain technology, and more specifically, to methods and devices for caching and executing smart contracts in a blockchain.

Background technique

Virtual Machine (Virtual Machine) is a complete computer system with complete hardware system functions that is simulated by software and runs in a completely isolated environment. Since the virtual machine can isolate the impact of the underlying hardware platform and operating system on the upper-layer applications, it is very beneficial to the development of the upper-layer applications. There is no need to pay attention to the details of the underlying platform in the upper-level application development process, only the specific business logic. After the development is completed, the virtual machine runs the upper-layer application and is responsible for converting the application code into code suitable for execution on the underlying platform. Specifically, in many scenarios, upper-level applications are written and developed by developers using high-level languages, and then compiled into bytecode by a compiler. Bytecode is an execution program, a binary file composed of a sequence of operation code (op code)-data pairs, which is a kind of intermediate code. Then, the interpreter in the virtual machine interprets and executes the instruction stream represented by the bytecode.

For example, in a blockchain application scenario that supports smart contracts, a virtual machine can be deployed in each node of the blockchain network. Users can write a smart contract in a high-level language, and then compile it into bytecode by a compiler, include the bytecode in the transaction used to deploy the smart contract, and publish it to the blockchain network, that is, deploy to the block In each node of the chain network. When the smart contract needs to be executed, the virtual machine in each node interprets and executes the bytecode.

With the emergence of the WASM language, more and more blockchains use WASM as the writing language for smart contracts. Correspondingly, the WASM virtual machine is used to execute smart contracts. WASM, or WebAssembly, is a binary instruction format designed for stack virtual machines launched by the W3C community organization, and it is a new platform-independent intermediate bytecode format. The WASM virtual machine is a stack type virtual machine in which the operands of all instructions are placed on the stack, that is, the operands are obtained from the stack for each operation, and the result is pushed onto the stack after the instruction execution ends.

In various application scenarios including but not limited to blockchain, the speed of interpretation and execution of bytecode instruction sequences by the WASM virtual machine interpreter is critical to the performance of the entire system. Therefore, it is hoped that there will be an improved scheme to further improve the execution efficiency of the bytecode instruction stream in the WASM virtual machine.

Summary of the invention

The embodiments of this specification aim to provide a more effective solution for executing function modules in a virtual machine.

In order to achieve the above objective, one aspect of this specification provides a method for executing a functional module in a virtual machine, the method comprising: obtaining a WASM instruction sequence of the functional module; determining whether the WASM instruction sequence includes a predetermined continuous instruction, The predetermined continuous instruction is preset with a corresponding combined instruction, and the predetermined continuous instruction and its corresponding combined instruction have the same interpretation execution result; in the case where it is determined that the WASM instruction sequence includes at least one group of predetermined continuous instructions , Merge each group of predetermined consecutive instructions in the instruction sequence into corresponding merged instructions respectively; interpret and execute the instruction-merged WASM instruction sequence of the functional module.

In one embodiment, the virtual machine is a virtual machine in a blockchain node, and the function module is a first function defined in a first contract, and obtaining the WASM instruction sequence of the function module includes: When the first transaction that calls the first function in the first contract is executed, the WASM command sequence of the first function is obtained based on the command sequence of the first contract stored in the local storage medium of the node.

In one embodiment, based on the instruction sequence of the first contract stored in the node local storage medium, obtaining the WASM instruction sequence of the first function includes obtaining the variable value of the first contract from the node local storage medium. The long coded instruction sequence decodes the variable-length coded instruction sequence of the first contract to obtain the WASM instruction sequence of the first function.

In one embodiment, interpreting the combined WASM instruction sequence for executing the function module includes interpreting the combined WASM instruction sequence for executing the first function based on the data field of the first transaction.

In one embodiment, the predetermined continuous instruction includes at least two instructions, and the operating parameter corresponding to the last instruction in the predetermined continuous instruction is associated with at least one instruction before the last instruction in the predetermined continuous instruction.

In one embodiment, the last instruction includes a basic operation instruction.

Another aspect of this specification provides an apparatus for executing a function module in a virtual machine. The apparatus includes: an acquiring unit configured to acquire a WASM instruction sequence of the functional module; and a determining unit configured to determine the WASM instruction Whether the sequence includes a predetermined continuous instruction, the predetermined continuous instruction is preset with a corresponding merge instruction, and the predetermined continuous instruction and its corresponding merged instruction have the same interpretation execution result; the merging unit is configured to determine the When the WASM instruction sequence includes at least one group of predetermined continuous instructions, each group of predetermined continuous instructions in the instruction sequence are respectively combined into corresponding combined instructions; the execution unit is configured to interpret and execute the instructions of the functional module Combined WASM instruction sequence.

In one embodiment, the virtual machine is a virtual machine in a blockchain node, and the function module is a first function defined in a first contract, wherein the acquiring unit is further configured to: During the first transaction of the first function in a contract, the WASM command sequence of the first function is obtained based on the command sequence of the first contract stored in the local storage medium of the node.

In one embodiment, the acquiring unit is further configured to acquire the variable-length-encoded instruction sequence of the first contract from the node local storage medium, and perform the variable-length-encoded instruction sequence of the first contract. Decode, get the WASM instruction sequence of the first function.

In an embodiment, the execution unit is further configured to interpret the combined WASM instruction sequence for executing the first function based on the data field of the first transaction.

Another aspect of this specification provides a computer-readable storage medium on which a computer program is stored. When the computer program is executed in a computer, the computer is caused to execute any of the above-mentioned methods.

Another aspect of this specification provides a computing device, including a memory and a processor, the memory stores executable code, and when the processor executes the executable code, any one of the above methods is implemented.

In the WASM instruction fusion scheme according to the embodiment of this specification, the predetermined continuous instruction is merged into a preset new instruction by loading and parsing the WASM code in the virtual machine, thereby reducing the number of instructions, shortening the code execution time, and improving the virtual machine effectiveness. In addition, through the solution of the embodiment of this specification, there is no need to change the instruction form of the smart contract stored in the blockchain, which has higher flexibility and applicability.

Description of the drawings

By describing the embodiments of this specification in conjunction with the accompanying drawings, the embodiments of this specification can be made clearer:

Figure 1 is a schematic diagram of the process of calling the function calculation in the contract SCORE in the blockchain network;

Figure 2 illustrates the data changes in the stack when the instruction sequence of the calculation function is interpreted in the WASM virtual machine;

Fig. 3 shows a flow chart of a method for executing the function calculation of the contract SCORE in a virtual machine according to an embodiment of the present specification;

Figure 4 schematically shows the data change process in the stack when the fusion instruction sequence of the calculation function is interpreted in the WASM virtual machine;

Figure 5 shows a flowchart of a smart contract caching and execution method according to another embodiment of this specification;

Fig. 6 shows an apparatus for executing function modules in a virtual machine according to an embodiment of the present specification.

Detailed ways

The embodiments of this specification will be described below in conjunction with the drawings.

As those skilled in the art know, the blockchain network includes several nodes, and each node can communicate with each other. In a blockchain such as a consortium chain, a user can send a transaction to any node in the blockchain through the client. The transaction can be an ordinary transfer transaction, or it can be used to deploy a smart contract or call a smart contract. Suppose that the user Bob of the blockchain wants to issue a smart contract Contract SCORE. The smart contract uses the following formula (1) to calculate the user's reward score s based on the user's consumption amount x and sales amount y in the platform, for example:

S=(x+y*2)*3 (1)

Bob can write the smart contract in a high-level language such as C++, and then use the compiler to convert the C++ smart contract into the following WASM instruction sequence:

Contract SCORE

function calculation(param x i32)(param y i32){

get_local y

i32.const 2

i32.mul

get_local x

i32.add

i32.const 3

i32.mul

}.

It can be understood that, for ease of reading, the above WASM instruction sequence is displayed in the form of text. In practice, the WASM instruction sequence is expressed in binary format, so that the above function calculation has the following form (here for simplicity, it is expressed in hexadecimal Show binary code):

{20y

41 02

6c

20x

6a

41 03

6c}.

Then, Bob can publish the transaction for deploying the SCORE contract to any node in the blockchain through his client. Therefore, each node in the blockchain network can obtain and deploy the above-mentioned contract SCORE in the local storage medium.

Figure 1 is a schematic diagram of the process of calling the function calculation in the contract SCORE in the blockchain network 100. The blockchain network 100 includes nodes A to D. The users of the blockchain can connect to any of the nodes A to D through the client. . Assuming that the user Alice of the blockchain wants to call the function calculation in the contract SCORE, Alice can send, for example, transaction 1 (Tx 1) to node A in the blockchain through her client to call the contract.

Specifically, as shown in Figure 1, in transaction 1, the from field can be the address of the caller Alice, and the to field is the contract name and contract address of the SCORE contract, indicating the smart contract called by the exchange. In the Data field, it contains the method or function name (calculation) in the contract to be called and the parameter value passed in (Alice's consumption amount x=50 and sales amount y=100).

Generally, after each node deploys the contract SCORE, when the transaction that calls the function calculation in the contract SCORE is executed later, the instruction sequence of the function calculation is obtained from the local storage medium, and the instruction sequence is executed sequentially.

Figure 2 illustrates the data changes in the stack when the instruction sequence of the calculation function is interpreted in the WASM virtual machine. In Figure 2a, the interpreter in the virtual machine interprets the execution instruction get_local y, and pushes the value of the parameter y obtained from the corresponding transaction of the function calculation of the call contract SCORE onto the stack, assuming that the value of y is 1000; in Figure 2b, By interpreting the execution instruction i32.const 2, the constant value 2 is pushed onto the stack; in Figure 2c, by interpreting the execution instruction i32.mul, the two latest values (that is, the value of the y parameter 1000 and the constant value) are first popped from the stack. Value 2), multiply them to obtain the product 2000, and then push the result 2000 into the stack. In Figure 2c, the dotted line indicates that after 1000 and 2 are popped, 1000 and 2 are no longer in the stack; in Figure 2d By interpreting the execution instruction get_local x, the value 500 of the parameter x obtained from the corresponding transaction is pushed into the stack, assuming that the value of x is 500; in Figure 2e, the execution instruction i32.add is interpreted from the stack Pop two values (that is, the product result of the above multiplication 2000 and the value of parameter x 500), add them to obtain the sum 2500, and then push the result 2500 onto the stack; in Figure 2f, the instruction i32 is executed through interpretation .const 3, push the constant value 3 into the stack; in Figure 2g, by interpreting the execution instruction i32.mul, two values are popped from the stack (that is, the result of the above addition is 2500 and the constant value 3), and they are added together Multiply to obtain the product 7500, and then push the result 7500 into the stack, so that the remaining value 7500 in the stack is the return value of executing the function. It can be seen from this process that if the above instruction sequence is directly executed, there will be multiple data push and data pop processes on the stack, which consumes more time.

In order to reduce the time to execute the calculation of the calling function, in the embodiment of this specification, in the calling process, the predetermined consecutive instructions in the WASM instruction sequence of the function calculation are merged in the WASM virtual machine to obtain the fused instruction sequence, and Execute the fused instruction sequence, which can greatly reduce the execution time.

Specifically, after Alice publishes transaction 1 to the blockchain, each node can obtain transaction 1, and execute the function calculation in the contract SCORE through the WASM virtual machine, thereby returning the contract execution result. Among them, for example, when transaction 1 is executed in the virtual machine of node D, the command sequence of the contract SCORE is obtained from the local storage medium, the WASM command sequence of the function calculation is obtained therefrom, the WASM command sequence of the function calculation is fused, and based on The data field of transaction 1 interprets and executes the instruction sequence fused with instructions, thereby shortening the transaction execution time.

It can be understood that FIG. 1 and the corresponding description are only schematic and not restrictive. For example, the blockchain network is not limited to a consortium chain network, but may also be a public chain network. In addition, the WASM instruction sequence is not limited to the instruction sequence of the smart contract in the blockchain, but may also be the instruction sequence of the computing module in other application scenarios. In the following, a smart contract in the blockchain will be taken as an example for an exemplary description.

Fig. 3 shows a flow chart of a method for executing function calculation of contract SCORE in a virtual machine according to an embodiment of the present specification, including steps S302 to S308.

Step S302: Obtain the WASM instruction sequence of the function calculation.

Step S304: Determine whether the WASM instruction sequence includes a predetermined continuous instruction, the predetermined continuous instruction is preset with a corresponding combined instruction, and the predetermined continuous instruction and its corresponding combined instruction have the same interpretation execution result.

Step S306: In a case where it is determined that the WASM instruction sequence includes at least one group of predetermined continuous instructions, each group of predetermined continuous instructions in the instruction sequence is merged into corresponding merged instructions.

Step S308: Interpret the combined WASM instruction sequence that executes the calculation function.

The following describes the execution process of each step in FIG. 3 in detail.

Step S302: Obtain the WASM instruction sequence of the function calculation.

As described above, when a transaction (for example, transaction 1) that calls a certain function in the contract SCORE (for example, function calculation) is executed, the pre-deployed contract SCORE instruction sequence can be found from the local storage medium. Usually, a key value table corresponding to each contract is generated in a storage medium (such as a hard disk), where the key is the hash value of the contract name, and the value is the storage address of the contract, so that the hash value of the contract address of the contract SCORE can be retrieved. Hopefully, find the storage address of the contract SCORE in the storage medium, so that the instruction sequence of the contract SCORE can be read from the storage medium according to the storage address.

In one embodiment, the instruction sequence of the contract SCORE stored in the storage medium is a WASM instruction sequence, so that the WASM instruction sequence of the contract SCORE can be directly obtained from the storage medium, so that the WASM instruction sequence of the function calculation can be obtained therefrom. .

In one embodiment, the instruction sequence of the SCORE contract stored in the storage medium is encoded in a leb 128 variable-length encoding method, so as to reduce the file size and make better use of storage space. Leb 128, or "Little-Endian Base 128", is a variable-length encoding for any signed or unsigned integer. Therefore, an integer encoded with Leb128 will change the number of bytes according to the size of the number. According to the encoding method of leb 128, of the 8 bits (8 bits) of each byte, the lower 7 bits are the valid data part, and the highest bit is used to indicate whether the current byte is the last byte, and 1 means the last byte. Byte, 0 means it is not the last byte, that is, the subsequent bytes need to be continued. In this way, different numbers of bytes can be used to encode integers of different sizes.

Correspondingly, for the leb-encoded instruction sequence, when decoding the data, each byte is first restored to 8 bits, and the highest bit is used to determine whether to follow the following bytes to form the target data together. Therefore, if the instruction sequence is decoded, an instruction of variable length will be obtained. In order to store these instructions, variable-length instructions can be converted into memory-aligned fixed-length instructions. In this way, the WASM instruction sequence of the contract SCORE can be obtained. After the WASM instruction sequence of the contract SCORE is obtained, the WASM instruction sequence of the function calculation can be obtained.

It can be understood that in this embodiment, it is not limited to obtain the WASM instruction sequence from the local storage medium of the node. For example, in one embodiment, the pre-cached WASM instruction sequence of the SCORE contract can be read from the memory.

In step S304, it is determined whether the WASM instruction sequence includes a predetermined continuous instruction, the predetermined continuous instruction is preset with a corresponding merged instruction, and the predetermined continuous instruction and its corresponding merged instruction have the same interpretation execution result.

The predetermined continuous instruction is a number of predetermined continuous instructions that can be combined. For such predetermined continuous instructions, a corresponding combined instruction and a machine code corresponding to the combined instruction have been set in advance, and the machine code is executing After that, the corresponding consecutive instructions have the same execution result.

For example, for the instruction sequence of the above function calculation, a combined instruction “i32.mul y, const 2” can be preset relative to the continuous instruction “get_local y/i32.const 2/i32.mul”. Similarly, the combined instruction actually The middle is a binary code, and a binary code that is not used in the WASM instruction set can be selected to represent the combined instruction. At the same time, in the interpreter of the virtual machine, a machine code (machine code) corresponding to the combined instruction is preset, and the corresponding operation of the machine code is to obtain the value of parameter y, and compare the value of parameter y with 2. Multiply and push the product into the stack, where the value of the parameter y can be obtained from the data in the transaction that calls the SCORE contract. It can be seen that the operation result of the machine code corresponding to the combined instruction is the same as the execution result of the machine code corresponding to the three consecutive instructions, and the product of the value of the parameter y and 2 is pushed onto the stack.

In addition, a combined instruction "i32.add x" can be preset relative to the continuous instruction "get_local x/i32.add", and at the same time, the machine code corresponding to the combined instruction is preset in the interpreter of the virtual machine , The corresponding operation of this machine code is to pop the latest value from the stack, get the value of parameter x, add the popped value to the value of parameter x, and push the result of the addition into the stack, where Get the value of x from the transaction data of the call contract SCORE. It can be seen that the operation result of the machine code corresponding to the combined instruction is the same as the execution result of the machine code corresponding to the two consecutive instructions, both of which are the result of adding the product and the value of the parameter x to the stack.

In addition, a combined instruction “i32.mul const 3” can be preset relative to the continuous instruction “i32.const 3/i32.mul”, and at the same time, the virtual machine interpreter is preset to correspond to the combined instruction The machine code corresponding to the machine code is to pop the latest value from the stack, multiply the popped value by 3, and push the product into the stack. It can be seen that the operation result of the machine code corresponding to the combined instruction is the same as the execution result of the machine code corresponding to the two consecutive instructions. Both the result of the above addition and the product of 3 are pushed into the stack, and the final push is The value in the stack is the return value of the function.

It can be seen from the above three examples that in the predetermined consecutive instructions, each instruction has a certain correlation. For example, for the continuous instruction "get_local y/i32.const 2/i32.mul", the last instruction i32.mul will use the obtained value (y) or immediate value (ie constant 2) of the previous two instructions. In addition to the multiplication and addition instructions, the last instruction in the predetermined continuous instruction may also be a basic operation instruction such as a subtraction instruction and a division instruction, so that instruction merging can be performed similarly.

For example, in the above step S304, it has been determined that the instruction sequence includes three sets of predetermined consecutive instructions, so that the three sets of instructions can be merged into corresponding merged instructions respectively, that is, the merged WASM instruction sequence is:

{i32.mul y const 2

i32.add x

i32.mul const 3

}.

That is, based on the data field of transaction 1, the combined WASM instruction sequence that executes the calculation function is interpreted.

FIG. 4 schematically shows the data change process in the stack when the fusion instruction sequence of the calculation execution function is interpreted in the WASM virtual machine. For the above-mentioned fusion instruction sequence of function calculation obtained in step S306, in Fig. 4a, in a virtual machine such as node D, the execution instruction i32.mul y const2 is first interpreted by an interpreter, specifically by interpreting the combined instruction, Obtain the preset machine code of the merge instruction, and then execute the machine code, thereby obtaining the value of parameter y 1000 from the data field of transaction 1, and multiplying 1000 by the constant 2 to obtain the product 2000, and then multiply the product 2000 pushed into the stack. It can be seen from Figure 4a that the interpretation and execution of the merge instruction i32.mul y const 2 only pushes data once to the stack, that is, pushes the product 2000. In Figure 2, the interpretation and execution corresponds to the merge instruction for three consecutive times. This instruction, referring to Figures 2a-2c, needs to push data into the stack three times and pop the data once from the stack to obtain the result of pushing the product 2000 into the stack. Comparing FIGS. 4a and 2a-2c, it can be seen that through the fusion instruction sequence solution according to the embodiment of the present specification, the operation process of the stack in the virtual machine is greatly simplified, and the transaction execution speed is accelerated.

Similarly, in Figure 4b, the execution instruction i32.add x is interpreted in the virtual machine of node D, and the value in it is popped from the stack, that is, 2000. The value of parameter x is obtained from the data of transaction 1. Add to get the sum 2500 and push 2500 onto the stack. The interpretation and execution of the merge instruction corresponds to Fig. 2d and Fig. 2e in Fig. 2. It can be seen that by merging the two instructions get_local x and i32.add, when interpreting and executing the merge instruction, the data push to the stack is reduced. , To speed up the contract execution speed.

In Figure 4c, the execution instruction i32.mul const 3 is interpreted in the virtual machine of node E or node D, and the latest value, namely 2500, is popped from the stack, and it is multiplied by the constant 3 to obtain the

product

7500, and 7500 is pushed into the stack.

By comparing Figure 2 and Figure 4, it can be intuitively concluded that by fusing the instruction sequence according to the method shown in Figure 3, compared to interpreting and executing the initial instruction sequence, the stack is more accurate when interpreting and executing the fused instruction sequence. Fewer data operations achieve the same contract execution result, which greatly accelerates the contract execution speed.

Fig. 5 shows a flowchart of a smart contract caching and execution method according to another embodiment of the present specification. The method is executed in a virtual machine of any node in the blockchain, and includes the following steps.

Step S502, in response to transaction 2 received by the blockchain node, obtain the WASM instruction sequence of the contract SCORE from the local storage medium. In the transaction 2, the function calculation in the contract SCORE is called.

Step S504: Determine whether the WASM instruction sequence includes a predetermined continuous instruction, the predetermined continuous instruction is preset with a corresponding combined instruction, and the predetermined continuous instruction and its corresponding combined instruction have the same interpretation execution result.

Step S506: In a case where it is determined that the WASM instruction sequence includes at least one group of predetermined continuous instructions, each group of predetermined continuous instructions in the instruction sequence is merged into corresponding merged instructions, respectively.

The execution of step S502 to step S506 can refer to the above description of step S302 to step S306, which will not be repeated here. The difference is that the WASM command sequence in these steps is the contract SCORE command sequence.

In step S508, the WASM instruction sequence combined with the instruction is cached in the memory in association with the contract SCORE.

In an implementation manner, node D can allocate a starting address for storing the WASM instruction sequence in its memory, so that the instruction sequence is stored in the memory starting from the starting address, and the instruction sequence in the The parameters related to the storage start address are modified to the start address, and the contract SCORE is recorded in a predetermined table in the memory corresponding to the start address. The table records key-value pairs, for example, the key is, for example, the hash value of the contract address of the contract SCORE, and the value is the start address.

After the WASM instruction sequence merged by the instructions is cached in the memory, when the node again receives a transaction that calls a function in the contract SCORE (function calculation or other functions), the cached contract SCORE can be directly obtained from the memory The fusion instruction sequence of this function eliminates the need to obtain the instruction sequence from the storage medium and perform the instruction fusion process every time a transaction that calls the function in the SCORE contract is executed.

In step S510, based on the data field of transaction 2, the fused instruction sequence of the function calculation of the execution contract SCORE is interpreted.

For this step, reference may be made to the above description of step S308, which will not be repeated here.

It can be understood that although the above example uses the fusion of the instruction sequence of the smart contract in the WASM virtual machine to illustrate the method steps and the technical effects brought by the fusion of the WASM instruction sequence in the virtual machine, the embodiment of this specification does not Limited to the above-mentioned embodiment. The WASM language can be used in a variety of scenarios. For example, in AutoCAD, Google Earth, Unity, and WebPack, the corresponding functions are implemented by executing the WASM program in a virtual machine. In these scenarios, similarly, when executing the function module, by In the virtual machine, the instruction sequence of the functional module is merged in the static analysis stage, so that when the merged instruction sequence is executed, the program execution time can be greatly reduced, and the merged instruction sequence can be cached in the memory to perform repeated functions. , The cached fusion instruction sequence can be directly obtained from the memory, further accelerating the execution speed of the program.

FIG. 6 shows an apparatus 600 for executing functional modules in a virtual machine according to an embodiment of the present specification. The apparatus includes: an acquiring unit 61, a determining unit 62, a merging unit 63, and an executing unit 64.

The obtaining unit 61 is configured to obtain the WASM instruction sequence of the functional module.

The determining unit 62 is configured to determine whether a predetermined continuous instruction is included in the WASM instruction sequence, the predetermined continuous instruction is preset with a corresponding combined instruction, and the predetermined continuous instruction and its corresponding combined instruction have the same interpretation and execution result.

The merging unit 63 is configured to, in a case where it is determined that the WASM instruction sequence includes at least one group of predetermined consecutive instructions, merge each group of predetermined consecutive instructions in the instruction sequence into corresponding merged instructions, respectively.

The execution unit 64 is configured to interpret and execute the combined WASM instruction sequence of the functional module.

In one embodiment, the virtual machine is a virtual machine in a blockchain node, and the function module is a first function defined in a first contract. The acquiring unit 61 is further configured to execute the call During the first transaction of the first function in the first contract, the WASM command sequence of the first function is obtained based on the command sequence of the first contract stored in the local storage medium of the node.

In one embodiment, the obtaining unit 61 is further configured to obtain the variable-length-encoded instruction sequence of the first contract from the local storage medium of the node, and obtain the variable-length-encoded instruction sequence of the first contract Decode and get the WASM instruction sequence of the first function.

In one embodiment, the execution unit 64 is further configured to interpret the instruction-fused WASM instruction sequence for executing the first function based on the data field of the first transaction.

It needs to be understood that the descriptions of "first", "second", etc. in this article are only used to distinguish similar concepts for the sake of simplicity of description, and do not have other limiting effects.

The various embodiments in this specification are described in a progressive manner, and the same or similar parts between the various embodiments can be referred to each other, and each embodiment focuses on the difference from other embodiments. In particular, as for the system embodiment, since it is basically similar to the method embodiment, the description is relatively simple, and for related parts, please refer to the part of the description of the method embodiment.

The foregoing describes specific embodiments of this specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps described in the claims can be performed in a different order than in the embodiments and still achieve desired results. In addition, the processes depicted in the drawings do not necessarily require the specific order or sequential order shown in order to achieve the desired results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

Those of ordinary skill in the art should be further aware that the units and algorithm steps of the examples described in the embodiments disclosed herein can be implemented by electronic hardware, computer software or a combination of the two, in order to clearly illustrate the hardware For the interchangeability with software, the composition and steps of each example have been described generally in terms of function in the above description. Whether these functions are executed by hardware or software depends on the specific application and design constraint conditions of the technical solution. A person of ordinary skill in the art may use different methods for each specific application to implement the described functions, but such implementation should not be considered beyond the scope of the present application. Among them, the software module can be placed in random access memory (RAM), memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, register, hard disk, removable disk, CD-ROM, or technical fields Any other form of storage medium known within.

The specific embodiments described above further describe the purpose, technical solutions and beneficial effects of the present invention in detail. It should be understood that the above are only specific embodiments of the present invention, and are not intended to limit the scope of the present invention. The scope of protection, any modification, equivalent replacement, improvement, etc., made within the spirit and principle of the present invention shall be included in the scope of protection of the present invention.

Claims

A method for executing functional modules in a virtual machine, the method including:

Acquiring the WASM instruction sequence of the functional module;

Determine whether the WASM instruction sequence includes a predetermined continuous instruction, the predetermined continuous instruction includes a plurality of instructions arranged consecutively, the predetermined continuous instruction is preset with a corresponding merge instruction, the merge instruction is a single instruction, and The predetermined continuous instruction and its corresponding combined instruction have the same interpretation and execution result;

In a case where it is determined that the WASM instruction sequence includes at least one group of predetermined continuous instructions, each group of predetermined continuous instructions in the instruction sequence is respectively merged into corresponding merged instructions;

Interpret the combined WASM instruction sequence that executes the function module.
The method according to claim 1, wherein the virtual machine is a virtual machine in a blockchain node, the function module is a first function defined in a first contract, and the WASM instruction of the function module is obtained The sequence includes obtaining the WASM instruction sequence of the first function based on the instruction sequence of the first contract stored in the local storage medium of the node when the first transaction that calls the first function in the first contract is executed.
The method according to claim 2, wherein, based on the instruction sequence of the first contract stored in the node local storage medium, obtaining the WASM instruction sequence of the first function includes obtaining the first contract from the node local storage medium The variable-length-encoded instruction sequence of the first contract is decoded to obtain the WASM instruction sequence of the first function.
The method according to claim 2, wherein interpreting the instruction-merged WASM instruction sequence that executes the function module comprises, based on the data field of the first transaction, interpreting the instruction-merged WASM that executes the first function Sequence of instructions.
The method according to claim 1, wherein the predetermined continuous instruction includes at least two instructions, and the operating parameter corresponding to the last instruction in the predetermined continuous instruction is at least one before the last instruction in the predetermined continuous instruction. The instruction is associated.
The method according to claim 5, wherein the last instruction includes a basic operation instruction.
A device for executing function modules in a virtual machine, the device comprising:

The obtaining unit is configured to obtain the WASM instruction sequence of the functional module;

The determining unit is configured to determine whether a predetermined continuous instruction is included in the WASM instruction sequence, the predetermined continuous instruction includes a plurality of instructions arranged consecutively, the predetermined continuous instruction is preset with a corresponding merge instruction, and the merge instruction Is a single instruction, and the predetermined consecutive instruction and its corresponding combined instruction have the same interpretation and execution result;

The merging unit is configured to, in a case where it is determined that the WASM instruction sequence includes at least one group of predetermined consecutive instructions, merge each group of predetermined consecutive instructions in the instruction sequence into corresponding merged instructions respectively;

The execution unit is configured to interpret and execute the combined WASM instruction sequence of the functional module.
8. The device according to claim 7, wherein the virtual machine is a virtual machine in a blockchain node, and the function module is a first function defined in a first contract, and wherein the obtaining unit is further configured to: When the first transaction that calls the first function in the first contract is executed, the WASM command sequence of the first function is obtained based on the command sequence of the first contract stored in the local storage medium of the node.
8. The device according to claim 8, wherein the obtaining unit is further configured to obtain the variable-length-encoded instruction sequence of the first contract from the local storage medium of the node, and to obtain the variable-length-encoded instruction sequence of the first contract Decode the instruction sequence of the first function to obtain the WASM instruction sequence of the first function.
8. The device according to claim 8, wherein the execution unit is further configured to interpret the combined WASM instruction sequence for executing the first function based on the data field of the first transaction.
8. The apparatus according to claim 7, wherein the predetermined continuous instruction includes at least two instructions, and the operating parameter corresponding to the last instruction in the predetermined continuous instruction is at least one of the operating parameters before the last instruction in the predetermined continuous instruction. The instruction is associated.
The apparatus according to claim 11, wherein the last instruction includes a basic operation instruction.
A computer-readable storage medium having a computer program stored thereon, and when the computer program is executed in a computer, the computer is caused to execute the method according to any one of claims 1-6.
A computing device includes a memory and a processor, the memory stores executable code, and when the processor executes the executable code, the method according to any one of claims 1 to 6 is implemented.