CN113867903B - Method and device for determining parallel conflict domain of intelligent contract in block chain - Google Patents
Method and device for determining parallel conflict domain of intelligent contract in block chain Download PDFInfo
- Publication number
- CN113867903B CN113867903B CN202111472554.8A CN202111472554A CN113867903B CN 113867903 B CN113867903 B CN 113867903B CN 202111472554 A CN202111472554 A CN 202111472554A CN 113867903 B CN113867903 B CN 113867903B
- Authority
- CN
- China
- Prior art keywords
- function
- node
- variable
- control flow
- flow graph
- 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
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45504—Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44589—Program code verification, e.g. Java bytecode verification, proof-carrying code
Abstract
The invention discloses a method and a device for determining a parallel conflict domain of an intelligent contract in a block chain, wherein the method comprises the following steps: constructing a first control flow graph of the intelligent contract, wherein the first control flow graph comprises sub-control flow graphs of all functions of the intelligent contract; determining the calling relationship of each function, adding calling relationship edges among nodes with the calling relationship in the first control flow graph, determining the type of the added calling relationship edges, and obtaining a second control flow graph; adding data fact nodes of each node to the dependent variable in the second control flow graph, determining data fact transmitted among the nodes in the second control flow graph according to the calling relation edges and types among the nodes in the second control flow graph, and obtaining a third control flow graph; for any function of the functions, searching the data fact node from the data fact node of the ending node of the function to the data fact node of the starting node of the function according to the third control flow chart, and the method is suitable for financial technology (Fintech).
Description
Technical Field
The invention relates to the field of block chains (Blockchain) in the field of financial technology (Fintech), in particular to a method and a device for determining a parallel conflict domain of an intelligent contract in a block chain.
Background
With the development of computer technology, more and more technologies are applied in the financial field, and the traditional financial industry is gradually changing to financial technology (Fintech), but due to the requirements of the financial industry on safety and real-time performance, higher requirements are also put forward on the technologies. At present, based on the non-tamper property of the block chain (Blockchain), transactions are often performed through the block chain in the field of financial technology. Data in the underlying storage system of the blockchain can be accessed through the intelligent contract, however, some data may have access conflict when the intelligent contract is executed in parallel, and the execution result is uncertain. Without intervention, it may cause an error in the execution of the smart contract. At present, reference is provided for invoking the intelligent contract by solving the parallel conflict domain of the intelligent contract. The parallel conflict domain may be characterized by program variables in the intelligent contract for which there is a conflict.
In the current parallel conflict domain solving mode, no method for solving the corresponding parallel conflict domain of the intelligent contract is provided for the intelligent contract with function call. This is a problem to be solved.
Disclosure of Invention
The invention provides a method and a device for determining a parallel conflict domain of an intelligent contract in a block chain, which solve the problem that the corresponding parallel conflict domain of the intelligent contract cannot be solved in the prior art.
In a first aspect, the present invention provides a method for determining a parallel conflict domain of an intelligent contract in a blockchain, including: constructing a first control flow graph of an intelligent contract, wherein the first control flow graph comprises sub control flow graphs of functions of the intelligent contract, the sub control flow graphs of the first functions comprise a starting node and an ending node of execution of the first functions, when the first functions contain a calling instruction, the sub control flow graphs of the first functions comprise the calling node and a returning node corresponding to the calling instruction, and the first functions are any functions in the functions;
determining the calling relationship of each function, adding calling relationship edges among nodes with calling relationship in the first control flow graph, determining the type of the added calling relationship edges, and obtaining a second control flow graph; the type of any calling relation edge represents the transmission type of data facts between a first node and a second node, and the first node and the second node are nodes at two ends of the calling relation edge; the fact that the data of any node of the first function indicates that the variable corresponding to the node is located in the parallel conflict domain of the first function before the program statement corresponding to the node is executed;
adding data fact nodes of each node to the dependent variable in the second control flow graph, determining data facts transmitted among the nodes in the second control flow graph according to the calling relationship edges and types among the nodes in the second control flow graph, and obtaining a third control flow graph;
and aiming at any function of the functions, searching a data fact node from a data fact node of an end node of the function to a data fact node of a start node of the function according to the third control flow diagram, and determining a parallel conflict domain of the intelligent contract according to each data fact node searched in the searching process.
In the above manner, after the first control flow graph of the intelligent contract is constructed, the call relation edges are added among the nodes with the call relation in the first control flow graph, the type of the added call relation edges is determined, thereby concatenating the transfer relationships between the data facts of the nodes in the function through the second control flow graph, and further adding data fact nodes for the dependent variables of each node in the second control flow graph, therefore, after the third control flow graph is obtained, the data fact node of the ending node of the function is searched to the data fact node of the starting node of the function for searching, the conclusion of the whole intelligent contract can be obtained through the searched data fact nodes in a serial connection mode, and the parallel conflict domain of the intelligent contract is accurately determined, so that a solving mode of the parallel conflict domain is provided for the intelligent contract with function calling.
Optionally, the function of the first function call is determined as follows:
if the first function comprises a dynamic call instruction, the instruction parameter of the dynamic call instruction comprises a function pointer of each called function, and a function signature of a second function in the dynamic call instruction and an instance object type for calling the second function are obtained, wherein the second function is any function of each called function;
determining whether a third function is included in the instance object type;
if the instance object type comprises a third function, and the function signature of the third function is the same as that of the second function, determining that the third function is a function called by the first function;
if the third function is not included in the instance object type, updating the instance object type to a subtype in the instance object type, and returning to the step of determining whether the third function is included in the instance object type.
In the method, for the dynamic call instruction, although the called function cannot be directly obtained, the function called by the first function can be determined through the function signature, the function signature has uniqueness and stronger accuracy, and the subtype in each instance object type can be traversed until no subtype exists, so that the function called by the first function can be accurately and comprehensively obtained.
Optionally, if the first function includes a static call instruction, and an instruction parameter of the static call instruction includes a function name of a fourth function, determining the function name of the fourth function as the function called by the first function.
In the above method, if the first function includes a static call instruction, the function name of the fourth function in the instruction parameter may be directly extracted, so that the function called by the first function may be determined more efficiently.
Optionally, the first node and the second node are both nodes corresponding to a target program statement in the intelligent contract, and the fact that the data is transmitted from the first node to the second node is determined according to the following manner:
and if the target program statement is an assignment statement, and a program variable in the target program statement is the same as a basic variable in a preset data fact, or a member variable of the program variable is the same as the basic variable, or the program variable is the same as the member variable of the basic variable, determining the data fact transmitted from the first node to the second node according to the assignment of the program variable, wherein the basic variable is a non-member variable.
In the above manner, for the assignment statement, the fact of the data transferred from the first node to the second node can be determined according to the program variable and the basic variable, even if the program variable or the basic variable includes the member variable, so that the fact of the data transferred from the first node to the second node can be accurately tracked according to the relationship between the variables.
Optionally, determining whether a first variable exists in the first function, where the first variable is a member variable of a second variable, and the first variable is any variable in the first function; if the first variable exists, updating the first variable in the first function to be in the form of a member variable of the second variable, and returning to the step of determining whether the first variable exists in the first function.
In the above manner, for a first variable in a first function, the first variable is updated to take the form of a member variable of a second variable, and the step of determining whether the first variable exists in the first function is returned, so that iteration is continued until a non-member variable is obtained, an access path of regular variables is unified, and a data fact transfer relationship between variables is obtained more easily.
Optionally, the first node and the second node are both nodes corresponding to a target program statement in the intelligent contract, and the fact that the data is transmitted from the first node to the second node is determined according to the following manner: and if the target program statement is a storage read-write statement and the program variable in the target program statement is different from the basic variable in the preset data fact, determining the data fact transmitted from the first node to the second node according to the basic variable, wherein the basic variable is a non-member variable.
In the above manner, on the premise that the variables in the function are all non-member variables and member variables are taken, when the target program statement is a storage read-write statement and the program variable in the target program statement is different from the basic variable in the preset data fact, the data fact transmitted from the first node to the second node can be directly determined according to the basic variable.
Optionally, the determining a parallel conflict domain of the intelligent contract according to the data fact nodes searched in the search process includes:
for any variable of any function of the functions, if the variable has a target propagation path, determining the variable as the variable in the parallel collision domain; the target propagation path is composed of corresponding continuous data fact nodes from the end node of the function to the start node of the function.
In the foregoing manner, for any variable of any function of each function, when the variable has a target propagation path, the relationship of data fact transfer may be characterized by corresponding consecutive data fact nodes between the end node of the function and the start node of the function, so as to determine that the variable is a variable in the parallel collision domain.
In a second aspect, the present invention provides an apparatus for determining a parallel conflict domain of an intelligent contract in a blockchain, including:
the building module is used for building a first control flow graph of the intelligent contract, the first control flow graph comprises sub-control flow graphs of all functions of the intelligent contract, the sub-control flow graphs of the first function comprise a starting node and an ending node of execution of the first function, when the first function contains a call instruction, the sub-control flow graphs of the first function comprise a call node and a return node corresponding to the call instruction, and the first function is any one of the functions;
the first control flow graph is used for determining the calling relationship of each function, adding calling relationship edges among nodes with the calling relationship in the first control flow graph, determining the type of the added calling relationship edges, and obtaining a second control flow graph; the type of any calling relation edge represents the transmission type of data facts between a first node and a second node, and the first node and the second node are nodes at two ends of the calling relation edge; the fact that the data of any node of the first function indicates that the variable corresponding to the node is located in the parallel conflict domain of the first function before the program statement corresponding to the node is executed;
the data fact nodes are used for adding the corresponding variables of each node in the second control flow graph, and the data fact transmitted among the nodes in the second control flow graph is determined according to the calling relationship edges and types among the nodes in the second control flow graph, so that a third control flow graph is obtained;
and the determining module is used for searching a data fact node from a data fact node of an end node of the function to a data fact node of a start node of the function according to the third control flow diagram aiming at any function of the functions, and determining a parallel conflict domain of the intelligent contract according to each data fact node searched in the searching process.
Optionally, the determining module is further configured to:
determining a function of the first function call as follows:
if the first function comprises a dynamic call instruction, the instruction parameter of the dynamic call instruction comprises a function pointer of each called function, and a function signature of a second function in the dynamic call instruction and an instance object type for calling the second function are obtained, wherein the second function is any function of each called function;
determining whether a third function is included in the instance object type;
if the instance object type comprises a third function, and the function signature of the third function is the same as that of the second function, determining that the third function is a function called by the first function;
if the third function is not included in the instance object type, updating the instance object type to a subtype in the instance object type, and returning to the step of determining whether the third function is included in the instance object type.
Optionally, the determining module is further configured to:
and if the first function comprises a static calling instruction, and the instruction parameter of the static calling instruction comprises the function name of a fourth function, determining the function name of the fourth function as the function called by the first function.
Optionally, the first node and the second node are both nodes corresponding to a target program statement in the intelligent contract, and the determining module is further configured to:
determining the fact of data communicated by the first node to the second node as follows:
and if the target program statement is an assignment statement, and a program variable in the target program statement is the same as a basic variable in a preset data fact, or a member variable of the program variable is the same as the basic variable, or the program variable is the same as the member variable of the basic variable, determining the data fact transmitted from the first node to the second node according to the assignment of the program variable, wherein the basic variable is a non-member variable.
Optionally, the determining module is further configured to:
determining whether a first variable exists in the first function, wherein the first variable is a member variable of a second variable, and the first variable is any variable in the first function;
if the first variable exists, updating the first variable in the first function to be in the form of a member variable of the second variable, and returning to the step of determining whether the first variable exists in the first function.
Optionally, the first node and the second node are both nodes corresponding to a target program statement in the intelligent contract, and the determining module is further configured to:
determining the fact of data communicated by the first node to the second node as follows:
and if the target program statement is a storage read-write statement and the program variable in the target program statement is different from the basic variable in the preset data fact, determining the data fact transmitted from the first node to the second node according to the basic variable, wherein the basic variable is a non-member variable.
Optionally, the determining module is further configured to:
for any variable of any function of the functions, if the variable has a target propagation path, determining the variable as the variable in the parallel collision domain; the target propagation path is composed of corresponding continuous data fact nodes from the end node of the function to the start node of the function.
The advantageous effects of the second aspect and the various optional apparatuses of the second aspect may refer to the advantageous effects of the first aspect and the various optional methods of the first aspect, and are not described herein again.
In a third aspect, the present invention provides a computer device comprising a program or instructions for performing the method of the first aspect and the alternatives of the first aspect when the program or instructions are executed.
In a fourth aspect, the present invention provides a storage medium comprising a program or instructions which, when executed, is adapted to perform the method of the first aspect and the alternatives of the first aspect.
These and other aspects of the invention are apparent from and will be elucidated with reference to the embodiments described hereinafter.
Drawings
In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings needed to be used in the description of the embodiments will be briefly introduced below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and it is obvious for those skilled in the art to obtain other drawings based on these drawings without inventive exercise.
Fig. 1 is a schematic flowchart corresponding to a method for determining a parallel conflict domain of an intelligent contract in a block chain according to an embodiment of the present invention;
fig. 2 is a schematic diagram of a first control flow diagram corresponding to a method for determining a parallel conflict domain of an intelligent contract in a block chain according to an embodiment of the present invention;
fig. 3 is a schematic diagram illustrating a flow of specific steps of data fact delivery in a method for determining a parallel conflict domain of an intelligent contract in a block chain according to an embodiment of the present invention;
fig. 4 is a schematic structural diagram of a parallel conflict domain determining apparatus for an intelligent contract in a block chain according to an embodiment of the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention clearer, the present invention will be described in further detail with reference to the accompanying drawings, and it is apparent that the described embodiments are only a part of the embodiments of the present invention, not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
For convenience of description, terms appearing in the present application will be first introduced below.
Intelligent contract: an intelligent contract is a collection of code and data that runs on top of a blockchain system, where the code is responsible for implementing the functionality of the intelligent contract and the data is responsible for storing the state of the intelligent contract, which can receive and send information.
Trading: in blockchains, any operation (deploying a contract, invoking a contract interface, etc.) is done by sending a transaction. The transaction is initiated by the user and sent to the blockchain node through the client. After receiving the transaction, the blockchain node packs the transaction into blocks and executes the blocks.
The transaction is executed in parallel: the transaction in the blockchain is the call of an intelligent contract interface, and the parallel execution can be realized by analyzing the read-write relation involved in the transaction execution so as to improve the performance of the bottom layer of the whole blockchain.
Parallel conflict domains: the set of data states that a transaction needs to access during execution may cause conflicts and thus uncertainty in the execution results when executed in parallel, since different transactions may access the same data states during execution. Since blockchain systems typically use a key-value database as their back-end storage system, parallel conflict domains can be characterized by program variables that have conflicts in the intelligent contracts.
Static program analysis: static program analysis refers to a method of analyzing certain program attributes without running the program. The result of static program analysis cannot be completely accurate, for a program with an infinite execution path (such as a program including an infinite recursion), all possible execution paths of the program cannot be enumerated, and even if the execution path is limited, path traversal cannot be performed due to the problem of state explosion, so the static program analysis often adopts an approximation method: that is, if the original analysis target is to answer "yes" or "no" to a certain property, the target of the approximate method is to change the target to answer "yes", "no" or "unknown", that is, to allow an uncertain answer to occur, for example, "this program may have bug".
The following drawings: in computer science, a graph is an abstract data type used to implement the concepts of undirected graphs and directed graphs of graph theory in mathematics. The data structure of a graph contains a finite (possibly variable) set as a set of nodes, and a set of unordered pairs (corresponding to undirected graphs) or ordered pairs (corresponding to directed graphs) as a set of edges (also referred to as arcs in directed graphs).
A control flow graph: a Control Flow Graph (CFG) is an abstract representation of a process or program, and represents all paths that a program may traverse during execution. The CFG graphically represents the possible flow of all basic block executions within a process. Each vertex in the CFG corresponds to a basic block of programs, and uses directed edges to represent branches.
Domain sensitivity: also called attribute sensitivity, is an analysis technique mainly aimed at object-oriented languages (including structural bodies in C language, etc.), and aims to improve the analysis accuracy of static codes throughout the analysis process.
Data fact: namely, Data Fact, refers to the property held by a program before or after the execution of a certain program statement.
IFDS algorithm framework: the method is a static analysis framework and can be used for solving the problems of meeting requirements of interprocess, finish and distribution (a spreading function of data fact meets an allocation law, namely for the spreading function
Need to satisfy
And Subset Problem (the Problem to be solved is the Subset Problem), and the implementation of the common IFDS algorithm framework can refer to the reference text in the attachmentDocument 1 and reference 2.
An access path: the variable access mode is expressed in the form of "x.f.g", where "x" is called the base variable and "f", "g" are called the domain. "x.f.g" means that the length of the access path can be infinite by first accessing the variable "x", then accessing the data member named "f" in the variable "x", and finally accessing the data member named "g" in "x.f".
In the course of the operation of a financial institution (banking institution, insurance institution or security institution) in carrying out a transaction (e.g. a loan transaction, a deposit transaction, etc. of a bank), transactions are usually carried out through a blockchain. Data in the underlying storage system of the blockchain can be accessed through the intelligent contract, however, some data may have access conflict when the intelligent contract is executed in parallel, and the execution result is uncertain. In the current parallel conflict domain solving mode, no method for solving the corresponding parallel conflict domain of the intelligent contract is provided for the intelligent contract with function call. This situation does not meet the requirements of financial institutions such as banks, and the efficient operation of various services of the financial institutions cannot be ensured.
As shown in fig. 1, the present application provides a method for determining a parallel conflict domain of an intelligent contract in a blockchain.
Step 101: a first control flow graph of the intelligent contract is constructed.
Step 102: and determining the call relation of each function, adding a call relation edge between nodes with the call relation in the first control flow graph, determining the type of the added call relation edge, and obtaining a second control flow graph.
Step 103: adding data fact nodes of each node to the dependent variable in the second control flow graph, determining data facts transmitted among the nodes in the second control flow graph according to the calling relationship edges and types among the nodes in the second control flow graph, and obtaining a third control flow graph;
step 104: and aiming at any function of the functions, searching a data fact node from a data fact node of an end node of the function to a data fact node of a start node of the function according to the third control flow diagram, and determining a parallel conflict domain of the intelligent contract according to each data fact node searched in the searching process.
In step 101-step 104, the first control flow graph includes a sub-control flow graph of each function of the intelligent contract, the sub-control flow graph of the first function includes a start node and an end node of execution of the first function, and when the first function includes a call instruction, the sub-control flow graph of the first function includes a call node and a return node corresponding to the call instruction, and the first function is any one of the functions.
The type of any calling relation edge represents the transmission type of data facts between a first node and a second node, and the first node and the second node are nodes at two ends of the calling relation edge; the fact that the data of any node of the first function is the variable corresponding to the node is located in the parallel conflict domain of the first function before the program statement corresponding to the node is executed.
In step 102, the call relationship edge types may include the following types:
Call-Flow edge, i.e. the transfer function that solves the function Call (parameter mapping); Return-Flow edge, i.e. solve the transfer function of 0; the CallToReturn-Flow edge, i.e., the transfer function from the function call to the function return; Normal-Flow edge, refers to the transfer function of statements other than the 3 function processing scopes described above.
For example, code for the following intelligent contracts:
fn bar(&mut self, s1: &String, s2: &String, b: bool) {
if b {
mapping s1 = 0// write store with s1 as key
} else {
Mapping s2 = 0// write store with s2 as key
}
}
pubfn foo(&mut self, s1: String, s2: String, b: bool) {
let t = self.bar(&s1, &s2, b);
}
As shown in fig. 2, the second control flow graph corresponding to the intelligent contract code is a first control flow graph if the call relationship edge is not added in fig. 2, and is a third control flow graph if the data fact node of each node for the dependent variable is added and the data fact transferred between each node in the second control flow graph is determined according to the call relationship edge and the type between each node in the second control flow graph.
The scheme of the invention designs an in-process transfer function (namely a transfer function corresponding to a Normal-Flow edge), and can support static analysis of a domain-sensitive transaction parallel conflict domain. On the basis of the constructed super graph, the scheme of the invention further converts the super graph into an expanded super graph, and converts the calculation of a transfer function in static analysis, namely the transfer calculation of a data fact into the solution of an edge in expanded by using nodes in a data fact representation graph. In addition, the extended super map is extended with a special data fact 0 for indicating empty sets. The method of the invention then takes the contract method exit point in the expanded super graph as an analysis starting point and the contract method entry point as an analysis end point, performs reverse data flow analysis based on an IFDS algorithm framework, and initiates data read-write requests by finding program statements and reversely tracks the data sources of keys used by the requests to be transmitted forward until the analysis key point is reached. After the calculation of the data propagation path is completed, checking which input parameters have paths for analyzing the starting point to reach the input parameters, and if the input parameters exist, indicating that the input parameters are parallel conflict domains of the contract method. A typical expanded hypergraph is shown in the following figure:
in an alternative embodiment, the function of the first function call may be determined in step 102 as follows:
if the first function comprises a dynamic call instruction, the instruction parameter of the dynamic call instruction comprises a function pointer of each called function, and a function signature of a second function in the dynamic call instruction and an instance object type for calling the second function are obtained, wherein the second function is any function of each called function; determining whether a third function is included in the instance object type; if the instance object type comprises a third function, and the function signature of the third function is the same as that of the second function, determining that the third function is a function called by the first function; if the third function is not included in the instance object type, updating the instance object type to a subtype in the instance object type, and returning to the step of determining whether the third function is included in the instance object type.
In another case, in step 102, if the first function includes a static call instruction, and an instruction parameter of the static call instruction includes a function name of a fourth function, the function name of the fourth function is determined as the function called by the first function.
Specifically, the implementation manner may specifically be as follows:
call instructions are divided into two categories: the static calling instruction clearly expresses the name and parameter list of the called function in the instruction parameter, and the specific called function can be uniquely determined according to the types of all parameters in the name and parameter list; dynamic call instruction: such an instruction usually includes a virtual table composed of several function pointers, and the actual address of the called function is located at runtime according to the value of the function pointer in the virtual table, so that the specific calling object of the instruction can only be determined at runtime.
The method aims to avoid the problem that a complete inter-process control flow graph cannot be established due to the fact that a specific object of a dynamic call instruction cannot be determined. In the method, the types of function pointers in the dynamic call instruction are taken as clues, possible called functions are deduced through inheritance relations among the types in a compiling period, and a calling edge relation is established between a current function and each possible called function, so that a complete inter-process control flow graph is constructed.
In a dynamic call instruction, a function call is expressed by using a form of "o.foo (…)", and a called function inference method based on a type inheritance relationship mainly infers based on the following two points:
the caller instance object type (i.e., the type of object pointed to by the "o" pointer), denoted as c;
the signature of the function in the call instruction is marked as m. The function signature is composed of a class name, a method parameter type and a method return value type. For example, for the "foo" method in the following code, its signature may be denoted as "c.foo (P, Q, R) T":
struct C;
impl C {
fn foo(P p, Q q, R r) -> T{ ... }
}
the definition function Dispatch (c, m) in this application is used to determine the called function, and it executes the following steps:
step (1): if c contains a certain function m ' and the signature of m ' is the same as m, returning m ', otherwise, jumping to (2).
Step (2): dispatch (c ', m) is returned, where c' is the parent of c.
Therefore, the steps of determining the specific function called by the function calling instruction in the present application are as follows:
step (1): an objective function set T is constructed and initialized to null.
Step (2): and acquiring the signature m of the called function at the function calling instruction.
And (3): and if the function call instruction is a static call instruction, making T = { m }, and jumping to (8), otherwise, jumping to (4).
And (4): if the function call instruction is a dynamic call instruction, let c = type of caller instance object at the function call instruction.
And (5): if some subtype with type c' as c exists in the code, jumping to (6), otherwise, jumping to (8).
And (6): the return of Dispatch (c', m) is added to T.
And (7): the c' type is excluded from the code and the jump is made to (5).
And (8): returning to T, which is a set of possible called functions.
In an optional implementation manner, the first node and the second node are both nodes corresponding to a target program statement in the intelligent contract, and in step 103, a fact that data is transferred from the first node to the second node is determined as follows:
and if the target program statement is an assignment statement, and a program variable in the target program statement is the same as a basic variable in a preset data fact, or a member variable of the program variable is the same as the basic variable, or the program variable is the same as the member variable of the basic variable, determining the data fact transmitted from the first node to the second node according to the assignment of the program variable, wherein the basic variable is a non-member variable.
One possible implementation may also be as follows:
determining whether a first variable exists in the first function, wherein the first variable is a member variable of a second variable, and the first variable is any variable in the first function; if the first variable exists, updating the first variable in the first function to be in the form of a member variable of the second variable, and returning to the step of determining whether the first variable exists in the first function.
The specific implementation described above (which may be referred to as access path reforming) may be as follows:
may be used to reform the access path through a defined REIFY function. The meaning of access path reforming is that the basic variables in the access path are continuously expanded into access paths with lower levels until the basic variables cannot be expanded. For example, in the following code example:
tmp1 = y.f;
tmp2 = tmp1.g;
tmp2.h = a;
when the access path "tmp 2. h" is reformed, because tmp2 = tmp1.g, it is expanded to "tmp 1. g.h", and because tmp1 = y.f, it is expanded to "y.f.g.h", because the variable y is not further defined in the example, the reforming process is ended.
The main purpose of access path reformation is to ensure the accuracy of the analysis results. In the above example, assuming a is the transaction parallel conflict domain after the last program statement is executed, if there is no process of access path reforming, the analysis process would erroneously consider "tmp 2.h = a; the statement does not have any effect on y.f.g.h, i.e. the fact that a is a transaction parallel conflict domain is not propagated to the data members of variable y. Since "tmp 2.h = a" is seen from the dimension of a single statement, "the base variable" tmp2 "in the left-hand access path is not the same as" y ". Conversely, if the renormalization is performed before the data stream is propagated, the statement may be transformed to "y.f.g.h = a; ", so that the data fact can be correctly propagated to" y.f.g.h ".
In the present application, the input of the REIFY function is an access path in the form of "b.f 1 … fn", and the steps (1) to (5) of the reforming are as follows:
step (1): a constant value statement S about the variable b is looked up in the code intermediate representation.
Step (2): if S is a constant value statement like "b = y.g1.. gm", then jump to (3), otherwise jump to (4).
And (3): return to REIFY (y.g. 1 … gm) and jump to (5).
And (4): f1 … fn.
And (5): and (6) ending.
It should be noted that, in a possible implementation manner of step 103, both the first node and the second node are nodes corresponding to a target program statement in the intelligent contract, and the fact that the data is transferred from the first node to the second node is determined according to the following manner:
and if the target program statement is a storage read-write statement and the program variable in the target program statement is different from the basic variable in the preset data fact, determining the data fact transmitted from the first node to the second node according to the basic variable, wherein the basic variable is a non-member variable.
Therefore, the overall Flow chart of step 103 can be as shown in FIG. 3, i.e. the execution manner of Normal-Flow transfer function.
In this application, to support domain-sensitive transaction conflict domain analysis, the input of the Normal-Flow transfer function includes two parameters, the first parameter is a target program statement, the second parameter is a preset data fact, which may be a data fact after executing the statement, represented by access path form b.f1 … fn, that is, a variable is a transaction parallel conflict domain, and the data fact before executing the statement is calculated according to the specific type of the statement.
The representation form of the variable is like "b.f 1 … fn", wherein "b" is the basic variable, and "f 1 … fn" is the ordered sequence formed by the names of the domains according to the access order. In summary, the Normal-Flow transfer function in the present application is implemented as follows:
step (1): a data fact set T is constructed and initialized to null.
Step (2): and (3) if the current program statement is an assignment statement in the shape of 'x = y', and otherwise, jumping to (6).
And (3): if x and b are the same variable, jump to (4), otherwise jump to (5).
And (4): let T = { y.f1 … fn }, jump to (23).
And (5): let T = { b.f1 … fn }, jump to (23).
And (6): if the current program statement is a storage system read-write statement in the form of "getstorage (x)", or "setStorage (x, …)", then jump to (7), otherwise jump to (10).
And (7): if x and b are the same variable, jump to (8), otherwise jump to (9).
And (8): let T = { 0}, jump to (23).
And (9): let T = { b.f1.. fn }, jump to (23).
Step (10): if the current program statement is an assignment statement in the form of "x = y.g", then go to (11), otherwise go to (15).
Step (11): if x and b are the same variable, jump to (12), otherwise jump to (14).
Step (12): calling the REIFY function reforms "y.g" to morph it to "z.g 1 … gm".
Step (13): let T = { z.g1 … gm.f1 … fn }, jump to (23).
Step (14): let T = { b.f1.. fn }, jump to (23).
Step (15): if the current statement is an assignment statement shaped as "x.g = y".
Step (16): calling the REIFY function reforms "x.g" to morph it to "z.g 1 … gm".
Step (17): if z and b are the same variable, m is less than or equal to n, and "g 1 … gm" = "f 1 … fm", then go to (18), otherwise go to (23).
Step (18): let i = 1.
Step (19): and if i is less than or equal to m, jumping to (20), otherwise, jumping to (21).
Step (20): if gi is not an array type, let i = i +1, jump to (18), otherwise jump to (22).
Step (21): let T = { y.fm +1 … fn }, jump to (23).
Step (22): let T = { y.fm +1 … fn, b.f1 … fn }.
Step (23): and returning to T.
In a possible implementation manner, in step 104, according to each data fact node searched in the search process, a specific manner of determining the parallel conflict domain of the intelligent contract is as follows:
for any variable of any function of the functions, if the variable has a target propagation path, determining the variable as the variable in the parallel collision domain; the target propagation path is composed of corresponding continuous data fact nodes from the end node of the function to the start node of the function.
In the foregoing manner, for any variable of any function of each function, when the variable has a target propagation path, the relationship of data fact transfer may be characterized by corresponding consecutive data fact nodes between the end node of the function and the start node of the function, so as to determine that the variable is a variable in the parallel collision domain.
As shown in fig. 4, the present invention provides a device for determining a parallel conflict domain of an intelligent contract in a blockchain, including:
a building module 401, configured to build a first control flow graph of an intelligent contract, where the first control flow graph includes a sub-control flow graph of each function of the intelligent contract, the sub-control flow graph of the first function includes a start node and an end node of execution of the first function, and when the first function includes a call instruction, the sub-control flow graph of the first function includes a call node and a return node corresponding to the call instruction, where the first function is any one of the functions;
the first control flow graph is used for determining the calling relationship of each function, adding calling relationship edges among nodes with the calling relationship in the first control flow graph, determining the type of the added calling relationship edges, and obtaining a second control flow graph; the type of any calling relation edge represents the transmission type of data facts between a first node and a second node, and the first node and the second node are nodes at two ends of the calling relation edge; the fact that the data of any node of the first function indicates that the variable corresponding to the node is located in the parallel conflict domain of the first function before the program statement corresponding to the node is executed;
the data fact nodes are used for adding the corresponding variables of each node in the second control flow graph, and the data fact transmitted among the nodes in the second control flow graph is determined according to the calling relationship edges and types among the nodes in the second control flow graph, so that a third control flow graph is obtained;
a determining module 402, configured to search, for any function of the functions, a data fact node from a data fact node of an end node of the function to a data fact node of a start node of the function according to the third control flow graph, and determine a parallel conflict domain of the intelligent contract according to each data fact node searched in a searching process.
Optionally, the determining module 402 is further configured to:
determining a function of the first function call as follows:
if the first function comprises a dynamic call instruction, the instruction parameter of the dynamic call instruction comprises a function pointer of each called function, and a function signature of a second function in the dynamic call instruction and an instance object type for calling the second function are obtained, wherein the second function is any function of each called function;
determining whether a third function is included in the instance object type;
if the instance object type comprises a third function, and the function signature of the third function is the same as that of the second function, determining that the third function is a function called by the first function;
if the third function is not included in the instance object type, updating the instance object type to a subtype in the instance object type, and returning to the step of determining whether the third function is included in the instance object type.
Optionally, the determining module 402 is further configured to:
and if the first function comprises a static calling instruction, and the instruction parameter of the static calling instruction comprises the function name of a fourth function, determining the function name of the fourth function as the function called by the first function.
Optionally, the first node and the second node are both nodes corresponding to a target program statement in the intelligent contract, and the determining module 402 is further configured to:
determining the fact of data communicated by the first node to the second node as follows:
and if the target program statement is an assignment statement, and a program variable in the target program statement is the same as a basic variable in a preset data fact, or a member variable of the program variable is the same as the basic variable, or the program variable is the same as the member variable of the basic variable, determining the data fact transmitted from the first node to the second node according to the assignment of the program variable, wherein the basic variable is a non-member variable.
Optionally, the determining module 402 is further configured to:
determining whether a first variable exists in the first function, wherein the first variable is a member variable of a second variable, and the first variable is any variable in the first function;
if the first variable exists, updating the first variable in the first function to be in the form of a member variable of the second variable, and returning to the step of determining whether the first variable exists in the first function.
Optionally, the first node and the second node are both nodes corresponding to a target program statement in the intelligent contract, and the determining module 402 is further configured to:
determining the fact of data communicated by the first node to the second node as follows:
and if the target program statement is a storage read-write statement and the program variable in the target program statement is different from the basic variable in the preset data fact, determining the data fact transmitted from the first node to the second node according to the basic variable, wherein the basic variable is a non-member variable.
Optionally, the determining module 402 is further configured to:
for any variable of any function of the functions, if the variable has a target propagation path, determining the variable as the variable in the parallel collision domain; the target propagation path is composed of corresponding continuous data fact nodes from the end node of the function to the start node of the function.
Based on the same inventive concept, embodiments of the present invention further provide a computer device, which includes a program or an instruction, and when the program or the instruction is executed, the method for determining the parallel conflict domain of the intelligent contract in the blockchain and any optional method provided by the embodiments of the present invention are executed.
Based on the same inventive concept, the embodiment of the present invention further provides a computer-readable storage medium, which includes a program or an instruction, and when the program or the instruction is executed, the method for determining the parallel conflict domain of the intelligent contract in the blockchain and any optional method provided by the embodiment of the present invention are executed.
It should be apparent to those skilled in the art that embodiments of the present invention may be provided as a method, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
While preferred embodiments of the present invention have been described, additional variations and modifications in those embodiments may occur to those skilled in the art once they learn of the basic inventive concepts. Therefore, it is intended that the appended claims be interpreted as including preferred embodiments and all such alterations and modifications as fall within the scope of the invention.
It will be apparent to those skilled in the art that various changes and modifications may be made in the present invention without departing from the spirit and scope of the invention. Thus, if such modifications and variations of the present invention fall within the scope of the claims of the present invention and their equivalents, the present invention is also intended to include such modifications and variations.
Claims (9)
1. A method for determining a parallel conflict domain of an intelligent contract in a block chain is characterized by comprising the following steps:
constructing a first control flow graph of an intelligent contract, wherein the first control flow graph comprises sub control flow graphs of functions of the intelligent contract, the sub control flow graphs of the first functions comprise a starting node and an ending node of execution of the first functions, when the first functions contain a calling instruction, the sub control flow graphs of the first functions comprise the calling node and a returning node corresponding to the calling instruction, and the first functions are any functions in the functions;
determining the calling relationship of each function, adding calling relationship edges among nodes with calling relationship in the first control flow graph, determining the type of the added calling relationship edges, and obtaining a second control flow graph; the type of any calling relation edge represents the transmission type of data facts between a first node and a second node, and the first node and the second node are nodes at two ends of the calling relation edge; the fact that the data of any node of the first function indicates that the variable corresponding to the node is located in the parallel conflict domain of the first function before the program statement corresponding to the node is executed;
adding data fact nodes of each node to the dependent variable in the second control flow graph, determining data facts transmitted among the nodes in the second control flow graph according to the calling relationship edges and types among the nodes in the second control flow graph, and obtaining a third control flow graph;
for any function of the functions, searching a data fact node from a data fact node of an end node of the function to a data fact node of a start node of the function according to the third control flow graph, and for any variable of any function of the functions, if the variable has a target propagation path, determining the variable as a variable in the parallel collision domain; the target propagation path is composed of corresponding continuous data fact nodes from the end node of the function to the start node of the function.
2. The method of claim 1, wherein the function of the first function call is determined as follows:
if the first function comprises a dynamic call instruction, the instruction parameter of the dynamic call instruction comprises a function pointer of each called function, and a function signature of a second function in the dynamic call instruction and an instance object type for calling the second function are obtained, wherein the second function is any function of each called function;
determining whether a third function is included in the instance object type;
if the instance object type comprises a third function, and the function signature of the third function is the same as that of the second function, determining that the third function is a function called by the first function;
if the third function is not included in the instance object type, updating the instance object type to a subtype in the instance object type, and returning to the step of determining whether the third function is included in the instance object type.
3. The method of claim 2, further comprising:
and if the first function comprises a static calling instruction, and the instruction parameter of the static calling instruction comprises the function name of a fourth function, determining the function name of the fourth function as the function called by the first function.
4. The method of claim 1, wherein the first node and the second node are both nodes corresponding to a target program statement in the intelligent contract, and the fact that the data is transferred from the first node to the second node is determined as follows:
and if the target program statement is an assignment statement, and a program variable in the target program statement is the same as a basic variable in a preset data fact, or a member variable of the program variable is the same as the basic variable, or the program variable is the same as the member variable of the basic variable, determining the data fact transmitted from the first node to the second node according to the assignment of the program variable, wherein the basic variable is a non-member variable.
5. The method of claim 1, further comprising:
determining whether a first variable exists in the first function, wherein the first variable is a member variable of a second variable, and the first variable is any variable in the first function;
if the first variable exists, updating the first variable in the first function to be in the form of a member variable of the second variable, and returning to the step of determining whether the first variable exists in the first function.
6. The method of claim 5, wherein the first node and the second node are both nodes corresponding to a target program statement in the intelligent contract, and the fact that the data is transferred from the first node to the second node is determined as follows:
and if the target program statement is a storage read-write statement and the program variable in the target program statement is different from the basic variable in the preset data fact, determining the data fact transmitted from the first node to the second node according to the basic variable, wherein the basic variable is a non-member variable.
7. A device for determining a parallel conflict domain of an intelligent contract in a block chain, comprising:
the building module is used for building a first control flow graph of the intelligent contract, the first control flow graph comprises sub-control flow graphs of all functions of the intelligent contract, the sub-control flow graphs of the first function comprise a starting node and an ending node of execution of the first function, when the first function contains a call instruction, the sub-control flow graphs of the first function comprise a call node and a return node corresponding to the call instruction, and the first function is any one of the functions;
the first control flow graph is used for determining the calling relationship of each function, adding calling relationship edges among nodes with the calling relationship in the first control flow graph, determining the type of the added calling relationship edges, and obtaining a second control flow graph; the type of any calling relation edge represents the transmission type of data facts between a first node and a second node, and the first node and the second node are nodes at two ends of the calling relation edge; the fact that the data of any node of the first function indicates that the variable corresponding to the node is located in the parallel conflict domain of the first function before the program statement corresponding to the node is executed;
the data fact nodes are used for adding the corresponding variables of each node in the second control flow graph, and the data fact transmitted among the nodes in the second control flow graph is determined according to the calling relationship edges and types among the nodes in the second control flow graph, so that a third control flow graph is obtained;
a determining module, configured to search, for any one of the functions, a data fact node from a data fact node of an end node of the function to a data fact node of a start node of the function according to the third control flow graph, and determine, for any variable of any one of the functions, that the variable is a variable in the parallel collision domain if the variable has a target propagation path; the target propagation path is composed of corresponding continuous data fact nodes from the end node of the function to the start node of the function.
8. A computer device comprising a program or instructions which, when executed by a processor, performs the method of any one of claims 1 to 6.
9. A computer-readable storage medium, comprising a program or instructions, which when executed by a processor, performs the method of any one of claims 1 to 6.
Priority Applications (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111472554.8A CN113867903B (en) | 2021-12-06 | 2021-12-06 | Method and device for determining parallel conflict domain of intelligent contract in block chain |
| PCT/CN2022/101643 WO2023103351A1 (en) | 2021-12-06 | 2022-06-27 | Method and apparatus for determining parallel collision domain of smart contract in blockchain |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111472554.8A CN113867903B (en) | 2021-12-06 | 2021-12-06 | Method and device for determining parallel conflict domain of intelligent contract in block chain |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113867903A CN113867903A (en) | 2021-12-31 |
| CN113867903B true CN113867903B (en) | 2022-04-01 |
Family
ID=78985969
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202111472554.8A Active CN113867903B (en) | 2021-12-06 | 2021-12-06 | Method and device for determining parallel conflict domain of intelligent contract in block chain |
Country Status (2)
| Country | Link |
|---|---|
| CN (1) | CN113867903B (en) |
| WO (1) | WO2023103351A1 (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113867903B (en) * | 2021-12-06 | 2022-04-01 | 深圳前海微众银行股份有限公司 | Method and device for determining parallel conflict domain of intelligent contract in block chain |
Citations (9)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102073589A (en) * | 2010-12-29 | 2011-05-25 | 北京邮电大学 | Code static analysis-based data race detecting method and system thereof |
| CN110263536A (en) * | 2019-06-21 | 2019-09-20 | 深圳前海微众银行股份有限公司 | The monitoring method and device of intelligent contract in a kind of block chain |
| CN111563820A (en) * | 2020-05-08 | 2020-08-21 | 中国工商银行股份有限公司 | Intelligent contract parallel execution method and device |
| CN112118290A (en) * | 2020-08-12 | 2020-12-22 | 北京大学 | Program analysis-based data resource management and control method |
| CN112767155A (en) * | 2021-01-19 | 2021-05-07 | 华南师范大学 | Intelligent contract security transaction sequence generation method, device, medium and equipment |
| CN112764897A (en) * | 2020-12-31 | 2021-05-07 | 杭州趣链科技有限公司 | Method, device and system for processing task request and computer readable storage medium |
| CN112837153A (en) * | 2021-02-10 | 2021-05-25 | 北京航空航天大学 | Intelligent contract conflict detection method based on directed acyclic graph |
| CN112965838A (en) * | 2021-03-16 | 2021-06-15 | 支付宝(杭州)信息技术有限公司 | Data race checking method and device for concurrent program |
| CN113609489A (en) * | 2021-07-21 | 2021-11-05 | 三峡大学 | Distributed detection method for intelligent contract conflict in industrial block chain |
Family Cites Families (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US11144893B2 (en) * | 2017-10-30 | 2021-10-12 | Nec Corporation | Method and system for securing smart contracts in blockchains |
| CN110490742B (en) * | 2019-08-13 | 2024-04-12 | 深圳前海微众银行股份有限公司 | Transaction execution method and device in blockchain |
| CN110599166A (en) * | 2019-09-09 | 2019-12-20 | 深圳前海微众银行股份有限公司 | Method and device for acquiring transaction dependency relationship in block chain |
| CN111797010B (en) * | 2020-06-23 | 2022-09-23 | 河海大学 | Intelligent contract test case generation method applying improved genetic algorithm |
| CN113867903B (en) * | 2021-12-06 | 2022-04-01 | 深圳前海微众银行股份有限公司 | Method and device for determining parallel conflict domain of intelligent contract in block chain |
-
2021
- 2021-12-06 CN CN202111472554.8A patent/CN113867903B/en active Active
-
2022
- 2022-06-27 WO PCT/CN2022/101643 patent/WO2023103351A1/en unknown
Patent Citations (9)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102073589A (en) * | 2010-12-29 | 2011-05-25 | 北京邮电大学 | Code static analysis-based data race detecting method and system thereof |
| CN110263536A (en) * | 2019-06-21 | 2019-09-20 | 深圳前海微众银行股份有限公司 | The monitoring method and device of intelligent contract in a kind of block chain |
| CN111563820A (en) * | 2020-05-08 | 2020-08-21 | 中国工商银行股份有限公司 | Intelligent contract parallel execution method and device |
| CN112118290A (en) * | 2020-08-12 | 2020-12-22 | 北京大学 | Program analysis-based data resource management and control method |
| CN112764897A (en) * | 2020-12-31 | 2021-05-07 | 杭州趣链科技有限公司 | Method, device and system for processing task request and computer readable storage medium |
| CN112767155A (en) * | 2021-01-19 | 2021-05-07 | 华南师范大学 | Intelligent contract security transaction sequence generation method, device, medium and equipment |
| CN112837153A (en) * | 2021-02-10 | 2021-05-25 | 北京航空航天大学 | Intelligent contract conflict detection method based on directed acyclic graph |
| CN112965838A (en) * | 2021-03-16 | 2021-06-15 | 支付宝(杭州)信息技术有限公司 | Data race checking method and device for concurrent program |
| CN113609489A (en) * | 2021-07-21 | 2021-11-05 | 三峡大学 | Distributed detection method for intelligent contract conflict in industrial block chain |
Also Published As
| Publication number | Publication date |
|---|---|
| WO2023103351A1 (en) | 2023-06-15 |
| CN113867903A (en) | 2021-12-31 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| JP7360328B2 (en) | Automatic dependency analyzer for heterogeneously programmed data processing systems | |
| US8793674B2 (en) | Computer-guided holistic optimization of MapReduce applications | |
| Charguéraud et al. | Machine-checked verification of the correctness and amortized complexity of an efficient union-find implementation | |
| Smith | Probabilistic noninterference through weak probabilistic bisimulation | |
| Liao et al. | Concurrency bugs in multithreaded software: Modeling and analysis using Petri nets | |
| Martínez et al. | Reactive model transformation with ATL | |
| CN110675255B (en) | Method and apparatus for concurrently executing transactions in a blockchain | |
| Bowers et al. | Top-down synthesis for library learning | |
| WO2015019364A2 (en) | Graph based ontology modeling system | |
| Zhao et al. | Overhead-conscious format selection for spmv-based applications | |
| Lebanoff et al. | Check-wait-pounce: Increasing transactional data structure throughput by delaying transactions | |
| CN113867903B (en) | Method and device for determining parallel conflict domain of intelligent contract in block chain | |
| CN110648124A (en) | Method and apparatus for concurrently executing transactions in a blockchain | |
| Wolf | How Petri net theory serves Petri net model checking: a survey | |
| Neele et al. | Solving parameterised boolean equation systems with infinite data through quotienting | |
| Coullon et al. | The SIPSim implicit parallelism model and the SkelGIS library | |
| Blicha et al. | A cooperative parallelization approach for property-directed k-induction | |
| Mutluergil et al. | A mechanized refinement proof of the Chase–Lev deque using a proof system | |
| Bousse et al. | Scalable armies of model clones through data sharing | |
| Ellen et al. | Universal constructions that ensure disjoint-access parallelism and wait-freedom | |
| Wu et al. | An empirical study on C++ concurrency constructs | |
| Bacci et al. | Convex lattice equation systems | |
| König et al. | Data Independence for Software Transactional Memory | |
| US20240104016A1 (en) | Intermediate Representation Method and Apparatus for Compiling Computation Graphs | |
| LaBorde et al. | Dynamic Transactional Transformation |
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 |