CN113434522B - Parallel updating method and updating system on state tree oriented to alliance chain - Google Patents

Parallel updating method and updating system on state tree oriented to alliance chain Download PDF

Info

Publication number
CN113434522B
CN113434522B CN202110498176.4A CN202110498176A CN113434522B CN 113434522 B CN113434522 B CN 113434522B CN 202110498176 A CN202110498176 A CN 202110498176A CN 113434522 B CN113434522 B CN 113434522B
Authority
CN
China
Prior art keywords
state
node
conflict
parallel
nodes
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
Application number
CN202110498176.4A
Other languages
Chinese (zh)
Other versions
CN113434522A (en
Inventor
朱承宇
陈之豪
戚晓冬
张召
金澈清
周傲英
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
East China Normal University
Original Assignee
East China Normal University
Priority date (The priority date 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 date listed.)
Filing date
Publication date
Application filed by East China Normal University filed Critical East China Normal University
Priority to CN202110498176.4A priority Critical patent/CN113434522B/en
Publication of CN113434522A publication Critical patent/CN113434522A/en
Application granted granted Critical
Publication of CN113434522B publication Critical patent/CN113434522B/en
Active legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/23—Updating
    • G06F16/2308—Concurrency control
    • G06F16/2315—Optimistic concurrency control
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/27—Replication, distribution or synchronisation of data between databases or within a distributed database system; Distributed database system architectures therefor
    • 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
    • Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
    • Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
    • Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
    • Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management

Abstract

The invention discloses a parallel updating method on a state tree facing a alliance chain. The invention positions the conflict node needing to be modified on the state tree for each updated state, reasonably distributes tasks of updating the state and the node for the thread, and enables the thread to update the state tree node in parallel. The invention also discloses a system for realizing the parallel updating method, which comprises a consensus module, a transaction execution module and a storage module. By this method, updates to the state tree can be performed in parallel, thereby greatly improving system throughput. The invention realizes the lock-free parallel update of the state, and by decoupling the read operation and the write operation, the characteristic of batch update of the block chain is skillfully combined and used, and the concurrency performance is improved to the maximum extent.

Description

Parallel updating method and updating system on state tree oriented to alliance chain
Technical Field
The invention belongs to the technical field of blockchains, relates to a method for updating a state tree, and in particular relates to a parallel updating method and system for a state tree oriented to a alliance chain.
Background
The blockchain is a distributed account book which is maintained together by multiple parties and oriented to mutually untrusted environments, and has the characteristics of decentralization, non-falsification, traceability of historical data and the like. However, conventional blockchains are executed sequentially on a batch of transactions in order to ensure that each copy has a consistent final state. However, this mode of sequential execution does not take good advantage of the performance of modern multi-core processors, idles significant computer resources and brings about very poor performance.
The state storage mainly comprises a verifiable data structure storage, which is commonly called a state tree, such as MPT, SMT and the like. The structure can be used for calculating the abstract, indexing account states and providing integrity certification. In addition, the state tree stores all versions of account state data by building a snapshot of the global account state on each block. However, as each node updates on the state tree, the hash of the root node on the path of the state tree to this updated node is recalculated and all updated nodes need to be persisted at commit time. At present, a whole tree is locked to update the state in a plurality of parallel operation of the state tree, but the method is basically consistent with the serial update effect; another is to design a mechanism that uses locks at node granularity, but because of the upper and lower relationship of the node and its children, the more aggressive the locks on nodes closer to the root node will compete, which will also affect overall concurrency performance.
Therefore, in order to improve the overall performance of the federated chain, it is necessary to propose a parallel update strategy on the state tree for the federated chain.
Disclosure of Invention
In order to solve the defects existing in the prior art, the invention aims to provide a parallel update method on a state tree facing a alliance chain, which realizes lock-free parallel update of states, and the concurrency performance is improved to the greatest extent by decoupling read operation and write operation and skillfully combining the characteristics of block chain batch update.
Aiming at the defect of the prior art, the invention provides a parallel updating method on a state tree facing a alliance chain, which aims at improving the throughput rate of the alliance chain. In parallel update on a state tree, the invention analyzes conflict relation between jobs by decoupling read operation and write operation, parallel sinks to find a node for common update among jobs from a root node, divides conflict-free jobs into different working threads for execution, and updates all updated states in one block to the state tree in parallel without lock, thereby improving block processing speed and system throughput.
The invention provides a parallel updating method on a state tree facing a alliance chain, which specifically comprises the following steps:
step 1: distributing the state set S to be updated to different working threads in a distribution mode of modulus, hash mapping, ordered segmentation and the like;
step 2: performing parallel sinking search on all updated states on the state tree until a conflict node is found, and attaching the corresponding state to the conflict node;
step 3: the conflict node-updated state list is taken out from the mapping relation, the conflict node and the additional state set thereof are reassigned to different working threads in the allocation modes of modulus, hash mapping, ordered segmentation and the like, so that one conflict node is modified by one working thread as much as possible, and one working thread can modify one or more conflict nodes;
step 4: and updating the nodes of the state tree in parallel according to the state allocated by the working thread and the conflict node information.
Wherein, the liquid crystal display device comprises a liquid crystal display device,
said step 1 further comprises the steps of:
step 1-1: collecting all state sets S and working thread sets which need to be updated in batches, and initializing a counter;
step 1-2: and taking out each updated state from the set S, obtaining indexes of the working threads by using modes of modulo, hash mapping, ordered segmentation division and the like, and distributing the taken states to the corresponding working threads.
Said step 2 further comprises the steps of:
step 2-1: the state set is parallelly taken out from the working thread, and the mapping relation between the node and the working list is initialized;
step 2-2: and (3) extracting the updated state from the state set, searching the conflict node on the state tree, and adding the updated state into a state list of the conflict node in the mapping relation of the step (2-1).
Said step 4 further comprises the steps of:
step 4-1: reading corresponding conflict nodes needing updating and an updating state list of the conflict nodes in parallel from each working thread;
step 4-2: and sequentially extracting conflict nodes from the conflict node set in parallel, acquiring an update state list of the conflict nodes from the mapping relation, and sequentially updating the conflict nodes and the child nodes needing updating on the tree.
The invention also provides a system for realizing the parallel updating method, which comprises the following steps: the system comprises a consensus module, a transaction execution module and a storage module.
The consensus module is used for maintaining the operation sequence and fairness of the system and maintaining the stable operation of the system through rewards and punishments; the consensus refers to a community solution that achieves the statement accepted by the diverging parties, even if only marginally accepted, even just resting the dispute.
The transaction execution module executes intelligent contract binary codes in transactions by using an Executor (Executor); the actuator is similar to a black box in execution, with the input being the smart contract code and the output being a change of state.
The Storage module is used for modifying the State (State) of the account after the transaction passes through the transaction execution module, and the Storage module stores the modified State (Storage).
The beneficial effects of the invention include: the invention realizes the lock-free parallel update of the state, and by decoupling the read operation and the write operation, the characteristic of batch update of the block chain is skillfully combined and used, and the concurrency performance is improved to the maximum extent.
Drawings
FIG. 1 is a diagram showing an example of job assignment according to embodiment 1 of the present invention.
Fig. 2 is a parallel sinking example diagram of embodiment 1 of the present invention.
FIG. 3 is a diagram illustrating nodes for worker thread allocation of desired updates according to embodiment 1 of the present invention.
Fig. 4 is a diagram showing an example of parallel node update according to embodiment 1 of the present invention.
FIG. 5 is a diagram showing an example of job assignment according to embodiment 2 of the present invention.
Fig. 6 is a parallel sink illustration of embodiment 2 of the present invention.
FIG. 7 is a diagram illustrating an example of nodes for which worker threads are assigned updates in accordance with embodiment 2 of the invention.
FIG. 8 is a diagram showing an example of job assignment according to embodiment 3 of the present invention.
Fig. 9 is a parallel sink illustration of embodiment 3 of the present invention.
FIG. 10 is a diagram illustrating nodes for worker thread assignment of the update needed in accordance with embodiment 3 of the present invention.
Detailed Description
The present invention will be described in further detail with reference to the following specific examples and drawings. The procedures, conditions, experimental methods, etc. for carrying out the present invention are common knowledge and common knowledge in the art, except for the following specific references, and the present invention is not particularly limited.
In a conventional blockchain, after transactions in a block are performed, the updated state is serially updated onto the state tree, which limits the blockchain throughput improvement. In the invention, in order to update the states to the state tree in parallel without locks, thereby improving the overall performance of the system, decoupling the read-write operation, and updating the updated states to the state tree in batches by utilizing the characteristics of blockchain batches, so that the conflict relation of the nodes needing to be updated on the state tree can be obtained, thereby maximally carrying out parallel update scheduling without locks and improving the throughput of the whole system.
The parallel updating method on the state tree facing the alliance chain provided by the invention is as follows:
Figure BDA0003055304120000041
the method comprises the following specific steps:
step 1: the state set S which needs to be updated is distributed to different working threads, and the method comprises the following specific steps (lines 1-5):
step 1-1: collecting all state sets S needing to be updated in batches, initializing a counter cnt=0 and a working thread set W;
step 1-2: the state (k, v) of each update is taken from the set S, the counter cnt and the total number of working threads N t Taking the modulus to obtain idx, distributing the fetched state (k, v) to the idx working thread, and adding one to the counter cnt;
k is an account address; the v is a value modified by an account address; the idx is a work thread identifier distributed according to a partitioning rule;
step 2: all update states are sunk in parallel on the tree until conflicting nodes are found, including the following specific steps (lines 6-12):
step 2-1: the state set task_set is parallelly taken out from the working thread, and the mapping relation M between the nodes and the working list is initialized;
step 2-2: extracting updated state (k, v) from state set task_set, searching conflict node on state tree c Adding the updated states (k, v) to the updated state list l in the mapping relation M t In (a) and (b);
step 3, extracting the conflict node-updated state list (node) from the mapping relation M c ,l t ) The counter cnt is combined with the total number of working threads N t Modulo the idx, the conflicting node-updated state list (node c ,l t ) Evenly distributing the thread to different working threads in a modulo way, and adding one to a counter cnt (lines 13-17);
step 4: according to the state allocated by the working thread and the conflict node information, updating the nodes of the state tree in parallel, wherein the method comprises the following specific steps (lines 19-25):
step 4-1: reading a corresponding conflict node set needing updating and a corresponding state (k, v) of the conflict node set needing updating from each working thread in parallel;
step 4-2: sequentially extracting the conflict node nodes from the conflict node set node_set in parallel c Obtaining updated state list l of conflict node from mapping relation M t And updating the conflict nodes and the child nodes needing updating thereof on the tree in sequence.
The invention also provides a system for realizing the parallel updating method, which comprises the following steps: the system comprises a consensus module, a transaction execution module and a storage module.
The consensus module is used for maintaining the operation sequence and fairness of the system and maintaining the stable operation of the system through rewards and punishments; the consensus refers to a community solution that achieves the statement accepted by the diverging parties, even if only marginally accepted, even just resting the dispute.
The transaction execution module executes intelligent contract binary codes in transactions by using an Executor (Executor); the actuator is similar to a black box in execution, with the input being the smart contract code and the output being a change of state.
The Storage module is used for modifying the State (State) of the account after the transaction passes through the transaction execution module, and the Storage module stores the modified State (Storage).
Example 1
The embodiment is a method for updating nodes on a state tree in parallel.
Dirty status (dirtystate): the state of all transactions of a block modified after the end of execution.
And (3) operation: the update work for the leaf node where each state is located and the parent node on its path.
Conflict node: multiple states update the same node, and the node updated multiple times is the conflict node.
Expansion node: there can only be one child node.
Branch node: there may be multiple nodes.
Leaf node: there are no child nodes.
First, as shown in FIG. 1, assume that after all transactions within a block have been performed, a total of 6 dirty states s are generated 1 ～s 6 Wherein "I (-)" and "D (-)" represent the insertion and deletion of a state, respectively. All of these dirty states (jobs) are evenly distributed among 3 worker threads (worker threads a, b, c are represented by rectangles, circles, diamonds, respectively).
Next, as shown in fig. 2, 3 worker threads sink in parallel on the state tree, find the conflict node for each job, and append the job to the corresponding conflict node. For example, a circular worker thread b holds a job (dirty state) s as can be seen from FIG. 1 2 Sum s 6 Then worker thread b sinks in parallel on the state tree, with the path: nodePoint 1->Node 3->Node 6 and node 1->Node 2->And node 5. The final sinking step ends at two conflicting nodes: node 5 and node 6. After all worker threads complete the sink step, as shown in FIG. 2, eventually all jobs (dirty state) are attached to 4 conflicting nodes: node 5, node 6, node 8, node 9.
When all conflict nodes are found, although some jobs (dirty state) are allocated to different working threads after step 1, jobs belonging to different working threads are allocated on the same conflict node after the state of step 2 is submerged: s is(s) 2 Sum s 6 Belonging to working threads b, s 1 Sum s 5 Belonging to worker thread a, but s 1 Sum s 6 Belongs to the same conflict node s 2 Sum s 5 Belonging to different conflict nodes. Thus, as shown in FIG. 3, s will be taken into account in terms of load balancing 1 Sum s 6 Assigned to worker threads a, s 2 Sum s 5 Assigned to working threads b, s 3 Sum s 4 Assigned to worker thread c.
After the node update tasks are assigned to different worker threads, all worker threads update different conflicting nodes in parallel, as shown in FIG. 4.
Example 2
As shown in FIG. 5, assume that after all transactions within a block have been performed, a total of 6 dirty states s are generated 1 ～s 6 Wherein "I (-)" and "D (-)" represent the insertion and deletion of a state, respectively. All of these dirty states (jobs) are mapped in 3 worker threads by way of hash mapping (worker threads a, b, c are represented by rectangles, circles, diamonds, respectively).
Next, as shown in fig. 6, 3 worker threads sink in parallel on the state tree, find the conflict node of each job, and append the job to the corresponding conflict node. For example, a circular worker thread b holds a job (dirty state) s as can be seen from FIG. 1 2 Sum s 6 Then worker thread b sinks in parallel on the state tree, with the path: node 1->Node 4->Node 8 and node 1->Node 4->Node 9. Finally go downThe sinking step ends at two conflicting nodes: node 8 and node 9. After all worker threads complete the sink step, as shown in FIG. 2, eventually all jobs (dirty state) are attached to 4 conflicting nodes: node 5, node 6, node 8, node 9.
When all conflict nodes are found, although some jobs (dirty state) are allocated to different working threads after step 1, jobs belonging to different working threads are allocated on the same conflict node after the state of step 2 is submerged: s is(s) 2 Sum s 6 Belonging to working threads b, s 1 Sum s 5 Belonging to the working threads a, s 3 Sum s 4 Belonging to the working thread c. But s is 1 Sum s 4 Belongs to the same conflict node s 2 Sum s 5 Belonging to different conflict nodes. Thus, as shown in FIG. 7, s will be taken into account in terms of load balancing 1 Sum s 4 Assigned to worker threads a, s 2 Sum s 5 Assigned to working threads b, s 3 Sum s 6 Assigned to worker thread c.
The procedure of stage four was identical to that of example 1.
Example 3
As shown in FIG. 8, assume that after all transactions within a block have been performed, a total of 6 dirty states s are generated 1 ～s 6 Wherein "I (-)" and "D (-)" represent the insertion and deletion of a state, respectively. All these dirty states (jobs) are mapped in 3 worker threads by means of ordered segmentation (worker threads a, b, c are represented by rectangles, circles, diamonds, respectively).
Next, as shown in fig. 9, 3 worker threads sink in parallel on the state tree, find a conflict node for each job, and append the job to the corresponding conflict node. For example, a circular worker thread b holds a job (dirty state) s as can be seen from FIG. 1 2 Sum s 6 Then worker thread b sinks in parallel on the state tree, with the path: node 1->Node 3->Node 6 and node 1->Node 4->Node 8. The final sinking step ends at two conflicting nodes: node 6 and node 8. After all worker threads complete the sinking step, e.g.As shown in fig. 2, eventually all jobs (dirty state) are appended to 4 conflicting nodes: node 5, node 6, node 8, node 9.
When all conflict nodes are found, although some jobs (dirty state) are allocated to different working threads after step 1, jobs belonging to different working threads are allocated on the same conflict node after the state of step 2 is submerged: s is(s) 2 Sum s 6 Belonging to working threads b, s 1 Sum s 5 Belonging to the working threads a, s 3 Sum s 4 Belonging to the working thread c. But s is 4 Sum s 5 Belongs to the same conflict node s 1 Sum s 2 Belonging to different conflict nodes. Thus, as shown in FIG. 10, s will be taken into account in terms of load balancing 4 Sum s 5 Assigned to worker threads a, s 1 Sum s 2 Assigned to working threads b, s 3 Sum s 6 Assigned to worker thread c.
The procedure of stage four was identical to that of example 1.
The protection of the present invention is not limited to the above embodiments. Variations and advantages that would occur to one skilled in the art are included within the invention without departing from the spirit and scope of the inventive concept, and the scope of the invention is defined by the appended claims.

Claims (2)

1. A method for parallel updating on a state tree oriented to a federation chain, the method comprising the steps of:
step 1: distributing the state set to be updated to different working threads in a mode of modular, hash mapping and orderly segmentation dividing; in step 1, the method further comprises the following steps:
step 1-1: collecting all state sets and working thread sets which need to be updated in batches, and initializing a counter;
step 1-2: taking out each updated state from the set, obtaining indexes of the working threads by using modes of modulo, hash mapping and orderly segmentation division, and distributing the taken states to the corresponding working threads;
step 2: all the updated states are sunk and searched in parallel on the tree until a conflict node is found, and the corresponding state is added to the conflict node; in step 2, the method further comprises the following steps:
step 2-1: the state set is parallelly taken out from the working thread, and the mapping relation between the node and the working list is initialized;
step 2-2: the updated state is taken out from the state set, conflict nodes are searched for on the state tree, and the updated state is added into the state set of the conflict nodes;
step 3: the conflict node-updated state list is taken out from the mapping relation, the conflict node and the additional state set thereof are reassigned to different working threads in the mode of modular taking, hash mapping and orderly segmentation dividing, and one working thread modifies one or more conflict nodes;
step 4: according to the state allocated by the working thread and the conflict node information, updating the nodes of the state tree in parallel; in step 4, the method further comprises the following steps:
step 4-1: reading corresponding conflict nodes needing updating and an updating state list of the conflict nodes in parallel from each working thread;
step 4-2: and sequentially extracting conflict nodes from the conflict node set in parallel, acquiring an update state list of the conflict nodes from the mapping relation, and sequentially updating the conflict nodes and the child nodes needing updating on the tree.
2. A system for implementing the parallel update method of claim 1, the system comprising: the system comprises a consensus module, a transaction execution module and a storage module;
the consensus module maintains the operation sequence and fairness of the system and maintains the stable operation of the system through rewards and punishments, and consensus is a community solution for achieving statements accepted by the diverging parties;
the transaction execution module executes intelligent contract binary codes in transactions by using an executor; the input of the executor is intelligent contract binary code, and the output is a change of state;
the storage module is used for modifying the state of the account after the transaction passes through the transaction execution module, and the storage module stores the modified state.
CN202110498176.4A 2021-05-08 2021-05-08 Parallel updating method and updating system on state tree oriented to alliance chain Active CN113434522B (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CN202110498176.4A CN113434522B (en) 2021-05-08 2021-05-08 Parallel updating method and updating system on state tree oriented to alliance chain

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN202110498176.4A CN113434522B (en) 2021-05-08 2021-05-08 Parallel updating method and updating system on state tree oriented to alliance chain

Publications (2)

Publication Number Publication Date
CN113434522A CN113434522A (en) 2021-09-24
CN113434522B true CN113434522B (en) 2023-06-09

Family

ID=77753069

Family Applications (1)

Application Number Title Priority Date Filing Date
CN202110498176.4A Active CN113434522B (en) 2021-05-08 2021-05-08 Parallel updating method and updating system on state tree oriented to alliance chain

Country Status (1)

Country Link
CN (1) CN113434522B (en)

Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101917394A (en) * 2010-06-13 2010-12-15 大连海事大学 Middleware system for sharing data in mobile phone equipment and working method
CN108513658A (en) * 2016-12-30 2018-09-07 华为技术有限公司 A kind of transaction methods and device
CN110688377A (en) * 2019-08-30 2020-01-14 阿里巴巴集团控股有限公司 Method and device for updating state Merck tree
CN111683043A (en) * 2020-04-26 2020-09-18 华东师范大学 Intelligent contract concurrent execution method facing alliance chain and based on trusted execution environment
CN112579291A (en) * 2020-12-22 2021-03-30 北京航空航天大学 StateDB-based intelligent contract parallel operation system and parallel operation method

Family Cites Families (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US10203318B2 (en) * 2015-08-20 2019-02-12 Ofi Testing Equipment, Inc. Multi-purpose tube for oil well cement testing
CN109067863B (en) * 2018-07-25 2021-03-05 上海点融信息科技有限责任公司 Method, apparatus and storage medium for managing node identification of blockchain node
US20200210170A1 (en) * 2018-12-27 2020-07-02 Hcl America Inc Resolving potential merge conflicts by utilizing a distributed blockchain framework
CN110276689B (en) * 2019-06-19 2023-05-02 辽宁大学 Intelligent contract implementation method based on dynamic decision
CN111294234B (en) * 2020-01-17 2022-07-29 麦科思(苏州)数据科技有限公司 Parallel block chain fragmentation method based on intelligent contract optimization model

Patent Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101917394A (en) * 2010-06-13 2010-12-15 大连海事大学 Middleware system for sharing data in mobile phone equipment and working method
CN108513658A (en) * 2016-12-30 2018-09-07 华为技术有限公司 A kind of transaction methods and device
CN110688377A (en) * 2019-08-30 2020-01-14 阿里巴巴集团控股有限公司 Method and device for updating state Merck tree
CN111683043A (en) * 2020-04-26 2020-09-18 华东师范大学 Intelligent contract concurrent execution method facing alliance chain and based on trusted execution environment
CN112579291A (en) * 2020-12-22 2021-03-30 北京航空航天大学 StateDB-based intelligent contract parallel operation system and parallel operation method

Also Published As

Publication number Publication date
CN113434522A (en) 2021-09-24

Similar Documents

Publication Publication Date Title
Kwon et al. A study of skew in mapreduce applications
Wang et al. {RStream}: Marrying relational algebra with streaming for efficient graph mining on a single machine
TWI660281B (en) Method and device for writing blockchain business data and method for determining business subset
US5857180A (en) Method and apparatus for implementing parallel operations in a database management system
US7899799B2 (en) Transaction processing system of database using multi-operation processing providing concurrency control of transactions
CN108564470B (en) Transaction distribution method for parallel building blocks in block chain
CN111736964B (en) Transaction processing method and device, computer equipment and storage medium
CN113205417B (en) Alliance chain oriented transaction parallel processing method and system
CN101739281A (en) Infrastructure for parallel programming of clusters of machines
US7293011B1 (en) TQ distribution that increases parallism by distributing one slave to a particular data block
AU2023201414A1 (en) Systems and methods for performing data processing operations using variable level parallelism
CN102207935A (en) Method and system for establishing index
CN111125229A (en) Data blood margin generation method and device and electronic equipment
CN108062378B (en) The Connection inquiring method and system of more time serieses under a kind of storage of column
CN110442580A (en) A kind of block chain state date storage method, equipment and storage medium
CN111428275B (en) Alliance chain-oriented service non-stop fragment increasing method
CN113434522B (en) Parallel updating method and updating system on state tree oriented to alliance chain
CN109033301A (en) A kind of db transaction execution method based on graphics processor
Sun et al. Implementing parallel and concurrent tree structures
US7188113B1 (en) Reducing contention by slaves for free lists when modifying data in a table partition
CN108334565A (en) A kind of data mixing storage organization, data store query method, terminal and medium
Biswas Heterogeneous Data Structure “r-Atrain”
CN112163024B (en) Configuration information export and import method based on hierarchical association structure
US7185340B1 (en) Multiphase system and method of performing operations on data structures
Tapdiya et al. A comparative analysis of materialized views selection and concurrency control mechanisms in NoSQL databases

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