CN109542455B - Contract execution method, contract reduction method, device, and storage medium - Google Patents
Contract execution method, contract reduction method, device, and storage medium Download PDFInfo
- Publication number
- CN109542455B CN109542455B CN201811447697.1A CN201811447697A CN109542455B CN 109542455 B CN109542455 B CN 109542455B CN 201811447697 A CN201811447697 A CN 201811447697A CN 109542455 B CN109542455 B CN 109542455B
- Authority
- CN
- China
- Prior art keywords
- intelligent contract
- contract
- byte code
- identifier
- bytecode
- 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.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
- G06F21/60—Protecting data
- G06F21/64—Protecting data integrity, e.g. using checksums, certificates or signatures
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Computer Security & Cryptography (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Health & Medical Sciences (AREA)
- Bioethics (AREA)
- General Health & Medical Sciences (AREA)
- Computer Hardware Design (AREA)
- Management, Administration, Business Operations System, And Electronic Commerce (AREA)
Abstract
The invention provides a contract execution method, a contract simplification method, equipment and a storage medium, wherein the method comprises the following steps: judging whether the first intelligent contract to be executed is simplified according to the first identifier: if yes, loading a corresponding first byte code from the node database; combining the first intelligent contract and the first byte code to generate a second intelligent contract, and executing the second intelligent contract; and the first intelligent contract is generated by cutting a first byte code and adding a first identifier to a third intelligent contract by the modified compiler. The invention reduces the size of the intelligent contract, reduces the consumption of resource storage or resource transmission in the block chain system, and improves the storage efficiency of the block chain nodes.
Description
Technical Field
The present application relates to the field of block chain technology, and in particular, to a contract execution method, a contract simplification method, a device, and a storage medium.
Background
wasm is a binary file of WebAssembly, contains binary byte codes and is an intermediate code; the wasm is widely used as a propagation medium for issuing the intelligent contracts due to the advantages of high performance, low storage cost, multi-language support and the like. The Go language is widely used for compiling intelligent contracts due to the advantages of simple deployment, good concurrency, good execution performance, simplicity, easiness in learning and the like. However, each intelligent contract source code written in Go language, the compiled intelligent contract wsm byte code (intelligent contract Go-wasm) contains the same runtime byte code, and the byte code of the part contains about 1M data; the intelligent contract go-wasm will be deployed on each node of the blockchain, and each node needs to send a repeated running byte code to the blockchain system to wait for consensus, which causes waste of memory resources of the blockchain system.
Disclosure of Invention
In view of the foregoing defects or shortcomings in the prior art, it is desirable to provide a contract execution method, a contract reduction method, a device, and a storage medium that reduce the size of an intelligent contract, reduce the consumption of resource storage or resource transmission in a blockchain system, and improve the storage efficiency of blockchain nodes.
In a first aspect, the present invention provides a contract execution method, including:
judging whether the first intelligent contract to be executed is simplified according to the first identifier: if yes, loading a corresponding first byte code from the node database;
combining the first intelligent contract and the first byte code to generate a second intelligent contract, and executing the second intelligent contract;
and the first intelligent contract is generated by cutting a first byte code and adding a first identifier to a third intelligent contract by the modified compiler.
In a second aspect, the present invention provides a contract simplifying method, including:
cutting a first byte code and adding a first identifier to the third intelligent contract through the modified compiler to generate a first intelligent contract;
the first identification is used for identifying the first intelligent contract as a reduced intelligent contract.
In a third aspect, the present invention also provides an apparatus comprising one or more processors and a memory, wherein the memory contains instructions executable by the one or more processors to cause the one or more processors to perform a contract execution method and a contract reduction method provided according to embodiments of the present invention.
In a fourth aspect, the present invention also provides a storage medium storing a computer program that causes a computer to execute the contract execution method and the contract simplification method provided according to the embodiments of the present invention.
The contract execution method, the contract simplification method, the device and the storage medium provided by the embodiments of the invention judge whether the first intelligent contract to be executed is simplified by the intelligent contract according to the first identifier: if yes, loading a corresponding first byte code from the node database; combining the first intelligent contract and the first byte code to generate a second intelligent contract, and executing the second intelligent contract; the method for generating the first intelligent contract by cutting the first byte code for the third intelligent contract and adding the first identifier by the modified compiler reduces the size of the intelligent contract, reduces the consumption of resource storage or resource transmission in the block chain system and improves the storage efficiency of the block chain nodes.
The contract execution method, the contract reduction method, the device and the storage medium provided by some embodiments of the present invention further search, through the first hash value, whether the corresponding first bytecode exists in the node database: if yes, loading a first byte code from the node database; according to the method for writing the first hash value into the block chain, the first byte code matched with the first hash value is quickly searched and loaded from the block chain, so that the generation of the second intelligent contract by combining the first intelligent contract with the first byte code is accelerated, the time for executing the second intelligent contract is shortened, the block chain performance is improved, and the user experience is improved.
Drawings
Other features, objects and advantages of the present application will become more apparent upon reading of the following detailed description of non-limiting embodiments thereof, made with reference to the accompanying drawings in which:
fig. 1 is a schematic diagram of a scenario of contract execution and contract simplification according to an embodiment of the present invention.
Fig. 2 is a flowchart of a contract execution method according to an embodiment of the present invention.
FIG. 3 is a flow chart of a preferred embodiment of the method shown in FIG. 2.
Fig. 4 is a flowchart of a contract reduction method according to an embodiment of the present invention.
Fig. 5 is a schematic structural diagram of an apparatus according to an embodiment of the present invention.
Detailed Description
The present application will be described in further detail with reference to the following drawings and examples. It is to be understood that the specific embodiments described herein are merely illustrative of the relevant invention and not restrictive of the invention. It should be noted that, for convenience of description, only the portions related to the present invention are shown in the drawings.
It should be noted that the embodiments and features of the embodiments in the present application may be combined with each other without conflict. The present application will be described in detail below with reference to the embodiments with reference to the attached drawings.
Fig. 1 is a schematic diagram of a scenario of contract execution and contract simplification according to an embodiment of the present invention. As shown in fig. 1, in the present embodiment, the intelligent contract source code written in Go language is compiled into a third intelligent contract of wasm code, the third intelligent contract contains the entire runtime, and the modified compiler cuts the third intelligent contract into the first intelligent contract (configured with the first identifier) and the first bytecode; when the first intelligent contract needs to be executed, the corresponding first byte code is loaded from the node database, the first intelligent contract and the first byte code are combined to form a second intelligent contract, and at the moment, the second intelligent contract contains complete runtime and can be loaded and executed. The contract execution method provided by the present invention is specifically described below with reference to fig. 2.
Fig. 2 is a flowchart of a contract execution method according to an embodiment of the present invention. As shown in fig. 2, in this embodiment, the present invention provides a contract execution method, including:
s12: judging whether the first intelligent contract to be executed is simplified according to the first identifier: if yes, loading a corresponding first byte code from the node database;
s14: combining the first intelligent contract and the first byte code to generate a second intelligent contract, and executing the second intelligent contract;
and the first intelligent contract is generated by cutting a first byte code and adding a first identifier to a third intelligent contract by the modified compiler.
Specifically, taking the application scenario shown in fig. 1 as an example, the first intelligent contract is a contact 1, the second intelligent contract is a contact 2, the third intelligent contract is a contact 3, the first bytecode is runtime _2, and the first identifier is X;
cutting the first byte code of the third intelligent contract through the modified compiler, enabling the third intelligent contract to output the byte code without a runtime part (the byte code without the runtime part is runtime _2), and adding a first identifier to generate a first intelligent contract;
the first intelligent contract extract 1 is generated by the modified compiler clipping the first byte code runtime _2 to the third intelligent contract extract 3 and adding the first identifier X, i.e., extract 1 is extract 3-runtime _2+ X;
combining the first intelligent contract extract 1 with the first byte code runtime _2 generates a second intelligent contract extract 2, i.e., extract 2 ═ extract 1+ runtime _ 2.
In step S12, it is determined whether the first smart contract contact 1 to be executed is a reduced smart contract according to the first identifier X: if yes, loading a corresponding first byte code runtime _2 from the node database;
in step S14, combining the first intelligent contract extract 1 with the first bytecode runtime _2 to generate a second intelligent contract extract 2, and executing a second intelligent contract extract 2; since the contact 2 ═ contact 1+ runtime _2 ═ contact 3-runtime _2+ X + runtime _2, that is, the second smart contract has a complete runtime, it can be loaded and run;
the embodiment reduces the size of the intelligent contract, reduces the consumption of resource storage or resource transmission in the block chain system, and improves the storage efficiency of the block chain nodes.
In a preferred embodiment, the first intelligent contract is a clipped go-wasm contract and the first bytecode is a clipped runtime bytecode.
FIG. 3 is a flow chart of a preferred embodiment of the method shown in FIG. 2. As shown in fig. 3, in a preferred embodiment, loading the corresponding first bytecode from the node database includes:
s122: searching whether a corresponding first byte code exists in the node database through the first hash value: if so, the first bytecode is loaded from the node database.
The first hash value is obtained by performing hash operation on the first byte code, and the first hash value is written into the block chain.
Specifically, taking the application scenario shown in fig. 1 as an example, after the source code version is iterated, the bytecode of the corresponding version is generated; the method comprises the steps that the version of the current Go language is updated to be 1.5 from 1.4, intelligent contract source codes written by the Go language of the 1.5 version are used, the byte codes of a third intelligent contract wasm after compiling are 1.5 versions, a first byte code is generated by cutting the third intelligent contract, and the first byte code is also 1.5 versions; performing hash operation on the first bytecode of the 1.5 version to obtain a first hash value hash _ v1.5 of the first bytecode of the 1.5 version, and writing the hash _ v1.5 into a block chain; the block chain now contains the first hash values of the first bytecodes of different versions, including hash _ v1.5, hash _ v1.4, and so on.
In step S122, the node database is searched for whether the corresponding first bytecode exists through hash _ v 1.5: if yes, the first bytecode corresponding to hash _ v1.5 is loaded from the node database.
Correspondingly, whether a corresponding first bytecode exists or not is searched in the node database through hash _ v 1.5: otherwise, the corresponding first bytecode cannot be loaded and an error is reported.
According to the embodiment, the first byte code matched with the first hash value is quickly searched and loaded from the block chain, so that the generation of the second intelligent contract by combining the first intelligent contract and the first byte code is accelerated, the time of executing the second intelligent contract is shortened, the block chain performance is improved, and the user experience is improved.
Fig. 4 is a flowchart of a contract reduction method according to an embodiment of the present invention. As shown in fig. 4, in this embodiment, the present invention provides a contract reducing method, including:
s22, cutting a first byte code and adding a first identifier to the third intelligent contract through the modified compiler to generate a first intelligent contract;
the first identification is used for identifying the first intelligent contract as a reduced intelligent contract.
Specifically, taking the application scenario shown in fig. 1 as an example, the first intelligent contract is contact 1, the third intelligent contract is contact 3, the first bytecode is runtime _2, and the first identifier is X;
cutting the first byte code of the third intelligent contract through the modified compiler, enabling the third intelligent contract to output the byte code without a runtime part (the byte code without the runtime part is runtime _2), and adding a first identifier to generate a first intelligent contract;
the first intelligent contract extract 1 is generated by the modified compiler clipping the first byte code runtime _2 to the third intelligent contract extract 3 and adding the first identifier X, i.e., extract 1 is extract 3-runtime _2+ X;
in step S22, generating a first intelligent contract extract 1 by clipping the first bytecode runtime _2 and adding the first identifier X to the third intelligent contract extract 3 by the modified compiler;
the first identifier X is used for identifying the first intelligent contract as a reduced intelligent contract, the reduced intelligent contract is a bytecode without a runtime part (the bytecode without the runtime part is runtime _2), and the intelligent contract of the first identifier is added.
In a preferred embodiment, the compiler is configured to generate a modified compiler.
In a preferred embodiment, the first intelligent contract is a clipped go-wasm contract and the first bytecode is a clipped runtime bytecode.
In a preferred embodiment, the hash operation is performed on the first bytecode to obtain a first hash value, and the first hash value is written into the block chain, so that when the node executes the step of loading the corresponding first bytecode from the node database, the following steps are executed:
searching whether a corresponding first byte code exists in the node database through the first hash value: if yes, loading the corresponding first byte code from the node database.
After the source code version is iterated, the byte codes of the corresponding versions are generated; assuming that the version of the current Go language is updated from 1.4 to 1.5, the intelligent contract source code written by using the Go language of 1.5 version has the compiled third intelligent contract wsm byte code of 1.5 version, the first byte code is generated by cutting the third intelligent contract, and the first byte code is also 1.5 version.
Performing hash operation on the first bytecode of the 1.5 version to obtain a first hash value hash _ v1.5 of the first bytecode of the 1.5 version, and writing the hash _ v1.5 into a block chain; the block chain now contains the first hash values of the first bytecodes of different versions, including hash _ v1.5, hash _ v1.4, and so on.
At this time, when the node executes the step of loading the corresponding first bytecode from the node database, the following steps are executed:
looking up whether a corresponding first bytecode exists in the node database through hash _ v 1.5: if yes, loading a first byte code corresponding to the hash _ v1.5 from the node database;
correspondingly, whether a corresponding first bytecode exists or not is searched in the node database through hash _ v 1.5: otherwise, the corresponding first bytecode cannot be loaded and an error is reported.
Fig. 5 is a schematic structural diagram of an apparatus according to an embodiment of the present invention.
As shown in fig. 5, as another aspect, the present application also provides an apparatus 500 including one or more Central Processing Units (CPUs) 501 that can perform various appropriate actions and processes according to a program stored in a Read Only Memory (ROM)502 or a program loaded from a storage section 508 into a Random Access Memory (RAM) 503. In the RAM503, various programs and data necessary for the operation of the apparatus 500 are also stored. The CPU501, ROM502, and RAM503 are connected to each other via a bus 504. An input/output (I/O) interface 505 is also connected to bus 504.
The following components are connected to the I/O interface 505: an input portion 506 including a keyboard, a mouse, and the like; an output portion 507 including a display such as a Cathode Ray Tube (CRT), a Liquid Crystal Display (LCD), and the like, and a speaker; a storage portion 508 including a hard disk and the like; and a communication section 509 including a network interface card such as a LAN card, a modem, or the like. The communication section 509 performs communication processing via a network such as the internet. The driver 510 is also connected to the I/O interface 505 as necessary. A removable medium 511 such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, or the like is mounted on the drive 510 as necessary, so that a computer program read out therefrom is mounted into the storage section 508 as necessary.
In particular, according to an embodiment of the present disclosure, the contract execution method and the contract reduction method described in any of the above embodiments may be implemented as a computer software program. For example, embodiments of the present disclosure include a computer program product comprising a computer program tangibly embodied on a machine-readable medium, the computer program including program code for performing a contract execution method and a contract reduction method. In such an embodiment, the computer program may be downloaded and installed from a network through the communication section 509, and/or installed from the removable medium 511.
As yet another aspect, the present application also provides a computer-readable storage medium, which may be the computer-readable storage medium included in the apparatus of the above-described embodiment; or it may be a separate computer readable storage medium not incorporated into the device. The computer-readable storage medium stores one or more programs, which are used by one or more processors to execute the contract execution method and the contract reduction method described in the present application.
The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
The units or modules described in the embodiments of the present application may be implemented by software or hardware. The described units or modules may also be provided in a processor, for example, each of the described units may be a software program provided in a computer or a mobile intelligent device, or may be a separately configured hardware device. Wherein the designation of a unit or module does not in some way constitute a limitation of the unit or module itself.
The above description is only a preferred embodiment of the application and is illustrative of the principles of the technology employed. It will be appreciated by those skilled in the art that the scope of the invention herein disclosed is not limited to the particular combination of features described above, but also encompasses other arrangements formed by any combination of the above features or their equivalents without departing from the spirit of the present application. For example, the above features may be replaced with (but not limited to) features having similar functions disclosed in the present application.
Claims (9)
1. A contract execution method, comprising:
judging whether the first intelligent contract to be executed is simplified according to the first identifier: if yes, loading a corresponding first byte code from the node database;
combining the first intelligent contract and the first byte code to generate a second intelligent contract, and executing the second intelligent contract;
wherein the first intelligent contract is generated by the modified compiler cutting the first byte code and adding the first identifier to a third intelligent contract.
2. The method of claim 1, wherein the first intelligent contract is a clipped go-wasm contract and the first bytecode is a clipped runtime bytecode.
3. The method of claim 1, wherein loading the corresponding first bytecode from the node database comprises:
searching whether a corresponding first byte code exists in the node database through the first hash value: if yes, loading the first byte code from the node database;
and the first hash value is obtained by carrying out hash operation on the first byte code, and the first hash value is written into a block chain.
4. A contract streamlining method, comprising:
cutting a first byte code and adding a first identifier to the third intelligent contract through the modified compiler to generate a first intelligent contract;
wherein the first identifier is used for identifying that the first intelligent contract is a reduced intelligent contract, and the first identifier is used for a blockchain node to:
when the first intelligent contract to be executed is judged to be a simplified intelligent contract according to the first identification, loading a corresponding first byte code from a node database;
and combining the first intelligent contract and the first byte code to generate a second intelligent contract, and executing the second intelligent contract.
5. The method of claim 4, further comprising:
and configuring a compiler to generate the modified compiler.
6. The method of claim 4, wherein the first intelligent contract is a clipped go-wasm contract and the first bytecode is a clipped runtime bytecode.
7. The method of claim 4, further comprising:
performing hash operation on the first byte code to obtain a first hash value, and writing the first hash value into a block chain;
when the first intelligent contract to be executed is judged to be a reduced intelligent contract according to the first identifier, loading a corresponding first byte code from a node database comprises:
when the first intelligent contract to be executed is judged to be a reduced intelligent contract according to the first identification, searching whether a corresponding first byte code exists in a node database through a first hash value: and if so, loading the first byte code from the node database.
8. A computer device, the device comprising:
one or more processors;
a memory for storing one or more programs,
the one or more programs, when executed by the one or more processors, cause the one or more processors to perform the method recited in any of claims 1-7.
9. A storage medium storing a computer program, characterized in that the program, when executed by a processor, implements the method according to any one of claims 1-7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811447697.1A CN109542455B (en) | 2018-11-29 | 2018-11-29 | Contract execution method, contract reduction method, device, and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811447697.1A CN109542455B (en) | 2018-11-29 | 2018-11-29 | Contract execution method, contract reduction method, device, and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN109542455A CN109542455A (en) | 2019-03-29 |
| CN109542455B true CN109542455B (en) | 2021-08-06 |
Family
ID=65851556
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201811447697.1A Active CN109542455B (en) | 2018-11-29 | 2018-11-29 | Contract execution method, contract reduction method, device, and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN109542455B (en) |
Families Citing this family (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110188097A (en) * | 2019-04-19 | 2019-08-30 | 阿里巴巴集团控股有限公司 | The storage of intelligent contract, execution method and device and electronic equipment in block chain |
| US10783082B2 (en) | 2019-08-30 | 2020-09-22 | Alibaba Group Holding Limited | Deploying a smart contract |
| CN110675256B (en) * | 2019-08-30 | 2020-08-21 | 阿里巴巴集团控股有限公司 | Method and device for deploying and executing intelligent contracts |
| CN111045793A (en) * | 2020-03-13 | 2020-04-21 | 支付宝(杭州)信息技术有限公司 | Method and device for executing functional module in virtual machine |
| CN113360578B (en) * | 2021-06-18 | 2023-04-07 | 中国科学技术大学 | Method, system and storage medium for hierarchically cutting data in block chain transaction |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107370730A (en) * | 2017-07-14 | 2017-11-21 | 阿里巴巴集团控股有限公司 | A kind of log-on message processing method and equipment |
| CN107820690A (en) * | 2017-08-21 | 2018-03-20 | 达闼科技成都有限公司 | Information choosing method, device, electronic equipment and computer-readable recording medium |
| CN108566420A (en) * | 2018-03-29 | 2018-09-21 | 上海点融信息科技有限责任公司 | Data processing method, equipment and computer readable storage medium for block chain |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| KR101849917B1 (en) * | 2016-10-13 | 2018-05-31 | 주식회사 코인플러그 | Method for providing certificate service based on smart contract and server using the same |
-
2018
- 2018-11-29 CN CN201811447697.1A patent/CN109542455B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107370730A (en) * | 2017-07-14 | 2017-11-21 | 阿里巴巴集团控股有限公司 | A kind of log-on message processing method and equipment |
| CN107820690A (en) * | 2017-08-21 | 2018-03-20 | 达闼科技成都有限公司 | Information choosing method, device, electronic equipment and computer-readable recording medium |
| CN108566420A (en) * | 2018-03-29 | 2018-09-21 | 上海点融信息科技有限责任公司 | Data processing method, equipment and computer readable storage medium for block chain |
Non-Patent Citations (1)
| Title |
|---|
| "基于语义嵌入模型与交易信息的智能合约自动分类系统";黄步添;《自动化学报》;20170930;第43卷(第9期);1-12 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN109542455A (en) | 2019-03-29 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109542455B (en) | Contract execution method, contract reduction method, device, and storage medium | |
| US10534590B2 (en) | Dynamic recompilation techniques for machine learning programs | |
| US11720344B2 (en) | Code hot-update method and device, storage medium, processor, and terminal | |
| CN110770698B (en) | Differential static analysis for dynamic code optimization | |
| US10942717B2 (en) | Generating closures from abstract representation of source code | |
| CN109313547B (en) | Query optimizer for CPU utilization and code reformulation | |
| CN110058861B (en) | Source code processing method and device, storage medium and electronic equipment | |
| CN111427583A (en) | Component compiling method and device, electronic equipment and computer readable storage medium | |
| CN111427579A (en) | Plug-in, application program implementing method and system, computer system and storage medium | |
| US8806425B1 (en) | Method and apparatus for generating infrastructure code | |
| US9684497B1 (en) | Optimized compiling of a template function | |
| CN110941655B (en) | Data format conversion method and device | |
| US9135027B1 (en) | Code generation and execution for dynamic programming languages | |
| US10684873B2 (en) | Efficient data decoding using runtime specialization | |
| Rochimah et al. | Decomposing monolithic to microservices: Keyword extraction and BFS combination method to cluster monolithic’s classes | |
| CN113656433B (en) | Entity object expansion method, entity object expansion device, electronic equipment and storage medium | |
| US20180364993A1 (en) | Generating executable files through compiler optimization | |
| US11429358B2 (en) | Representing asynchronous state machine in intermediate code | |
| CN110489124B (en) | Source code execution method, source code execution device, storage medium and computer equipment | |
| Morihata et al. | Optimizing declarative parallel distributed graph processing by using constraint solvers | |
| CN113448852A (en) | Test case obtaining method and device, electronic equipment and storage medium | |
| US9720660B2 (en) | Binary interface instrumentation | |
| CA2687672A1 (en) | Intelligent call graph generation | |
| CN111782248B (en) | Updating method and device of terminal application and electronic equipment | |
| CN117539492A (en) | Method and device for deleting redundant sentences in codes, electronic equipment and storage medium |
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 | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |