CN113468047B - Concurrent self-adaptive random test method based on heuristic rule - Google Patents

Concurrent self-adaptive random test method based on heuristic rule Download PDF

Info

Publication number
CN113468047B
CN113468047B CN202110674680.5A CN202110674680A CN113468047B CN 113468047 B CN113468047 B CN 113468047B CN 202110674680 A CN202110674680 A CN 202110674680A CN 113468047 B CN113468047 B CN 113468047B
Authority
CN
China
Prior art keywords
program
queue
concurrent
state
memory access
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Active
Application number
CN202110674680.5A
Other languages
Chinese (zh)
Other versions
CN113468047A (en
Inventor
沐燕舟
王赞
刘爽
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Tianjin University
Original Assignee
Tianjin University
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Tianjin University filed Critical Tianjin University
Priority to CN202110674680.5A priority Critical patent/CN113468047B/en
Publication of CN113468047A publication Critical patent/CN113468047A/en
Application granted granted Critical
Publication of CN113468047B publication Critical patent/CN113468047B/en
Active legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/36—Preventing errors by testing or debugging software
    • G06F11/3668—Software testing
    • G06F11/3672—Test management
    • G06F11/3688—Test management for test execution, e.g. scheduling of test suites
    • Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
    • Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
    • Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
    • Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Computer Hardware Design (AREA)
  • Quality & Reliability (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Debugging And Monitoring (AREA)

Abstract

The invention discloses a self-adaptive random concurrent testing method based on heuristic rules, which comprises the following steps of 1, randomly executing a concurrent program to be tested as input; step 2, searching a program state space from an initial state; step 3, heuristic rule sorting selection is carried out, and the three heuristic rules are respectively thread switching frequency, write operation occupation ratio and number of shared variables; step 4, after sequencing based on distance measurement and heuristic rules, controlling the length of a queue Q for storing all feasible sub-states, and adjusting by using a hyper-parameter N until a termination state of a program is reached; and step 5, carrying out error reporting, namely detecting errors contained in the given concurrent program to be detected, and finally outputting a detailed information report of the detected errors. Compared with the prior art, the method improves the efficiency of accelerating the detection of the concurrent program by using the heuristic rule, thereby solving the problem of 'cold start' caused by the detection by using the memory access mode; by continuously accumulating the information searched before and correcting the detection direction after correction, the efficiency of detecting concurrent program errors is greatly improved.

Description

Concurrent self-adaptive random test method based on heuristic rule
Technical Field
The invention relates to the field of software testing, in particular to a concurrent self-adaptive random testing method.
Background
With the development of multi-core processors, concurrent programming is widely applied; but at the same time it is highly likely to introduce concurrent errors that are difficult to detect. Unlike errors in sequential programs, concurrent errors are of the heisenbugs error type, meaning that concurrent errors may only be displayed in a specifically scheduled manner on a given error-inducing input, and may only be observable when a developer executes a program of the same information multiple times. This undoubtedly increases the difficulty of detecting concurrency errors. In order to expose a large number of concurrent errors that may be contained in a program, researchers have proposed many methods for exploring a program scheduling execution path causing the concurrent errors, which mainly include two broad categories, an exhaustive search method and a random scheduling method. The recurrence of concurrency errors is very challenging due to the unpredictability of the schedule, and the randomness of the schedule presents difficulties in the detection and localization of concurrency errors.
Adaptive Random Test (ART) is a series of algorithms that adaptively generate sequential procedural random test cases. The algorithmic model is used to simulate that test cases that may cause errors are unevenly distributed in the input domain. Due to this distribution bias, errors may be densely distributed in certain parts of the input field. Based on this, researchers believe that test cases with uniform distributions are more prone to expose errors in programs. The idea of adaptive random testing is to initially explore the state space of a program using random search, and then gradually focus the search direction to previously unexplored directions.
Disclosure of Invention
By adopting the heuristic rule designed based on the program running information, the problem of cold start caused by insufficient information at the initial running stage of the self-adaptive random scheduling method ARS is solved, and when the distance measurement based on the memory access mode fails, the algorithm is helped to quickly locate the suspicious program scheduling point, so that the efficiency of detecting the concurrent defects is improved.
A self-adaptive random concurrent test method based on heuristic rules comprises the following steps:
step 1, randomly executing a concurrent program to be tested as an input of the process: firstly, randomly executing a program to be tested to obtain a result; if the execution already triggers the error contained in the program, directly outputting the detected error information, and quitting the operation; otherwise, recording the information of the program scheduling path which is successfully operated at random and the included memory access mode, storing the information in the set T as accumulated information, and providing guidance for later search detection to correct the later detection direction;
step 2, exploring the program state space from the initial state, and the specific processing comprises the following steps: after the program to be tested is executed randomly and errors are not encountered, the program returns to the initial state of the program state space again, and the state space of the program is explored again from top to bottom; in each exploration, all feasible direct sub-states under the current state of the concurrent program to be tested are obtained firstly and are all stored in a queue Q, and then distance measurement between a scheduling path formed by all the sub-states in the queue Q and the currently explored parallel program state and a program scheduling path explored in the queue T is calculated; then, sorting the queue Q in a descending order, selecting a queue head element, namely a substate which is the largest in distance with the set T, out of the queue, and then continuously executing; if the distance measurement of the head element in the queue Q after sorting is the same as the value of the second element, the sorting is considered invalid, and a heuristic rule sorting stage is entered;
calculating a distance metric based on the memory access pattern, wherein the expression is as follows:
Figure BDA0003120273240000021
wherein, dist (trace)a,traceb) Represents the number of memory access modes contained in the corresponding memory access mode sets, tracea,tracebTwo different program scheduling paths are shown separately,
Figure BDA0003120273240000022
respectively representing the memory access mode sets contained in the two program scheduling paths and the distance between the two program scheduling paths;
step 3, heuristic rule sorting selection is carried out, and the method specifically comprises the following steps: calculating values of the three heuristic rules corresponding to a scheduling path consisting of the substate with the largest distance measurement in the queue Q and the currently explored program state, and if the substate with the largest value can be distinguished from the queue Q according to any one of the three heuristic rules, finishing the sorting and discharging the substate out of the queue; otherwise, randomly selecting a dequeue from all substates with the maximum distance;
the three heuristic rules are respectively thread switching frequency, write operation occupation ratio and number of shared variables;
and step 4, continuing to execute again, specifically comprising the following steps: after sequencing based on distance measurement and heuristic rules, controlling the length of a queue Q for storing all feasible substates, after selecting the substate and continuing to execute, if the length of the queue Q exceeds a hyperparameter N, deleting redundant elements at the tail of the queue, then executing a new substate, and repeating the process of exploring a program state space until a termination state of the program is reached;
step 5, error reporting is carried out, and the method specifically comprises the following steps: if the program is normally executed and no error is reported, recording the information of the program scheduling path explored from the initial state to the current termination state into a set T, then returning to the initial state of the program, and restarting exploration; otherwise, the program error is detected, the operation is directly exited, and error information is reported.
Compared with the prior art, the method improves the efficiency of accelerating the detection of the concurrent program by using the heuristic rule, thereby solving the problem of 'cold start' caused by the detection by using the memory access mode; by continuously accumulating the information searched before and correcting the detection direction after correction, the efficiency of detecting concurrent program errors is greatly improved.
Drawings
FIG. 1 is an exemplary program code snippet screenshot;
FIG. 2 is a diagram illustrating a state space structure corresponding to an exemplary program code;
FIG. 3 is a schematic overall flow chart of the heuristic rule-based adaptive random concurrent testing method of the present invention;
FIG. 4 is a diagram illustrating the effect of different values of the hyper-parameter N on the scheduling times (P-measure);
FIG. 5 is a diagram illustrating the effect of different values of the hyperparameter N on the detection time;
FIG. 6 is a graph comparing the average performance of MAP Coverage for different methods.
Detailed Description
The technical solution of the present invention is further described in detail below with reference to the accompanying drawings and specific embodiments.
As shown in FIG. 1, a screenshot of an exemplary program code snippet is presented. Unlike sequential programs, concurrent programs run in a structure that is a mesh of class trees. The example program has a shared variable, account, which is initialized to 0 (line 14). The main thread creates two threads t1、t2(lines 15-16), each thread may execute code that accesses or modifies the shared variable accumot value (lines 9-10). When the thread t1Executing lines 9 and 10 code and thread t2Executing the operation of line 9 and line 10 codesWhen an error occurs, it will cause the program to run incorrectly (line 19), which is a typical data race.
FIG. 2 is a diagram illustrating a state space structure corresponding to an exemplary program code. The runtime state space corresponding to the example concurrent program is modeled as a hierarchical mesh structure. Wherein the node represents the program state, which includes all shared variable evaluations and the program counter for each thread of the program; the tags represent the translations caused by the corresponding threads and statements. For example,<ti,sj>representing the ith thread tiThe j line code s is executedjThe subsequent resulting change in program state. The program state will change after the instruction is executed and the target state after the transition is determined based on the evaluation of the shared variable for each thread and the next instruction to trigger. The memory access pattern is matched out through a complete or partial program scheduling path. As shown in table 1, there are 17 general memory access modes. For example, the program scheduling path<t1,s9>，<t1,s10>，<t2,s9>，<t2,s10>The type 2 and type 3 memory access patterns in table 1 may be matched: [ (t)1,s10{},{account})，(t2,s9,{account},{})][(t1,s10,{},{account})，(t2,s10,{},{account})]. As can be seen from Table 1, more shared variables may be matched to more memory access patterns. Other research efforts have also employed the number of shared variables as an important feature of concurrent error prediction. Therefore, the number of shared variables is used as a heuristic rule to rank the explored program sub-states.
TABLE 1
Figure BDA0003120273240000051
Fig. 3 is a schematic overall flow chart of the heuristic rule-based adaptive random concurrent testing method of the present invention. The process comprises the following steps:
step 1, randomly executing a concurrent program to be tested as an input of the process: firstly, randomly executing a program to be tested to obtain a result; if the execution already triggers the error contained in the program, directly outputting the detected error information, and quitting the operation; otherwise, recording the information (including the memory access mode) of the program scheduling path which is successfully operated at random at this time and storing the information in the set T as accumulated information, and providing guidance for later search detection to correct the later detection direction;
step 2, exploring the program state space from the initial state, and the specific processing comprises the following steps: after the program to be tested is executed randomly and errors are not encountered, the program returns to the initial state of the program state space again, and the state space of the program is explored again from top to bottom; in each exploration, all feasible direct sub-states under the current state of the concurrent program to be tested are firstly acquired and are all stored in a queue Q, and then the distance measurement between a scheduling path formed by all the sub-states in the queue Q and the currently explored parallel program state and a program scheduling path explored in the queue T is calculated:
euclidean distance is typically used as a computational indicator to measure the distance between test cases. However, the euclidean distance has no way to reflect the influence of different program scheduling paths in a concurrency detection scenario, and therefore, the concurrency defect cannot be effectively discovered. The invention designs the measurement mode of the relevant information of program scheduling by adopting the memory access mode. The potential intuition of such a design is that the memory access pattern contained in the scheduling path that causes the program crash to generate an error should be different from the memory access pattern contained in the scheduling path that ends normal operation, i.e., the distance metric between the two should be large. Based on the distance metric of the memory access pattern, the expression is as follows:
Figure BDA0003120273240000063
wherein, dist (trace)a,traceb) Indicating the differences contained between their corresponding sets of memory access patternsNumber of elements (i.e. memory access patterns), tracea,tracebTwo different program scheduling paths are shown separately,
Figure BDA0003120273240000062
Figure BDA0003120273240000061
and respectively representing the memory access mode sets contained in the two program scheduling paths and the distance between the two program scheduling paths.
According to the above formula, it is also shown that the more different the memory access modes contained in the two program scheduling paths are, the larger the distance value is.
Then, sorting the queue Q in a descending order, selecting out the queue head element (namely the sub-state with the largest distance compared with the T) and then continuing to execute; if the distance measurement of the head element in the queue Q after sorting is the same as the value of the second element, the sorting is considered to be invalid (a substate with the largest distance cannot be distinguished), and a heuristic rule sorting stage is entered;
step 3, heuristic sorting selection is carried out, and the specific processing is as follows: and calculating values of the three heuristic rules corresponding to a scheduling path consisting of the substate with the maximum distance measurement in the queue Q and the currently explored program state, finishing sequencing if one substate with the maximum value can be distinguished from the queue Q according to any one of the three heuristic rules, and discharging the substate out of the queue for continuous execution. Otherwise, randomly selecting one dequeue from all the sub-states with the largest distance, and continuing the execution on the basis of the dequeue.
The heuristic rule making method specifically comprises the following steps:
in order to make up for the problem of 'cold start' of an adaptive random scheduling ARS algorithm, three heuristic rules are provided to help the method locate program scheduling paths which are more suspicious and are more likely to trigger errors, and meanwhile, the probability of generating memory access modes on the paths is greatly improved, so that the first round of sequencing based on distance measurement can play a greater role. The memory access mode mainly comprises three elements, namely a thread, a shared variable and a read-write operation, and based on the three elements, the following heuristic rule is designed:
heuristic rule one, thread switching frequency. Frequent thread switches may disrupt the original program logic and introduce more memory access patterns and thus data contention, which will lead to the most serious concurrency errors. Therefore, the invention takes the thread switching frequency of the searched sub-state as one of the rules for assisting the sorting.
And a heuristic rule II is write operation ratio. Previous studies have shown that some memory access patterns trigger more errors, such as "pattern 3" in table 1. This mode is a sequential write of a shared variable by two different threads. Write operations are an important cause of concurrency errors, and therefore, the present invention uses the write operation ratio, i.e., the ratio of the total number of write operations to the total number of read and write operations, as one of the heuristic rules that help in ordering the accessed sub-states.
And a third heuristic rule is used for sharing the number of variables. The number of shared variables involved in the current program scheduling path is considered a third heuristic. As can be seen from Table 1, more shared variables may be matched to more memory access patterns. Other research efforts have also employed the number of shared variables as an important feature of concurrent error prediction. Therefore, the number of the shared variables is used as a heuristic rule to sequence the searched program sub-states;
and step 4, continuing to execute again, specifically comprising the following steps: after sequencing based on distance measurement and heuristic rules, in order to ensure the performance and efficiency of the invention in execution, the length of the queue Q storing all feasible sub-states needs to be controlled, and a hyper-parameter N is set in advance for adjustment. This means that after the selected sub-state is continuously executed, if the length of the queue Q exceeds N, the redundant elements at the end of the queue are deleted, then a new sub-state is executed, and the process of searching the program state space down in step 2 is repeated until the end state of the program is reached;
step 5, error reporting is carried out, and the method specifically comprises the following steps: if the program is normally executed and no error is reported, recording the information of the program scheduling path searched from the initial state search to the current termination state into the set T, then returning to the program initial state and restarting the search. Otherwise, it means that the present invention detects the error of the program, directly exits from the operation, and reports the error information.
The invention evaluates on the existing common 45 concurrent benchmarks. These programs have been widely used to test the performance of new methods in various concurrent testing fields, mainly including concurrent error detection, localization and repair. Each program contains at least one concurrent error, which can be roughly classified into four categories, namely data contention, sequential conflict, atomic conflict or deadlock. Since the method function and the shared variable written in the original benchmark program during design have no or can not correctly realize the protection mechanism, the program crash or the memory damage can be caused in the actual operation. As shown in Table 2, the present invention is
The first column of the comparison result between the obvious concurrent benchmark program information and the existing concurrent defect detection method is the name of the project program, the second column is the total code line number of the project program, the third column is the total thread number contained in the project program, and the fourth column is the concurrent error type contained in the project program. The evaluation results show that compared with the existing method, the method provided by the invention has more stable performance in the aspects of effectiveness and efficiency of detecting the concurrency error.
Figure BDA0003120273240000081
Particularly, the method can effectively shorten the detection time, is obviously superior to the existing detection method (namely SR, MCR and TSA), and averagely reduces 44.27%, 97.89% and 28.31%; from the view of the program scheduling times spent on detecting errors, the promotion rates of the method are 72.58%, 79.64% and 58.02% for the other three methods respectively. In addition, it is worth noting that the invention can effectively detect some errors which are difficult to expose, the distribution of the errors in the program state space is very sparse, or the triggering condition is more complex. In addition, since most of the existing benchmark programs only contain one concurrency error, it is difficult to compare the capabilities of different methods for detecting more abundant concurrency errors in the above experiments, and MAP Coverage has been proved to be positively correlated with the capability of revealing concurrency errors. As shown in fig. 6, a graph comparing the average performance for MAP Coverage is shown. The performance of each method on the MAP coverage index is evaluated. Experimental results show that the method can reach higher MAP Coverage faster than other methods, which means that the method is more effective in detecting concurrency defects than the existing method and is more capable of detecting more abundant concurrency errors.
The invention relates to a program testing method oriented to concurrent modules, which is compiled by Java language, and models concurrent program blocks to be tested based on a JavaPathFinder framework to construct corresponding program state space.
The only hyper-parameter of the invention is the length control N of the queue Q storing all feasible sub-states, and the values of N are respectively discussed from 1 to 6 in order to select a parameter setting which can lead the invention to obtain the best performance. The results of the experiment are shown in two box plots in fig. 4 and 5. As shown in fig. 4, it is a schematic diagram of the influence result of different values of the hyper-parameter N on the scheduling times (P-measure) for detecting the first concurrent error; as shown in fig. 5, a schematic diagram of the effect of different values of the hyper-parameter N on the detection time is shown. Intuitively, the detection time of the present invention is affected by a variety of factors. A larger value for N means that more substates will be searched for in each iteration that are available for continuation. Therefore, a larger N may result in a decrease in the P-measure value. Further, the larger N, the more state information needs to be maintained, which takes time. From the experimental results of the scheduling times (P-measure) and the detection time, in order to balance the detection effectiveness (from the P-measure point of view) and the detection efficiency (from the execution time point of view), the invention considers that when N is 4, better comprehensive performance can be obtained.
In order to verify the effectiveness of the invention, the invention measures the detection performance from the two aspects of the scheduling times (P-measure) spent from exploration to the first concurrent error and the detection time. The fewer the number of schedules spent and the detection time, the better the performance of the detection. The experimental results are shown in column 10 after table 2, the invention can rapidly find the defects contained in the program to be tested with less cost, and the scheduling times and the average time spent for detecting the first error exploration on 45 common concurrent programs are 4.961 times and 1.790s respectively. Although slightly higher in runtime than the original adaptive random scheduling method (ARS), the cost of scheduling test can be significantly reduced and far better than other comparative methods: from the point of view of the number of spent scheduling times, the average lifting rates are 44.27%, 97.89% and 28.31% respectively; and from the detection time spent, the average lift rates were 72.58%, 79.64%, 58.02%, respectively. The three heuristic rules adopted by the invention can effectively help the algorithm to quickly locate the program scheduling path containing errors on the distance measurement based on the memory access mode, and the detection performance is improved.

Claims (1)

1. A self-adaptive random concurrent test method based on heuristic rules is characterized by comprising the following steps:
step 1, randomly executing a concurrent program to be tested as an input of the process: firstly, randomly executing a program to be tested to obtain a result; if the execution already triggers the error contained in the program, directly outputting the detected error information, and quitting the operation; otherwise, recording the information of the program scheduling path which is successfully operated at random and the included memory access mode, storing the information in the set T as accumulated information, and providing guidance for later search detection to correct the later detection direction;
step 2, exploring the program state space from the initial state, and the specific processing comprises the following steps: after the program to be tested is executed randomly and errors are not encountered, the program returns to the initial state of the program state space again, and the state space of the program is explored again from top to bottom; in each exploration, all feasible direct sub-states under the current state of the concurrent program to be tested are obtained firstly and are all stored in a queue Q, and then distance measurement between a scheduling path formed by all the sub-states in the queue Q and the currently explored parallel program state and a program scheduling path explored in the queue T is calculated; then, sorting the queue Q in a descending order, selecting a queue head element, namely a substate which is the largest in distance with the set T, out of the queue, and then continuously executing; if the distance measurement of the head element in the queue Q after sorting is the same as the value of the second element, the sorting is considered invalid, and a heuristic rule sorting stage is entered;
calculating a distance metric based on the memory access mode, wherein the expression is as follows:
Figure FDA0003120273230000011
wherein, dtst (trace)a，traceb) Represents the number of memory access modes, trace, contained between their corresponding memory access mode setsa，tracebTwo different program scheduling paths are shown separately,
Figure FDA0003120273230000012
respectively representing the memory access mode sets contained in the two program scheduling paths and the distance between the two program scheduling paths;
step 3, heuristic rule sorting selection is carried out, and the method specifically comprises the following steps: calculating values of three heuristic rules corresponding to a scheduling path consisting of the substate with the largest distance measurement in the queue Q and the currently explored program state, if the substate with the largest value can be distinguished from the queue Q according to any one of the three heuristic rules, finishing the sorting, and discharging the substate out of the queue; otherwise, randomly selecting a dequeue from all substates with the maximum distance;
the three heuristic rules are respectively thread switching frequency, write operation occupation ratio and number of shared variables;
and step 4, continuing to execute again, specifically comprising the following steps: after sequencing based on distance measurement and heuristic rules, controlling the length of a queue Q for storing all feasible substates, after selecting the substate and continuing to execute, if the length of the queue Q exceeds a hyperparameter N, deleting redundant elements at the tail of the queue, then executing a new substate, and repeating the process of exploring a program state space until a termination state of the program is reached;
step 5, reporting errors, which specifically comprises the following steps: if the program is normally executed and no error is reported, recording the information of the program scheduling path explored from the initial state to the current termination state into a set T, then returning to the initial state of the program, and restarting exploration; otherwise, the program error is detected, the operation is directly exited, and error information is reported.
CN202110674680.5A 2021-06-17 2021-06-17 Concurrent self-adaptive random test method based on heuristic rule Active CN113468047B (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CN202110674680.5A CN113468047B (en) 2021-06-17 2021-06-17 Concurrent self-adaptive random test method based on heuristic rule

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN202110674680.5A CN113468047B (en) 2021-06-17 2021-06-17 Concurrent self-adaptive random test method based on heuristic rule

Publications (2)

Publication Number Publication Date
CN113468047A CN113468047A (en) 2021-10-01
CN113468047B true CN113468047B (en) 2022-05-17

Family

ID=77870384

Family Applications (1)

Application Number Title Priority Date Filing Date
CN202110674680.5A Active CN113468047B (en) 2021-06-17 2021-06-17 Concurrent self-adaptive random test method based on heuristic rule

Country Status (1)

Country Link
CN (1) CN113468047B (en)

Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JPS6320657A (en) * 1986-07-14 1988-01-28 インタ−ナショナル　ビジネス　マシ−ンズ　コ−ポレ−ション Adapting mechanism pertaining to execution of sequential decision
WO2010001464A1 (en) * 2008-07-01 2010-01-07 富士通株式会社 Search device and search method
CN109522097A (en) * 2018-10-11 2019-03-26 天津大学 A kind of concurrent defect inspection method based on self-adapting random test
CN112817847A (en) * 2021-01-28 2021-05-18 杭州网易再顾科技有限公司 Data processing task testing method and device, electronic equipment and storage medium

Patent Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JPS6320657A (en) * 1986-07-14 1988-01-28 インタ−ナショナル　ビジネス　マシ−ンズ　コ−ポレ−ション Adapting mechanism pertaining to execution of sequential decision
WO2010001464A1 (en) * 2008-07-01 2010-01-07 富士通株式会社 Search device and search method
CN109522097A (en) * 2018-10-11 2019-03-26 天津大学 A kind of concurrent defect inspection method based on self-adapting random test
CN112817847A (en) * 2021-01-28 2021-05-18 杭州网易再顾科技有限公司 Data processing task testing method and device, electronic equipment and storage medium

Non-Patent Citations (3)

* Cited by examiner, † Cited by third party
Title
《一种基于自适应随机测试的并发缺陷检测方法》;杨杨;《信息科技辑》;20200615;全文 *
基于地理邻近性的自编码器在地点推荐中的应用;张文翔;《计算机与现代化》;20180420(第04期);全文 *
自动程序修复方法研究述评;王赞等;《计算机学报》;20170728(第03期);全文 *

Also Published As

Publication number Publication date
CN113468047A (en) 2021-10-01

Similar Documents

Publication Publication Date Title
Černý et al. Quantitative synthesis for concurrent programs
Sen Effective random testing of concurrent programs
Chatterjee et al. Measuring and synthesizing systems in probabilistic environments
JP2018087812A (en) Method for simultaneously testing semiconductor device, manufacturing method, and computer storage medium
Pierrot et al. Learning compositional neural programs with recursive tree search and planning
WO2023142502A1 (en) Loop instruction processing method and apparatus, and chip, electronic device, and storage medium
CN115715414A (en) Partitionable neural networks for solid state drives
CN105190334A (en) Method and apparatus for device testing using multiple processing paths
CN112988587A (en) Program detection method and device
Jahan et al. Version specific test case prioritization approach based on artificial neural network
CN113468047B (en) Concurrent self-adaptive random test method based on heuristic rule
CN111522730B (en) Program testing method and device, computer device and computer readable medium
US7779230B2 (en) Data flow execution of methods in sequential programs
Beccuti et al. Markov decision Petri net and Markov decision well-formed net formalisms
CN110083538A (en) A kind of concurrent program noise injection method
CN108959032A (en) Real-time monitoring method and device for server service index and electronic equipment
CN111858361B (en) Atomic violation defect detection method based on prediction and parallel verification strategy
Ferris et al. WalkSAT as an Informed Heuristic to DPLL in SAT Solving
Avros et al. Boosted decision trees for behaviour mining of concurrent programmes
CN114153494A (en) Hot spot code optimization method and device based on thermodynamic diagram
Long et al. Checking linearizability with fine-grained traces
Parízek et al. Fast detection of concurrency errors by state space traversal with randomization and early backtracking
Alam et al. Production-run software failure diagnosis via A daptive C ommunication T racking
US20130031520A1 (en) Functional verification system for semiconductor integrated circuit, and functional verification method for semiconductor integrated circuit
Shirole et al. Test scenario selection for concurrency testing from UML models

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