CN110795327B - Weighted dependency graph-based concurrent program execution trajectory static simplification method - Google Patents
Weighted dependency graph-based concurrent program execution trajectory static simplification method Download PDFInfo
- Publication number
- CN110795327B CN110795327B CN201810860882.7A CN201810860882A CN110795327B CN 110795327 B CN110795327 B CN 110795327B CN 201810860882 A CN201810860882 A CN 201810860882A CN 110795327 B CN110795327 B CN 110795327B
- Authority
- CN
- China
- Prior art keywords
- dependency graph
- events
- dependence
- local
- weighted
- 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
- 238000000034 method Methods 0.000 title claims abstract description 35
- 230000003068 static effect Effects 0.000 title claims abstract description 7
- 230000001360 synchronised effect Effects 0.000 claims description 14
- 230000001419 dependent effect Effects 0.000 claims description 4
- 238000012804 iterative process Methods 0.000 claims description 2
- 230000007547 defect Effects 0.000 abstract description 13
- 238000004364 calculation method Methods 0.000 description 4
- 238000010276 construction Methods 0.000 description 3
- 238000010586 diagram Methods 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000007812 deficiency Effects 0.000 description 1
- 230000004807 localization Effects 0.000 description 1
- 238000005457 optimization Methods 0.000 description 1
- 238000013522 software testing Methods 0.000 description 1
- 230000007704 transition Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
-
- 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/46—Multiprogramming arrangements
- G06F9/52—Program synchronisation; Mutual exclusion, e.g. by means of semaphores
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Software Systems (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Stored Programmes (AREA)
Abstract
The invention provides a weighted dependency graph-based concurrent program execution track static simplification method, which comprises the following steps: 1) calculating an event dependency relationship; 2) building a weighted dependency graph; 3) simplifying a weighted dependency graph; 4) and (6) topology sorting. The invention solves the problem that the prior concurrent program execution track method can not quickly and effectively obtain the optimal simplified track, not only furthest reduces the context switching in the original track, but also reduces a large amount of time consumed by randomness in the concurrent program execution track simplification process, further improves the debugging efficiency of the concurrent program, and thereby provides guarantee for accurately repairing the concurrent defects.
Description
Technical Field
The invention belongs to the technical field of software testing, in particular to the field of concurrent program debugging, and is used for helping developers to quickly understand and repair errors in concurrent programs.
Background
The rise of multi-core architecture processors has rapidly broken through the performance bottleneck of single-core processors. To accommodate hardware upgrades, programming must transition to multithreading. Therefore, concurrent programs are becoming the mainstream of the software development industry today. However, concurrency deficiencies can result due to the concurrent program's shared memory mechanism and thread scheduling uncertainty. Unlike serial programs, these concurrency flaws occur under a particular thread schedule, i.e., with contingencies. Even if a concurrency defect occurs in a certain program execution, the concurrency defect cannot be easily reproduced in the next execution, thereby bringing great trouble to the debugging work of the concurrency program.
The simplification of the execution track of the concurrent program can effectively help developers to quickly understand and repair the concurrent defects, and the program debugging efficiency is improved. By simplifying the execution track of the concurrent program, on one hand, the execution speed of the concurrent program can be improved on the premise of ensuring the recurrence of the concurrent defects, and on the other hand, the method is also beneficial to a developer to reason the reasons for causing the concurrent defects, thereby repairing the defects more accurately.
The main goal of concurrent program execution trace simplification is to reduce the number of thread switches. This problem has proven to be an optimization problem. The existing concurrent program execution trajectory simplification method mainly comprises the following 2 types: inline and offline simplifications. Inline simplification simplifies the trace by accurately acquiring shared memory dependencies on-the-fly using vector clock or lock distribution techniques, and then grouping variables using either transfer conventions or thread/space localization. The online simplification is accurate but less efficient. Offline simplification is a relatively straightforward simplification method. It first obtains the entire execution trajectory and then performs the simplified operation on the trajectory. A traditional simplification method based on a graph randomly selects a local edge, judges whether nodes at two ends of the local edge can be combined or not, and combines the nodes if the conditions are met. However, its randomness reduces the efficiency of concurrent program execution trace simplification, and in some cases, an optimal simplified trace cannot be obtained.
Disclosure of Invention
The invention aims to provide a method for statically simplifying the execution track of a concurrent program based on a weighted dependency graph, which solves the problem that the existing method for simplifying the execution track of the concurrent program cannot quickly and effectively obtain the optimal simplified track, further reduces context switching in the original track as much as possible, improves the working efficiency of software debugging and better infers the reason of the concurrency defect.
To achieve the above objective, the present invention provides a method for statically simplifying concurrent program execution traces based on a weighted dependency graph. The method comprises the following steps:
1) calculating an event dependency relationship, namely dividing two adjacent events into a local dependency and a remote dependency by judging whether the two adjacent events in an original track are in the same thread or not, and further dividing the two adjacent events into a conflict dependency and a synchronous dependency according to the two adjacent event types belonging to the remote dependency, wherein the conflict dependency comprises a read-write dependency, a write-read dependency and a write-write dependency, and the synchronous dependency comprises an unlocking and locking dependency, a thread creation and opening dependency, a thread quitting and ending dependency and a wakeup waiting dependency;
2) constructing a weighted dependency graph, namely constructing the weighted dependency graph by using the dependency relationship calculated in the step 1), adding a local edge and updating the node degree only when remote dependency occurs, otherwise, combining the node with the previous node, adding a remote edge and updating the node degree, and finally updating the weight of the local edge;
3) simplifying the weighted dependency graph, which is an iterative process, wherein each iteration selects a local edge with the minimum weight from the initial weighted dependency graph constructed in the step 2), and judges whether the local edge meets a merging condition, if the local edge is unreachable except the local edge from the entry node to the exit node, the local edge indicates that no other dependent event exists between the two nodes and the local edge can be merged, otherwise, the local edge cannot be merged, the degree of the relevant node and the weight of the relevant edge are updated after merging, and the iteration is carried out until all the local edges are checked once, so that the process of simplifying the weighted dependency graph is ended;
4) topological sorting, namely, for the simplified weighted dependency graph obtained in the step 3), generating a linear sequence by using an existing topological sorting algorithm, wherein the sequence is a final simplified concurrent program execution track, the occurrence sequence of events in the track still obeys the dependency relationship in the original track, and the track contains the least context switches.
Further, the specific steps of the step 1) are as follows:
step 1) -1: an initial state;
step 1) -2: judging whether two adjacent events belong to the same thread;
step 1) -3: if the two current events belong to the same thread, the two current events belong to local dependency and are added into a local dependency list;
step 1) -4: if the two current events do not belong to the same thread, further judging whether the two current events are two adjacent events with synchronous primitives, if so, judging that the two current events belong to synchronous dependency and adding the two current events into a synchronous dependency list;
step 1) -5: otherwise, the current two events belong to conflict dependency and are added into a conflict dependency list;
step 1) -6: judging whether all adjacent nodes are completely calculated, if so, executing the steps 1-7, otherwise, moving the checker forwards, returning to the steps 1-2, and continuously calculating the dependency relationship of two adjacent events;
step 1) -7: finishing the calculation of the event dependency relationship;
further, the specific steps of the step 2) are as follows:
step 2) -1: an initial state;
step 2) -2: adding local edges and updating the degree of the nodes;
step 2) -3: adding remote edges and updating the degree of the node;
step 2) -4: updating the weight of the local edge;
step 2) -5: finishing the construction of the initial weighted dependency graph;
further, the specific steps of the step 3) are as follows:
step 3) -1: an initial state;
step 3) -2: selecting a local edge with the minimum weight;
step 3) -3: judging whether a merging condition is met, if so, executing the steps 3) -4, otherwise, returning to the steps 3) -2, and reselecting a local edge with the minimum weight;
step 3) -4: combining the nodes at two ends of the local edge;
step 3) -5: updating the degree of the related node;
step 3) -6: updating the weight of the relevant edge;
step 3) -7: judging whether all edges are checked, if so, executing the steps 3) -8, otherwise, returning to the steps 3) -2, and continuously selecting a local edge with the minimum weight;
step 3) -8: simplifying the weighted dependency graph;
further, the specific steps of the step 4) are as follows:
step 4) -1: an initial state;
step 4) -2: selecting a topological sorting algorithm;
step 4) -3: generating a sequence by using the topological sorting algorithm selected in the step 4) -2;
step 4) -4: the simplified concurrent program execution track is generated;
the invention simplifies the concurrent program execution track based on the weighted dependency graph, improves the understanding of the concurrent defects and improves the efficiency of simplifying the concurrent program execution track; calculating the dependency relationship of all events in the original execution track, constructing an initial weighted dependency graph, simplifying the weighted dependency graph as much as possible on the premise of not breaking the event dependency relationship, and finally performing topological sorting on the simplified weighted dependency graph by using a topological sorting algorithm to generate a linear sequence, namely the simplified concurrent program execution track. Therefore, the reason of the concurrent defects caused by the concurrent defects is rapidly inferred, the debugging efficiency of the concurrent program is improved, and the repairing accuracy of the concurrent defects is further improved.
Drawings
Fig. 1 is a flowchart of a method for statically simplifying a concurrent program execution path based on a weighted dependency graph according to an embodiment of the present invention.
Fig. 2 is a flowchart of event dependency calculation in fig. 1.
FIG. 3 is a flow chart of the weighted dependency graph construction of FIG. 1.
FIG. 4 is a simplified flow diagram of the weighted dependency graph of FIG. 1.
Fig. 5 is a flow chart of the topology ranking of fig. 1.
Detailed Description
In order to better understand the technical content of the present invention, specific embodiments are described below with reference to the accompanying drawings.
Fig. 1 is a flowchart of a method for statically simplifying a concurrent program execution path based on a weighted dependency graph according to an embodiment of the present invention.
A method for statically simplifying a concurrent program execution path based on a weighted dependency graph is characterized by comprising the following steps:
1) calculating an event dependency relationship, namely dividing two adjacent events into a local dependency and a remote dependency by judging whether the two adjacent events in an original track are in the same thread or not, and further dividing the two adjacent events into a conflict dependency and a synchronous dependency according to the two adjacent event types belonging to the remote dependency, wherein the conflict dependency comprises a read-write dependency, a write-read dependency and a write-write dependency, and the synchronous dependency comprises an unlocking and locking dependency, a thread creation and opening dependency, a thread quitting and ending dependency and a wakeup waiting dependency;
2) building a weighted dependency graph, adding a local edge and updating the node degree only when remote dependency occurs, otherwise combining the node with the previous node, then adding a remote edge and updating the node degree, and finally updating the weight of the local edge;
3) simplifying the weighted dependency graph, iteratively selecting a local edge with the minimum weight from the constructed initial weighted dependency graph, judging whether the local edge meets a merging condition, if the local edge is unreachable except the local edge from an entry node to an exit node, indicating that no other dependent event exists between the two nodes, merging the local edge and the entry node, otherwise, not merging the local edge, updating the degree of the relevant node and the weight of the relevant edge after merging, iterating until all the local edges are checked once, and ending the simplification process of the weighted dependency graph;
4) and topological sorting, namely for the simplified weighted dependency graph, generating a linear sequence by using an existing topological sorting algorithm, wherein the sequence is a final simplified concurrent program execution track, the occurrence sequence of events in the track still obeys the dependency relationship in the original track, and the track contains the least context switching.
FIG. 2 is a flow chart of event dependency calculation. Judging whether two adjacent events in an original track are in the same thread, dividing the two adjacent events into local dependence and remote dependence, and further dividing the two adjacent events into conflict dependence and synchronous dependence according to the two adjacent event types belonging to the remote dependence, wherein the conflict dependence comprises read-write dependence, write-read dependence and write-write dependence, and the synchronous dependence comprises unlocking and locking dependence, thread creation and opening dependence, thread quitting and ending dependence and awakening and waiting dependence. The method comprises the following specific steps:
step 1: an initial state; step 2: judging whether two adjacent events belong to the same thread; and step 3: if the two current events belong to the same thread, the two current events belong to local dependency and are added into a local dependency list; and 4, step 4: if the two current events do not belong to the same thread, further judging whether the two current events are two adjacent events with synchronous primitives, if so, judging that the two current events belong to synchronous dependency and adding the two current events into a synchronous dependency list; and 5: otherwise, the current two events belong to conflict dependency and are added into a conflict dependency list; step 6: judging whether all adjacent nodes are completely calculated, if so, executing a step 7, otherwise, moving the checker forwards, returning to the step 2, and continuously calculating the dependency relationship of two adjacent events; and 7: and finishing the calculation of the event dependency relationship.
FIG. 3 is a flow chart of weighted dependency graph construction. And starting to construct an initial weighted dependency graph according to the event dependency relationship, adding a local edge and updating the node degree only when remote dependency occurs, otherwise, merging the node into the last node, then adding a remote edge and updating the node degree, and finally updating the weight of the local edge. The method comprises the following specific steps:
step 1: an initial state; step 2: adding local edges and updating the degree of the nodes; and step 3: adding remote edges and updating the degree of the node; and 4, step 4: updating the weight of the local edge; and 5: the initial weighted dependency graph is constructed.
Fig. 4 is a simplified flow diagram of a weighted dependency graph. Iteratively selecting a local edge with the minimum weight from the constructed initial weighted dependency graph, judging whether the local edge meets a merging condition, if the local edge is unreachable except the local edge from an ingress node to an egress node, indicating that no other dependent event exists between the two nodes, merging the local edge and the ingress node, otherwise, not merging the local edge, updating the degree of the relevant node and the weight of the relevant edge after merging, iterating until all local edges are checked, and ending the simplification process of the weighted dependency graph. The method comprises the following specific steps:
step 1: an initial state; step 2: selecting a local edge with the minimum weight; and step 3: judging whether a merging condition is met, if so, executing the step 4, otherwise, returning to the step 2, and reselecting a local edge with the minimum weight; and 4, step 4: combining the nodes at two ends of the local edge; and 5: updating the degree of the related node; step 6: updating the weight of the relevant edge; and 7: judging whether all edges are checked, if so, executing a step 8, otherwise, returning to the step 2, and continuously selecting a local edge with the minimum weight; and 8: and simplifying the weighted dependency graph.
FIG. 5 is a flow chart of topology ranking. For the simplified weighted dependency graph, an existing topological sorting algorithm is used for generating a linear sequence, the linear sequence is a final simplified concurrent program execution track, the occurrence sequence of events in the track still obeys the dependency relationship in the original track, and the track contains the least context switching. The method comprises the following specific steps:
step 1: an initial state; step 2: selecting a topological sorting algorithm; and step 3: generating a sequence by using the topological sorting algorithm selected in the step 2; and 4, step 4: and finishing the generation of the execution track of the simplified concurrent program.
In conclusion, the invention solves the problem that the prior concurrent program execution trajectory method can not quickly and effectively obtain the optimal simplified trajectory, not only reduces the context switching in the original trajectory to the maximum extent, but also reduces a large amount of time consumed by the concurrency program execution trajectory simplification process due to randomness, and further improves the concurrent program debugging efficiency, thereby providing guarantee for accurately repairing the concurrent defects.
Claims (4)
1. A static simplification method for a concurrent program execution track based on a weighted dependency graph is characterized in that the dependency relationship of all events in the track is calculated for the original concurrent program execution track, then an initial weighted dependency graph is constructed according to the dependency relationship of the events, further the initial weighted dependency graph is simplified on the premise of not breaking the event dependency relationship, finally the existing topological sorting algorithm is selected to carry out topological sorting on the simplified weighted dependency graph, and a linear sequence is generated, namely the simplified concurrent program execution track; the method comprises the following steps:
1) calculating an event dependency relationship;
definition 1: the dependency relationship of the two events is generally divided into local dependency and remote dependency;
local dependencies: indicating that two adjacent events are called by the same thread;
remote dependence: indicating that two adjacent events are called by two different threads;
definition 2: the two event remote dependencies can be divided into conflict dependencies and synchronization dependencies;
starting from every two adjacent events in the original track, sequentially judging whether the two events belong to the same thread, dividing the two events into local dependence and remote dependence, if the two events are called by the same thread, determining the two events are local dependence, otherwise, determining the two events are remote dependence; the remote dependence can be further divided into conflict dependence and synchronous dependence according to the event types, at least one of two events of the conflict dependence is write access, including read-write dependence, write-read dependence and write-write dependence, the synchronous dependence includes unlocking and locking dependence, thread creation and opening dependence, thread quitting and ending dependence and awakening and waiting dependence, and the two events are respectively added into the corresponding dependence relationship list;
2) building a weighted dependency graph;
connecting events by using the event dependency relationship calculated in the step 1) and using a local edge and a remote edge according to the sequence of the events in the track to form an initial weighted dependency graph, and updating the node degree and further updating the weight of the local edge every time a local edge and a remote edge are added in the process of constructing the dependency graph;
3) simplifying a weighted dependency graph;
the weighted dependency graph simplification is an iterative process, each iteration selects a local edge with the minimum weight from the initial weighted dependency graph constructed in the step 2), whether the local edge meets a merging condition is judged, if the local edge is unreachable except the local edge from an entry node to an exit node, it is indicated that no other dependent event exists between the two nodes, merging can be performed, otherwise merging cannot be performed, the degree of the relevant node and the weight of the relevant edge are updated after merging, iteration is performed until all the local edges are checked, and the weighted dependency graph simplification process is ended;
4) topology sorting;
for the simplified weighted dependency graph obtained in the step 3), generating a linear sequence by using an existing topological sorting algorithm, wherein the sequence is a final simplified concurrent program execution track, the occurrence sequence of events in the track still complies with the dependency relationship in the original track, and the track contains the least context switches.
2. The weighted dependency graph-based concurrent program execution trajectory static simplification method according to claim 1, wherein in step 2), an initial weighted dependency graph is constructed for all events in an original trajectory according to the dependency relationships calculated in step 1); only when remote dependence occurs, a local event node is newly created, otherwise, the local event node is added into the original local event node; and updating the node degree and further updating the weight of the local edge when adding one local edge and one remote edge.
3. The weighted dependency graph-based concurrent program execution trajectory static simplification method of claim 1, wherein in step 3), an initial weighted dependency graph is simplified to generate a simplified weighted dependency graph; the method comprises the following specific steps: iteratively selecting a local edge with the minimum weight, judging whether nodes at two ends of the local edge can be merged, namely whether the nodes except the local edge can be reached or not, merging can be carried out only under the condition that the nodes except the local edge cannot be reached, and then updating the degree of the related nodes and the weight of the related edges until all the local edges are checked, namely, the local edges which can not be merged in the dependency graph are not available.
4. The weighted dependency graph-based concurrent program execution trajectory static simplification method of claim 1, wherein in step 4), for a simplified weighted dependency graph, a linear sequence satisfying all event dependencies is generated; the method comprises the following specific steps: and selecting a topological sorting algorithm according to the simplified weighted dependency graph, and then generating a corresponding linear sequence according to the selected topological sorting algorithm, wherein the sequence is a simplified concurrent program execution track, meets the dependency relationship of all events in the original track, and has the least context switching.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810860882.7A CN110795327B (en) | 2018-08-01 | 2018-08-01 | Weighted dependency graph-based concurrent program execution trajectory static simplification method |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810860882.7A CN110795327B (en) | 2018-08-01 | 2018-08-01 | Weighted dependency graph-based concurrent program execution trajectory static simplification method |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110795327A CN110795327A (en) | 2020-02-14 |
| CN110795327B true CN110795327B (en) | 2021-07-30 |
Family
ID=69426051
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201810860882.7A Active CN110795327B (en) | 2018-08-01 | 2018-08-01 | Weighted dependency graph-based concurrent program execution trajectory static simplification method |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110795327B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111552843B (en) * | 2020-04-23 | 2023-03-31 | 中国电子科技集团公司第五十四研究所 | Fault prediction method based on weighted causal dependency graph |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102214141A (en) * | 2011-07-02 | 2011-10-12 | 中国矿业大学 | Real-time stack-based program slicing method |
| CN103605607A (en) * | 2013-12-02 | 2014-02-26 | 中标软件有限公司 | Software complexity analysis system and method |
| US9411706B1 (en) * | 2015-09-30 | 2016-08-09 | Semmle Limited | Suggesting candidate removable software dependencies |
| CN108304317A (en) * | 2017-12-28 | 2018-07-20 | 东南大学 | A kind of single process procedures static slicing method and system executing frequency based on path |
-
2018
- 2018-08-01 CN CN201810860882.7A patent/CN110795327B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102214141A (en) * | 2011-07-02 | 2011-10-12 | 中国矿业大学 | Real-time stack-based program slicing method |
| CN103605607A (en) * | 2013-12-02 | 2014-02-26 | 中标软件有限公司 | Software complexity analysis system and method |
| US9411706B1 (en) * | 2015-09-30 | 2016-08-09 | Semmle Limited | Suggesting candidate removable software dependencies |
| CN108304317A (en) * | 2017-12-28 | 2018-07-20 | 东南大学 | A kind of single process procedures static slicing method and system executing frequency based on path |
Non-Patent Citations (1)
| Title |
|---|
| 面向收敛的并发程序执行轨迹静态简化方法;常曦; 薛建新; 张卓; 毛晓光;《软件学报》;20170120;1107-1117 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110795327A (en) | 2020-02-14 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| Salzburger et al. | Optimisation of the ATLAS track reconstruction software for run-2 | |
| US8005770B2 (en) | Parallel generation of a bayesian network | |
| CN109522097B (en) | Concurrent defect detection method based on self-adaptive random test | |
| CN109960576A (en) | A kind of low energy consumption task scheduling strategy towards CPU-GPU isomery | |
| CN110399182B (en) | CUDA thread placement optimization method | |
| CN110795327B (en) | Weighted dependency graph-based concurrent program execution trajectory static simplification method | |
| Chen et al. | Variation-aware evaluation of MPSoC task allocation and scheduling strategies using statistical model checking | |
| CN104536877A (en) | Mixed strategy based test data generation method | |
| JP4050339B2 (en) | Concurrent program creation support device, parallel program creation method, and parallel program execution device | |
| Wang et al. | Evolution of China's city-size distribution: empirical evidence from 1949 to 2008 | |
| CN115238899A (en) | Quantum program parallel processing method and operating system for superconducting quantum computer | |
| CN112765827B (en) | Reliability analysis method of function related system | |
| Khandai et al. | Test case generation for concurrent system using UML combinational diagram | |
| CN110083538B (en) | Concurrent program noise injection method | |
| Ran et al. | Approximate optimal AUTOSAR software components deploying approach for automotive E/E system | |
| CN110059378B (en) | Automatic manufacturing system Petri network state generation method based on GPU parallel computing | |
| CN112364600B (en) | Processor micro-architecture design verification method | |
| CN110688093B (en) | Method for realizing lock instruction pseudorandom self-comparison verification model based on global constraint | |
| Han et al. | An improved method for test case prioritization in continuous integration based on reinforcement learning | |
| CN110096389A (en) | A kind of starting method, apparatus, equipment and the storage medium of database | |
| CN116361182B (en) | Symbol execution method for error state guidance | |
| CN113434374B (en) | Method and system for testing performance of memory management algorithm of real-time operating system | |
| Martí-Campoy et al. | An algorithm for deciding minimal cache sizes in real-time systems | |
| CN115827170A (en) | Parallel simulation method and device of computer system structure based on discrete event | |
| Zhao et al. | PICO: Accelerating All k-Core Paradigms on GPU |
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 |