CN110908771A

CN110908771A - Memory management method of intelligent contract based on JAVA

Info

Publication number: CN110908771A
Application number: CN201911110938.8A
Authority: CN
Inventors: 邱炜伟; 尹可挺; 李伟; 宋宇
Original assignee: Hangzhou Qulian Technology Co Ltd
Current assignee: Hangzhou Qulian Technology Co Ltd
Priority date: 2019-11-14
Filing date: 2019-11-14
Publication date: 2020-03-24

Abstract

The invention discloses a memory management method of intelligent contracts based on JAVA, which caches contract classes of users in a memory by modifying a JAVA virtual machine, realizes the function of repeatedly analyzing contract byte codes when the users send requests each time, and simultaneously realizes the management of the life cycle of the contract classes and controls the recovery mechanism of the contract classes by modifying a garbage recoverer mechanism of the JAVA virtual machine. The invention modifies the memory model and the garbage recycling mechanism of the JAVA virtual machine, so that the virtual machine is more efficient in processing JAVA contract class codes, and the processing efficiency of the virtual machine is improved.

Description

Memory management method of intelligent contract based on JAVA

Technical Field

The invention relates to a block chain technology, in particular to a memory management method of an intelligent contract based on JAVA.

Background

An intelligent contract is an assembly language programmed on a blockchain, the term being proposed by a cross-domain legal student in nike-Sabo, whose definition on an intelligent contract is "an intelligent contract is a set of numerically defined commitments including protocols on which the contracts participants can execute, in other words, an intelligent contract is a contract that can be automatically executed on a computer system when certain conditions are met. Usually one does not write the bytecode itself, but it is compiled from a higher level language, e.g. a proprietary language like JAVA.

The existing memory management method of the intelligent contract using JAVA has certain defects, and a user needs to perform deserialization and class loading processes on contract classes each time the contract is called, so that the calling time of the contract is reduced, and the time delay is increased. Further, in a block chain application scenario, a garbage recycling mechanism of the JAVA virtual machine has certain defects, and the JAVA virtual machine on the market can recycle the system class and the user contract class under the condition of insufficient memory. However, the execution efficiency is seriously affected by loading and recycling the class frequently in the block chain scene.

Disclosure of Invention

Aiming at the defects of the prior art, the invention provides an intelligent contract memory management method based on JAVA, which manages the memory in the processes of JAVA contract deployment, calling and upgrading and improves the execution efficiency of JAVA contracts, and the specific technical scheme is as follows:

a memory management method of intelligent contract based on JAVA, the memory management includes caching user contract class and carrying out different garbage recovery mechanism to different classes, wherein,

for caching user contract classes, when a JAVA virtual machine receives a request for analyzing the user contract classes, acquiring a contract deployment address and the contract classes of a user, and storing the contract classes of the user into a cache set in a memory, wherein the index of the cache set is the contract deployment address, when the user calls the contract classes at the contract deployment address next time, the contract classes are taken out of the memory, modifiable fields of the contract classes are reset and then returned to the user, and the contract classes are ensured to be consistent when returned to the user each time;

the mechanism for performing different garbage recycling on different classes specifically includes the following three conditions:

(1) for the system classes in JAVA, the virtual machine does not carry out garbage collection on the system classes, and all the system classes are distributed in one area in the memory;

(2) when the size of data in the cache exceeds a certain limit, the virtual machine automatically clears some user contract classes by using a page replacement algorithm so as to achieve the purpose of controlling the size of the memory;

(3) for each class instance, the virtual machine cleans it up with the garbage collection algorithm of JAVA.

Further, for system classes in JAVA, the virtual machine initializes them at startup.

Further, the modifiable field of the contract class is a static field.

Further, the page replacement algorithm is specifically a least recently used algorithm.

Furthermore, the system class, the contract class and the instances of each class are respectively stored in three different memory addresses, and are not overlapped with each other.

The invention has the beneficial effects that:

the invention is applied to a block chain platform, provides a set of brand-new intelligent contract memory management, realizes the caching of contract classes, does not need to be loaded every time of calling, and improves the code execution efficiency; a cache elimination mechanism is carried out on the cache while caching, so that the overflow of the memory is avoided; modifying a JAVA garbage recycling mechanism to enable JAVA garbage recycling to be more efficient; when the virtual machine is started, the system class is initialized, and the execution speed of the JAVA code is accelerated.

Drawings

FIG. 1 is a diagram of cache deposits of the present invention;

FIG. 2 is a flow diagram of reading a cache;

FIG. 3 is a schematic diagram of an LRU cache eviction algorithm.

Detailed Description

The present invention will be described in detail below with reference to the drawings and specific embodiments, and the objects and effects of the present invention will become more apparent.

The intelligent contract life cycle management method based on JAVA of the invention comprises two convenience of caching user contract classes and carrying out different garbage recycling mechanisms on different classes, wherein,

for caching user contract classes, when a JAVA virtual machine receives a request for analyzing the user contract classes, acquiring a contract deployment address and the contract classes of a user, and storing the contract classes of the user into a cache set in a memory, wherein an index of the cache set is the contract deployment address, when the user calls the contract classes at the contract deployment address next time, the contract classes are taken out of the memory, and a static field of the contract classes is reset and then returned to the user, so that the contract classes are consistent when being returned to the user each time; the specific cache storage manner is shown in fig. 1, and the flow of reading the cache is shown in fig. 2.

(1) for the system class in JAVA, the virtual machine does not carry out garbage collection on the system class, and all the system classes are distributed in a region in the memory.

(2) For the contract class of the user, the virtual machine automatically manages the memory, the virtual machine maintains a cache set in the memory, when the virtual machine caches the user class, the virtual machine inserts the class into the cache set, meanwhile, the virtual machine carries out a cache elimination strategy on the cache set, and when the size of the cache set exceeds a certain limit, the virtual machine manually eliminates some user classes by using a page replacement algorithm LRU so as to achieve the purpose of controlling the size of the memory. The algorithm keeps the most recently used contract class and eliminates the contract class which is too long in time of last use. The principle of the specific LRU algorithm is shown in fig. 3. That is, the cache set in the virtual machine uniformly maintains the survival time of the user class, which is not determined by the garbage collection mechanism.

For the system class in JAVA, the virtual machine initializes the system class when being started, thereby reducing the overhead of initializing the system class when running and improving the execution speed of the program.

Preferably, the modifiable field of the contract class is a static field. The page replacement algorithm is specifically the least recently used algorithm. The system class, the contract class and the instances of each class are respectively stored in three different memory addresses and are not overlapped with each other.

Claims

1. A memory management method of intelligent contract based on JAVA is characterized in that the memory management comprises caching user contract classes and carrying out different garbage recycling mechanisms on different classes, wherein,

for caching user contract classes, when a JAVA virtual machine receives a request for analyzing the user contract classes, acquiring a contract deployment address and the contract classes of a user, and storing the contract classes of the user into a cache set in a memory, wherein the index of the cache set is the contract deployment address, when the user calls the contract classes at the contract deployment address next time, the contract classes are taken out of the memory, modifiable fields of the contract classes are reset and then returned to the user, and the contract classes are guaranteed to be consistent when returned to the user each time.

2. A method for memory management in a JAVA based smart contract as claimed in claim 1, wherein the virtual machine initializes the system classes in JAVA at start-up.

3. A method for memory management in a JAVA based smart contract as claimed in claim 1, wherein the modifiable field of the contract class is a static field.

4. A method for memory management in a JAVA based smart contract as claimed in claim 1, wherein said page permutation algorithm is specifically a least recently used algorithm.

5. A memory management method for a JAVA based smart contract as claimed in claim 1, wherein the system class, the contract class and the instance of each class are stored in three different memory addresses respectively, and do not coincide with each other.