CN110059378B - Automatic manufacturing system Petri network state generation method based on GPU parallel computing - Google Patents
Automatic manufacturing system Petri network state generation method based on GPU parallel computing Download PDFInfo
- Publication number
- CN110059378B CN110059378B CN201910261540.8A CN201910261540A CN110059378B CN 110059378 B CN110059378 B CN 110059378B CN 201910261540 A CN201910261540 A CN 201910261540A CN 110059378 B CN110059378 B CN 110059378B
- Authority
- CN
- China
- Prior art keywords
- state
- transition
- reachable
- petri network
- petri
- 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.)
- Expired - Fee Related
Links
- 238000000034 method Methods 0.000 title claims abstract description 45
- 238000004519 manufacturing process Methods 0.000 title claims abstract description 11
- 230000007704 transition Effects 0.000 claims abstract description 41
- 239000011159 matrix material Substances 0.000 claims description 12
- 238000004364 calculation method Methods 0.000 abstract description 9
- 238000004880 explosion Methods 0.000 abstract description 4
- 230000000694 effects Effects 0.000 abstract description 3
- 230000006870 function Effects 0.000 description 7
- 230000008569 process Effects 0.000 description 5
- 238000002474 experimental method Methods 0.000 description 4
- 230000001133 acceleration Effects 0.000 description 3
- 238000004458 analytical method Methods 0.000 description 3
- 238000004891 communication Methods 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 238000003780 insertion Methods 0.000 description 2
- 230000037431 insertion Effects 0.000 description 2
- 238000005457 optimization Methods 0.000 description 2
- 238000012545 processing Methods 0.000 description 2
- HPTJABJPZMULFH-UHFFFAOYSA-N 12-[(Cyclohexylcarbamoyl)amino]dodecanoic acid Chemical compound OC(=O)CCCCCCCCCCCNC(=O)NC1CCCCC1 HPTJABJPZMULFH-UHFFFAOYSA-N 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 230000002401 inhibitory effect Effects 0.000 description 1
- 230000009467 reduction Effects 0.000 description 1
- 230000003252 repetitive effect Effects 0.000 description 1
- 238000003860 storage Methods 0.000 description 1
- 239000000126 substance Substances 0.000 description 1
- 230000009466 transformation Effects 0.000 description 1
- 230000000007 visual effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F30/00—Computer-aided design [CAD]
- G06F30/20—Design optimisation, verification or simulation
- G06F30/22—Design optimisation, verification or simulation using Petri net models
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02P—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN THE PRODUCTION OR PROCESSING OF GOODS
- Y02P90/00—Enabling technologies with a potential contribution to greenhouse gas [GHG] emissions mitigation
- Y02P90/02—Total factory control, e.g. smart factories, flexible manufacturing systems [FMS] or integrated manufacturing systems [IMS]
Landscapes
- Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- Theoretical Computer Science (AREA)
- Computer Hardware Design (AREA)
- Evolutionary Computation (AREA)
- Geometry (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Management, Administration, Business Operations System, And Electronic Commerce (AREA)
- General Factory Administration (AREA)
Abstract
The invention discloses a method for generating a Petri network state of an automatic manufacturing system based on GPU parallel computing, which comprises the following steps: the Petri network model to be solved and the Petri network system initial state M 0 Is converted intoInputting a file; initializing a table of a common array or linked list structure for representing a newly generated state set OPEN; initializing a table of a red-black tree structure for representing the generated state set CLOSED; initial state M of slave Petri net system 0 Starting, searching all reachable states of the Petri network to form a reachable state set; and outputting a state label and a state vector of each reachable state in the reachable state set, and specifically obtaining the state by which states are obtained by transmitting which transitions. The method disclosed by the invention can greatly improve the speed of calculating the Petri net reachable set by utilizing the GPU for parallel calculation and optimizing the data structure, has better and better effects when the reachable state number is increased continuously, and can effectively relieve the problem of state space explosion when a large Petri net model is analyzed.
Description
Technical Field
The invention belongs to the field of modeling and analysis of automatic manufacturing systems, and particularly relates to a Petri net state generation method of an automatic manufacturing system based on GPU parallel computing.
Background
Reachability graph analysis of a Petri net is one of the most basic, and most commonly used, methods for Petri net analysis. In general, the reachability graph calculation of the Petri net is carried out layer by layer from an initial state, and then serial calculation is carried out in a computer. However, when the scale of the Petri network is large, the number of reachable states is increased sharply, and a large amount of computing time and system resources are consumed by a serial computing method, so that the efficiency of modeling and analyzing the Petri network is greatly influenced.
The traditional method for serially calculating the reachable state set of the Petri network has the following characteristics and defects:
(1) in program implementation, the generation of reachable states employs a breadth-first policy. Generating each layer of successor identities through a breadth-first policy is one of the performance bottlenecks in building a complete set of reachable identities. In state M, the enable condition of each transition is judged, and the enable transition is transmitted to generate a new state. For each transition t, it is determined whether it is enabled, and typically only a few transitions are enabled under one identifier.
(2) Looking up whether the newly generated identification exists in the generated reachable graph G (N, M) 0 ) Is where the algorithm is most time consuming. For each enabled transition t in a state M in the current OPEN set, M' ═ M + [ N ] is calculated](. t) getting several new states, determining whether each newly generated state M' already exists in the CLOSED set, is a task that takes up a significant amount of CPU time, especially when Petri has a large number of reachable states.
Aiming at the two problems, the advantages of GPU parallel computing can be utilized to carry out optimization: on one hand, by utilizing multithreading, the enabling judgment and the expansion new state of a plurality of transitions are calculated simultaneously, so that the calculation time is greatly reduced; on the other hand, the GPU has better and higher computational efficiency by combining the hardware architecture and the characteristics of the GPU and aiming at the matrix operation involved in calculating the reachable set. Therefore, the method for serially calculating the reachable state set of the Petri network by using the GPU parallel operation as the optimization method instead of the traditional CPU has certain feasibility.
However, if the whole process of calculating the reachable state set of the Petri net is performed in the GPU, a new problem is exposed: when the repetitive state is removed, the whole generated reachable graph needs to be involved, and the OPEN and CLOSED sets are copied into the video memory, so that the communication between the CPU memory and the GPU video memory generates large time and system overhead, and the size of the video memory also restricts the algorithm to calculate the scale of the Petri network.
Disclosure of Invention
The invention aims to provide a Petri network reachable state generating method which has high calculating speed and better calculating result and can effectively relieve the problem of state space explosion by utilizing the advantages of GPU parallel calculation.
The technical solution for realizing the purpose of the invention is as follows: a method for generating a Petri network state of an automatic manufacturing system based on GPU parallel computing comprises the following steps:
step 1, a Petri network model to be solved and an initial state M of the Petri network system 0 Transformation ofIs an input file;
step 2, initializing a table of a common array or linked list structure, wherein the table is used for representing a newly generated state set OPEN; initializing a table of a red-black tree structure for representing the generated state set CLOSED;
step 3, starting from the Petri network system initial state M 0 Starting, searching all reachable states of the Petri network to form a reachable state set;
and 4, outputting the state label and the state vector of each reachable state in the reachable state set, wherein the states are obtained by transmitting the transition states.
Compared with the prior art, the invention has the following remarkable advantages: 1) advantages and disadvantages of the GPU and CPU calculation principle and characteristics are balanced, the Petri network reachable state is generated by mainly using GPU parallel calculation and secondarily using CPU calculation, and the problem of state space explosion can be effectively relieved; 2) the method has the advantages that the characteristic that GPU parallel computing is good at matrix operation is fully utilized, computing efficiency is improved, and particularly under the condition that the Petri network is large in size, the capability of analyzing and computing reachable states of the method is far higher than that of the existing method; 3) the GPU only judges the transition enabling and calculates the new state by the emission transition, thereby greatly inhibiting the communication overhead between the GPU and the CPU and ensuring the efficiency of the algorithm; 4) the traditional data structure is replaced by the data structure of the red and black tree, so that the link of duplicate removal is obviously optimized and improved compared with the original method; 5) the time complexity of the method of the invention is changed from the original O (n) 2 ) The reduction is O (lgn).
Drawings
FIG. 1 is a flow chart of the Petri net state generation method of the automatic manufacturing system based on GPU parallel computing.
FIG. 2 is a schematic diagram of a sequence of exchanging data and executing programs between a host side and a device side according to the present invention.
Fig. 3 is a diagram of a Petri net model corresponding to the workshop operation system in the embodiment of the invention.
Detailed Description
With reference to fig. 1, the method for generating the Petri net state of the automatic manufacturing system based on the GPU parallel computing comprises the following steps:
step 1, a Petri network model to be solved and an initial state M of the Petri network system 0 Converting into an input file;
step 2, initializing a table of a common array or linked list structure, which is used for representing a newly generated state set OPEN; initializing a table of a red and black tree structure for representing the generated state set CLOSED;
step 3, starting from an initial state M of the Petri network system 0 Starting, searching all reachable states of the Petri network to form a reachable state set;
and 4, outputting the state label and the state vector of each reachable state in the reachable state set, wherein the state is obtained by transmitting which transitions of which states.
Further, the format of the input file in step 1 is:
storing the self-defined incidence matrix and initial state sequence for Petri network model evolution in different files; wherein the content of the first and second substances,
(1) the incidence matrix is an integer matrix N with N rows and m columns, and is generated by adopting the following formula:
N＝{N ij if there is an arc pointing from transition j to library i, then N ij 1 is ═ 1; if there is an arc pointing from the library i to transition j, N ij -1; otherwise N ij ＝0}
In the formula, N ij The element of the ith row and j column in the matrix N, i is more than or equal to 1 and less than or equal to N, j is more than or equal to 1 and less than or equal to m, N is the number of banks in the Petri net, and m is the transition number;
(2) the initial state sequence is an integer sequence S ═ S i I is more than or equal to 1 and less than or equal to n, wherein S i Represents the initial state M 0 The number of the i-th library of (A) is counted.
Further, an initial state M is obtained from the Petri net system in step 3 0 Beginning, searching all reachable states of the Petri network to form a reachable state set, specifically:
step 3-1, setting the initial state M of the Petri net system 0 Adding an OPEN set and a CLOSED set;
3-2, distributing a video memory for the GPU and copying the OPEN set to the video memory; allocating a thread for each transition of each state in the OPEN set;
3-3, expanding the new state in parallel by using a search strategy in the GPU to obtain a new expanded state set;
step 3-4, with reference to fig. 2, removing the new extended state set obtained in step 3-3 from the video memory and adding the new extended state set into the OPEN set, and releasing the video memory space;
3-5, comparing the OPEN set with the CLOSED set, and removing repeated states, namely removing the states in the CLOSED set in the OPEN set; then adding the state in the OPEN set into the CLOSED set;
3-6, judging whether the OPEN set is empty, if so, terminating the search and obtaining all reachable states; otherwise, returning to the step 3-2.
Further preferably, the search strategy in step 3-3 specifically adopts a breadth-first search strategy.
Further preferably, the new state is expanded in step 3-3, specifically:
each transition of each state in the OPEN set is processed by one GPU thread, and the method specifically comprises the following steps:
3-3-1, judging whether a certain transition of a certain state M is enabled, if so, transmitting the transition, and executing the step 3-3-2; wherein, judge whether the transition enables, specifically do: if the transition t satisfies
Then transition t is enabled,. t represents the pre-repository location of transition t, M (p) represents the number of tokens in repository p, W (p, t) represents the weight of the arc between repository p and transition t;
step 3-3-2, calculating and transmitting a new state M' expanded from the state M after the transition, wherein the formula is as follows:
M'＝M+[N](·,t)
in the formula, [ N ] (. cndot., t) is an associated matrix column vector corresponding to the transition t.
The new state is expanded specifically as algorithm 1:
further preferably, the removing of the repetition state in step 3-5 specifically comprises:
for each state M in the OPEN set, searching a CLOSED set represented by a red-black tree from a root node, and if the same state M is found, deleting the state from the OPEN set; if not, the state is inserted into the red-black tree.
The processes of searching nodes and inserting nodes in the red and black tree are respectively as algorithm 2 and algorithm 3:
the search function SearchRBT in red and black trees starts first from the root node of the tree and returns a pointer to the node to be searched if the node key value is equal to the node. And if the key value of the node is smaller than the node to be searched, entering the left sub-tree to continue searching, and otherwise, entering the right sub-tree. Until the node is found or the leaf nodes of the red-black tree are reached.
The insert function InsertRBT in Algorithm 3 first looks for the position of the insert in the Red and Black Tree, corresponding to 1-7 lines in the pseudo code, which is similar to the SearchRBT function execution steps. After finding the corresponding insertion position, executing the insertion operation, and giving the color attribute to the node, wherein the color attribute corresponds to 8-16 lines of the pseudo code. The red-black tree may no longer satisfy its own structural properties after a new node is inserted, at which point the tree needs to be adapted, corresponding to the InsertRBT _ Fixup function. Since the InsertRBT _ Fixup function is an adjustment function of the red-black tree structure, the comparison logic is complicated and will not be described in detail.
The algorithm 4 is pseudo code of a Petri net reachable set generation algorithm of the automatic manufacturing system based on the GPU, and mainly comprises two steps of generating a subsequent node and removing a repeated node. For simplicity, the process of copying the host-side memory to the video memory and copying the video memory to the host-side memory is not given in the algorithm.
And the algorithm 4 adopts a breadth-first method to generate a Petri net reachable set. At the beginning, only the initial state M is in the OPEN set and the CLOSED set 0 . And under the condition that the OPEN set is not empty, expanding the subsequent identifier in the GPU in parallel by using a kernel function GPU-expand layer in the algorithm 1, copying the subsequent identifier into a CPU (central processing unit) memory, and completing the duplication checking work by using the optimized serial algorithms in the algorithms 2 and 3. Algorithm 4 also takes into account the fact that the required storage space in the OPEN set is identified to be larger than the video memory VRAM. And when the video memory capacity reaches the upper limit, adopting a method of expanding the OPEN set subsequent identification in batches. In the above algorithm, the CLOSED set is implemented by using a red-black tree, and the data structures of other data are implemented by using a common array or a linked list.
The present invention will be described in further detail with reference to examples.
Examples
The Petri net system model adopted in the embodiment is shown in FIG. 3, wherein the number of the libraries is 31, the number of the transitions is 24, and the initial identifier M of the system 0 That is {2,0,0,0,0,0,0,2,0,0,0,0,0,0,2,0,0,0,0,0,0,2,0,0,0,0,0,0,1,1,1 }. By changing the identity M 0 The Token number of the library is used for generating reachable sets of different scales so as to verify the performance of the method. At different initial identificationsLower (P) 1 ,P 2 ,P 3 ,P 4 ) The reachable state sets were calculated using the INA software, the optimized serial method, and the GPU-based method (Table 1 shows the method of the present invention), respectively, with the results shown in Table 1.
The computer CPU used in the experiment was Intel i 56500, which has a clock frequency of 3.2GHz and 4 processing cores. The CPU memory capacity is 8GB, and the mechanical hard disk capacity is 1 TB. The GPU adopts an NVIDIA GTX1050TI type video card, and has 1.39GHz clock frequency and 4GB video memory. The operating system used for the experiment was window10, and the programming environments were Microsoft Visual Studio2015 and CUDA 9.0. All experiments were completed with CPU memory overflow or longer than 1 day.
TABLE 1 reachable State set Generation speed comparison
In table 1, o.o.t. indicates that the software run time exceeds one day. In the first set of experiments, the number of reachable states was 157360, and the INA software calculated time was approximately 8 times the time used for the method of the present invention. When the number of reachable states reaches 6374984, the solving speed of the method is 133 times that of the INA method. It can be seen from the above table that compared with the conventional Petri net analysis software INA, the optimized serial method and the method of the present invention have obvious advantages in both the case where the reachable state sets are small in number and large in number.
Table 2 below further shows the performance comparison of the process of the present invention with the optimized serial process.
TABLE 2 acceleration effect after using the method according to the invention
In Table 2, T 1 Representation optimizationThe latter serial method calculates the time, T, used by the reachable state set 2 Representing the time it takes for the method of the present invention to compute a set of reachable states. When the number of reachable states is less, the acceleration efficiency of the method is about 20 percent, and along with the increase of the number of reachable states, the acceleration efficiency of the method is stabilized at about 30 percent.
The data show that the method can greatly improve the speed of calculating the Petri net reachable set by utilizing the GPU to calculate and optimize the data structure in parallel, has better and better effect when the reachable state number is increased continuously, and can effectively relieve the problem of state space explosion when a large Petri net model is analyzed.
Claims (2)
1. A Petri network state generation method of an automatic manufacturing system based on GPU parallel computing is characterized by comprising the following steps:
step 1, a Petri network model to be solved and an initial state M of the Petri network system 0 Converting into an input file;
step 2, initializing a table of a common array or linked list structure, which is used for representing a newly generated state set OPEN; initializing a table of a red-black tree structure for representing the generated state set CLOSED;
step 3, starting from the Petri network system initial state M 0 Starting, searching all reachable states of the Petri network to form a reachable state set; the method specifically comprises the following steps:
step 3-1, setting the initial state M of the Petri net system 0 Adding an OPEN set and a CLOSED set;
3-2, distributing a video memory for the GPU and copying the OPEN set to the video memory; allocating a thread for each transition of each state in the OPEN set;
3-3, expanding the new state in parallel by using a search strategy in the GPU to obtain a new expanded state set; the search strategy specifically adopts a breadth-first search strategy; the new state of the extension is specifically as follows:
each transition of each state in the OPEN set is processed by one GPU thread, and the method specifically comprises the following steps:
step (ii) of3-3-1, judging whether a certain transition of a certain state M is enabled, if so, transmitting the transition, and executing the step 3-3-2; wherein, judge whether transition enables, specifically do: if the transition t satisfies
M (p) ≧ W (p, t), transition t is enabled,. t represents the antecedent repository of transition t, (m) (p) represents the number of tokens in the repository p, W (p, t) represents the weight of the arc between repository p and transition t;
step 3-3-2, calculating and transmitting a new state M' expanded from the state M after the transition, wherein the formula is as follows:
M'＝M+[N](·,t)
wherein [ N ] (. t) is an associated matrix column vector corresponding to the transition t;
3-4, removing the new expansion state set obtained in the step 3-3 from the video memory, adding the new expansion state set into an OPEN set, and releasing the video memory space;
3-5, comparing the OPEN set with the CLOSED set, and removing repeated states, namely removing the states in the CLOSED set in the OPEN set; then adding the state in the OPEN set into the CLOSED set; the removing repetition state specifically includes:
for each state M in the OPEN set, searching a CLOSED set represented by a red and black tree from a root node, and if the same state M is found, deleting the state from the OPEN set; if not, inserting the state into the red-black tree;
3-6, judging whether the OPEN set is empty, if so, terminating the search and obtaining all reachable states; otherwise, returning to the step 3-2;
and 4, outputting the state label and the state vector of each reachable state in the reachable state set, wherein the states are obtained by transmitting the transition states.
2. The automatic manufacturing system Petri Net state generation method based on GPU parallel computing according to claim 1, wherein the format of the input file in the step 1 is as follows:
storing the self-defined incidence matrix and initial state sequence for Petri network model evolution in different files; wherein, the first and the second end of the pipe are connected with each other,
(1) the incidence matrix is an integer matrix N with N rows and m columns, and is generated by adopting the following formula:
N＝{N ij if there is an arc pointing from transition j to library i, then N ij 1 is ═ 1; if there is an arc pointed to by the library i to transition j, then N ij -1; otherwise N ij ＝0}
In the formula, N ij The matrix N is the element of the ith row and j column, i is more than or equal to 1 and less than or equal to N, j is more than or equal to 1 and less than or equal to m, N is the number of the banks in the Petri network, and m is the transition number;
(2) the initial state sequence is an integer sequence S ═ S i I is more than or equal to 1 and less than or equal to n, wherein S i Represents an initial state M 0 The number of the i-th library in (c).
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910261540.8A CN110059378B (en) | 2019-04-02 | 2019-04-02 | Automatic manufacturing system Petri network state generation method based on GPU parallel computing |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910261540.8A CN110059378B (en) | 2019-04-02 | 2019-04-02 | Automatic manufacturing system Petri network state generation method based on GPU parallel computing |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110059378A CN110059378A (en) | 2019-07-26 |
| CN110059378B true CN110059378B (en) | 2022-09-06 |
Family
ID=67318204
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910261540.8A Expired - Fee Related CN110059378B (en) | 2019-04-02 | 2019-04-02 | Automatic manufacturing system Petri network state generation method based on GPU parallel computing |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110059378B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117725348B (en) * | 2024-02-07 | 2024-05-10 | 蓝象智联(杭州)科技有限公司 | Thread management method and system in GPU computing large-scale array summation process |
Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105652833A (en) * | 2015-12-30 | 2016-06-08 | 南京理工大学 | Bi-directional intelligent search-based manufacturing enterprise shop scheduling optimization method |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8276124B2 (en) * | 2007-06-20 | 2012-09-25 | Microsoft Corporation | Constructing petri nets from traces for diagnostics |
-
2019
- 2019-04-02 CN CN201910261540.8A patent/CN110059378B/en not_active Expired - Fee Related
Patent Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105652833A (en) * | 2015-12-30 | 2016-06-08 | 南京理工大学 | Bi-directional intelligent search-based manufacturing enterprise shop scheduling optimization method |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110059378A (en) | 2019-07-26 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10332008B2 (en) | Parallel decision tree processor architecture | |
| US20150262062A1 (en) | Decision tree threshold coding | |
| US11349824B2 (en) | Block sequencing method and system based on tree-graph structure, and data processing terminal | |
| CN110852046B (en) | Block induction sequencing method and system for text suffix index | |
| CN112667528A (en) | Data prefetching method and related equipment | |
| US20150262063A1 (en) | Decision tree processors | |
| JP2019212171A (en) | Learning device and learning method | |
| CN110059378B (en) | Automatic manufacturing system Petri network state generation method based on GPU parallel computing | |
| CN110264392B (en) | Strong connection graph detection method based on multiple GPUs | |
| CN104866297B (en) | A kind of method and apparatus for optimizing kernel function | |
| CN109165201B (en) | Log merging method and terminal equipment | |
| CN116151384B (en) | Quantum circuit processing method and device and electronic equipment | |
| CN112199214A (en) | Candidate password generation and application cracking method on GPU | |
| JP7069898B2 (en) | Learning identification device and learning identification method | |
| CN112100446B (en) | Search method, readable storage medium, and electronic device | |
| CN108846248B (en) | Application modeling and performance prediction method | |
| Li et al. | Optimizing machine learning on apache spark in HPC environments | |
| Willson et al. | Comparing methods for species tree estimation with gene duplication and loss | |
| CN115827170B (en) | Parallel simulation method and device of computer architecture based on discrete event | |
| CN110334251B (en) | Element sequence generation method for effectively solving rehash conflict | |
| Ellis | Parallelizing irregular applications for distributed memory scalability: Case studies from genomics | |
| CN113485805B (en) | Distributed computing adjustment method, device and equipment based on heterogeneous acceleration platform | |
| CN111143456B (en) | Spark-based Cassandra data import method, device, equipment and medium | |
| US20220261669A1 (en) | Information processing system, information processing method, and computer-readable recording medium storing program | |
| CN108809726B (en) | Method and system for covering node by box |
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 | ||
| CF01 | Termination of patent right due to non-payment of annual fee | ||
| CF01 | Termination of patent right due to non-payment of annual fee |
Granted publication date: 20220906 |