CN104123178B - Parallelism constraint detection method based on GPUs - Google Patents

Abstract

The present invention is a method for detecting constraints in parallel based on a graphics processor. Steps: 1) using quantifiers as segmentation points, a constraint is divided into several processing units, and the recursive merger in the detection process is eliminated by scheduling these processing units. Maximize the degree of parallelism; 2) Generate a corresponding number of GPU threads according to the current processing unit and information set, each GPU thread calculates its corresponding variable assignment according to its own thread number, and processes the processing unit under this assignment. An assigned processing unit is called a parallel computing unit, which is the smallest unit that can be processed in parallel in the GPU; 3) The two-level storage strategy of the index-result pool, the non-fixed-length data generated by the nodes of all parallel computing units The results are stored in the result pool, and the starting address and length of the results generated by the nodes in the result pool are stored in the index. This strategy "serially allocates space and writes results in parallel", which can achieve a higher writing speed.

Description

Parallelization Constraint Detection Method Based on Graphics Processor

technical field

The invention relates to a parallelization constraint detection method based on a graphics processor.

Background technique

Constraint detection is a commonly used method to verify the validity of information. A constraint reflects a relationship that should be satisfied between one piece of information or multiple pieces of information. Generally speaking, a constraint is connected by several kinds of nodes: "universal quantifier" node, "existential quantifier" node, "and" node, "or" node, "implies" node, "not" node and "function" node . Each kind of node describes a specific relationship. Detecting constraints is to check the acquired information against predefined constraints, and a piece of information or a group of information that violates the constraints is invalid. Constraint detection is often combined with other applications.

There are two main types of current constraint detection methods: incremental detection and parallel detection. However, both of these methods are completely dependent on the central processing unit (CPU), thus consuming a large amount of computing resources that should be used for other applications. The calculation of this method no longer depends on the CPU, on the contrary, it mainly relies on the graphics processing unit (GPU) for calculation. Therefore, while improving the speed of constraint detection, this method also ensures sufficient computing resources for other applications.

Contents of the invention

Aiming at the deficiencies in the prior art, the present invention proposes a constraint detection method based on GPU, which takes too much time and occupies too many resources. The core of this method lies in three parts: constraint preprocessing; parallel strategy; storage strategy.

The technical solution of the present invention is: a parallel constraint detection method based on a graphics processor, which includes:

Constraint preprocessing, quantifier-based constraint segmentation method; specifically:

Step 1. Designate the constraint head node as the current node, and start splitting from the current node;

Step 2. If the current node is a "full name quantifier" or "existence quantifier" node, then divide the conglomerate into two sub-parts, one sub-part ends with the quantifier node, and the other starts with the sub-node of the quantifier node, specifying The child node of the quantifier node continues to split for the current node;

Step 3. If the current node is an "and" node, an "or" node or an "implication" node, specify the left child node of the node as the current node to continue splitting. After processing the left child node, specify the right child node of the node Continue splitting for the current node;

Step 4, if the current node is a "non" node, then specify the child node of the node to continue splitting for the current node;

Step 5. If the current node is a "function" node, stop the recursion of the current branch;

After splitting, a constraint is transformed into several processing units, each processing unit is disjoint, and all processing units together constitute the constraint.

Parallel strategy, a parallel processing method based on processing units; specifically:

Step 1. Calculate the number of threads N required, and set the context information set corresponding to the variable <υ ₁ ,υ ₂ ,...υ _n > in the path from the parent node of the current processing unit to the constraint head node as < S _i , S ₂ ,...S _n >, the number of pieces of information in each context information set is <I ₁ , I ₂ ,...I _n >, then N=I ₁ ×I ₂ ×...× I _n ; if the current processing unit does not contain any variable to the head node, or the current processing unit contains the head node, then N=1;

Step 2, generate N GPU threads, the thread id is from 0 to N-1 (the id is automatically assigned by the GPU); each thread independently calculates its corresponding assignment according to its own id, and setting the integer value M _i =j means that the variable υ _i takes It corresponds to the jth piece of information in the set S _i (0≤M _i <I _i ); then the value of M _i is obtained according to the following steps:

i: set size=1, cur=n;

ii: If cur ≥ 1, rotor iii, otherwise end;

iii: size=size*I _cur ; cur=cur-1, rotor ii.

Step 3. Each thread maps the calculated assignment to a processing unit to generate a parallel computing unit that each thread needs to process; each thread independently processes each parallel computing unit;

All the GPU threads described above are executed concurrently, and there is no dependency relationship between them.

storage strategy. The two-level storage method of the index-result pool mainly includes three parts: 1) index array, including two fields: the starting position pos of the result and the length len; 2) the result array; 3) the result array position pointer Pointer (referred to as location pointer), which can only be written exclusively. Assuming that the lengths of results generated by n threads are l ₁ , l ₂ ... l _i ... l _n , the two-level storage method of the index-result pool is specifically:

Step 1. Each thread calculates the storage position of its current node in the index array according to its assigned value;

Step 2. Each thread obtains the position pointer of the result array mutually exclusively. If the ith thread obtains the position pointer of the result array, it sets the starting position pos of the node as the current value of Pointer. After that,

Step 3, update the value of the result array position pointer: Pointer _new =Pointer _old +l _i , wherein, Pointer _old is the initial value of the position pointer, and l _i is the length of the result produced by the ith thread;

Step 4. After updating, release the result array position pointer for use by other threads, and fill the result into the result array, and fill the result length into the result length len of the node.

Beneficial effects of the present invention: the present invention can efficiently utilize GPU to carry out constraint detection: constraint segmentation eliminates recursion in the constraint processing process, making it suitable for the working mode of GPU; based on the parallel strategy of the processing unit, each thread can independently Locating and processing data improves the concurrency of the method; the concurrent storage strategy significantly improves storage efficiency. While improving the efficiency of constraint detection, the invention greatly reduces the dependence on CPU resources, so that more CPU resources can serve other applications. In addition, since the GPU and the CPU can execute at the same time, there is no waiting for each other, so this method can also use this feature to obtain additional efficiency gains.

Description of drawings

Fig. 1 is a use case diagram of constraint processing in the present invention.

Fig. 2 Context mapping and parallel strategy in the computing process of the present invention.

Figure 3 shows the two-level storage strategy of the present invention.

detailed description

The present invention will be described in further detail below in conjunction with the accompanying drawings and specific embodiments.

The GPU-based constraint detection method of this embodiment. The core of this method lies in three parts: constraint preprocessing; parallel strategy; storage strategy. Specifically:

1. Constraint preprocessing. The present invention proposes a constraint segmentation method based on quantifiers, comprising the following steps:

a) Designate the constraint head node as the current node, and start splitting from the current node;

b) If the current node is a "full quantifier" or "existence quantifier" node, divide the part into two subparts, one subpart ends with the quantifier node, and the other starts from the subnode of the quantifier node, specifying the quantifier The child nodes of the node continue to split for the current node;

c) If the current node is an "and" node, an "or" node or an "implication" node, specify the left child node of the node as the current node to continue splitting. After processing the left child node, specify the right child node of the node as The current node continues to split;

d) If the current node is a "non-" node, specify the sub-node of the node as the current node to continue splitting;

e) If the current node is a "function" node, stop the recursion of the current branch. After splitting, a constraint is transformed into several processing units, each processing unit is disjoint, and all processing units together constitute the constraint. Figure 1 shows a constraint, and its meaning is as follows: For any taxi in city A, the distance it travels within a period of time can only be within a reasonable range. For this constraint, it will be divided into three parts according to the above algorithm, as shown by the dotted line in the figure.

2. Parallel strategy. The processing unit-based parallel processing method includes the following steps:

a) Calculate the required number of threads N. Let the context information set corresponding to variables <υ ₁ ,υ ₂ ,...υ _n > in the path from the parent node of the current processing unit to the constraint head node be <S ₁ , S ₂ ,...S _n >, the number of pieces of information in each context information set is <I ₁ , I ₂ ,...I _n >, then N=I ₁ ×I ₂ ×...×I _n ; if the current processing unit reaches the head node Contains any variable, or the current processing unit contains a head node, then N=1;

b) Generate N GPU threads with thread ids ranging from 0 to N-1 (the id is automatically assigned by the GPU); each thread independently calculates its corresponding assignment according to its own id. Let the integer value M _i =j mean that the variable υ _i takes the jth piece of information in its corresponding set S _i (0≤M _i <l _i ), then the value of M _i is obtained according to the following steps:

i. let size=1, cur=n;

ii. If cur≥1, go to iii, otherwise end;

iii. size=size*I _cur ; cur=cur-1, transfer to ii

c) Each thread maps the calculated assignment to a processing unit to generate a parallel computing unit that each thread needs to process; each thread independently processes each parallel computing unit.

All the GPU threads described above are executed concurrently, and there is no dependency relationship between them. Take the constraints shown in Figure 1 as an example. Assume that two taxi information in city A are currently received: taxi 1 and taxi 2. Then, when calculating the processing unit 1, according to the above algorithm step a), the processing unit has 2 variables (a and b) from the root node, and each variable can take two values (taxi 1 and taxi 2), so N=4; 4 threads (ids are 0, 1, 2, 3 respectively) are generated according to step b). Each thread independently calculates the value of its variable. Taking the calculation of the variable value of the thread whose id is 3 as an example, the assignment calculation process corresponding to the two variables is:

size=1, cur=2;

size=1×I _cur =1×2=2, cur=cur-1=1;

Since cur ≥ 1, continue this process, you can get M ₁ = 1; finally get M ₁ = 1, M ₂ = 1, note that the information is numbered from 0, so M ₁ = 1, M ₂ = 1 means Both the first variable and the second variable take the second piece of information in their respective information sets, ie (a=taxi 2, b=taxi 2). Mapping the value to the processing unit can result in a parallel computing unit. Parallel computing unit group 1 in FIG. 2 shows four generated parallel computing units.

3. Storage strategy. The two-level storage method of the index-result pool mainly includes three parts: 1) index array, including two fields: the starting position pos of the result and the length len; 2) the result array; 3) the result array position pointer Pointer (referred to as location pointer), which can only be written exclusively. Assuming that the lengths of the results generated by n threads are l ₁ , l ₂ ... l _i ... l _n , the stored procedure of this method is as follows:

a) Each thread calculates the storage position of each current node in the index array according to its assignment;

b) Each thread obtains the position pointer mutually exclusive, if the i-th thread obtains the position pointer, then it sets the starting position pos of the node as the current value of Pointer, after that,

c) Update the value of the location pointer: Pointer _new = Pointer _old + l _i , wherein, Pointer _old is the initial value of the location pointer, and l _i is the length of the result generated by the i-th thread.

d) After updating, release the location pointer for use by other threads, and fill the result into the result array, and fill the result length into the result length len of the node.

The storage strategy is shown in Figure 3: There are three threads processing three nodes at the same time, and they all need to write results to memory. Assuming that the results of these three nodes need to occupy 1, 3, and 2 storage spaces respectively, they will apply for access location pointers (the current value is 0) at the same time. Assuming that thread _t1 obtains the right to access the position pointer, it sets the starting position of its own result as the current value of Pointer (ie 0), and updates the value of Pointer: Pointer _new = Pointer _old + 1 = 1, and then releases the pointer For access by threads t ₂ and t ₃ ; after t ₁ updates the value of the position pointer, fills the result into the description information array, and updates its own length in the index array (ie 1). The first element in the index array records the storage start position (0) and length (1) of the result generated by t ₁ . Assume that t ₂ obtains Pointer access right before t _3. Due to the update of t ₁ , the current value of Pointer is 1. Therefore, the starting position of the result of t ₂ is 1, and update the value of Pointer. Pointer _new = Pointer _old + 3 = 4. Release the Pointer, fill the result into the description information array, and update its own length in the index array (that is, 3). This strategy allocates space serially, but multiple threads can write results in parallel and without conflict.

The above 1, 2 expounded the method of using GPU parallel detection constraints, and 3 expounded the method of efficient parallel writing results suitable for GPU.

The above embodiments only describe part of the functions of the present invention, but the embodiments and drawings are not used to limit the present invention. Any equivalent changes or modifications made without departing from the spirit and scope of the present invention also belong to the protection scope of the present invention. Therefore, the scope of protection of the present invention should be determined by the content defined in the claims of the present application.

Claims (4)

1. A parallelization constraint detection method based on a graphics processor, characterized in that it comprises: quantifier-based constraint segmentation step; Parallel processing steps based on processing units; storage policy steps; The quantifier-based constraint segmentation step is specifically: Step 1. Designate the constraint head node as the current node, and start splitting from the current node; Step 2. If the current node is a "full quantifier" or "existence quantifier" node, divide the node into two subparts, one subpart ends with the quantifier node, and the other part starts with the subnode of the quantifier node. Specify the The child nodes of the quantifier node continue to split for the current node; Step 3. If the current node is an "and" node, an "or" node or an "implication" node, specify the left child node of the node as the current node to continue splitting. After processing the left child node, specify the right child node of the node Continue splitting for the current node; Step 4, if the current node is a "non" node, then specify the child node of the node to continue splitting for the current node; Step 5. If the current node is a "function" node, stop the recursion of the current branch; After splitting, a constraint is transformed into several processing units, each processing unit is disjoint, and all processing units together constitute the constraint. 2. The parallelization constraint detection method according to claim 1, characterized in that: the parallel processing step based on the processing unit is specifically: Step 1. Calculate the number of threads N required, and set the context information set corresponding to the variables <v ₁ ,v ₂ ,…v _n > in the path from the parent node of the current processing unit to the constraint head node as <S ₁ ,S ₂ ,…S _n >, the number of pieces of information in each context information set is <I ₁ ,I ₂ ,…I _n >, then N=I ₁ ×I ₂ ×…×I _n ; if the current processing unit reaches the end The node does not contain any variables, or the current processing unit contains the head node, then N=1; Step 2, generate N GPU threads, the thread id is from 0 to N-1 (the id is automatically assigned by the GPU); each thread independently calculates its corresponding assignment according to its own id, and the integer value M _i =j indicates that the variable v _i takes It corresponds to the jth piece of information in the set S _i (0≤M _i <I _i ); Step 3. Each thread maps the calculated assignment to a processing unit to generate a parallel computing unit that each thread needs to process; each thread independently processes each parallel computing unit; All the GPU threads described above are executed concurrently, and there is no dependency relationship between them. 3. the parallelization constraint detection method according to claim 2, is characterized in that: the value of _Mi among the step 2 draws by the following steps: i. Sub-step i: set size=1, cur=n; ii. Sub-step ii: if cur ≥ 1, go to rotor step iii, otherwise end; Sub-step iii: size=size*I _cur ; cur=cur-1, rotor step ii. 4. The parallelization constraint detection method according to claim 1, characterized in that: the storage strategy step is specifically: a two-level storage method of an index-result pool, comprising three parts: 1) an index array, comprising two Domain: the starting position pos and the length len of the result; 2) the result array; 3) the result array position pointer Pointer, which can only be written mutually exclusive; Assuming that the lengths of results generated by n threads are l ₁ , l ₂ ... l _i ... l _n , the two-level storage method of the index-result pool is specifically: Step 1. Each thread calculates the storage position of its current node in the index array according to its assigned value; Step 2. Each thread obtains the position pointer of the result array mutually exclusively. If the ith thread obtains the position pointer of the result array, it sets the starting position pos of the node as the current value of Pointer. After that, Step 3, update the value of the result array position pointer: Pointer _new =Pointer _old +l _i , wherein, Pointer _old is the initial value of the position pointer, and l _i is the length of the result produced by the ith thread; Step 4. After updating, release the result array position pointer for use by other threads, and fill the result into the result array, and fill the result length into the result length len of the node.