CN111290946B - Floating point number error detection method and device based on atomic state function - Google Patents
Floating point number error detection method and device based on atomic state function Download PDFInfo
- Publication number
- CN111290946B CN111290946B CN202010056313.4A CN202010056313A CN111290946B CN 111290946 B CN111290946 B CN 111290946B CN 202010056313 A CN202010056313 A CN 202010056313A CN 111290946 B CN111290946 B CN 111290946B
- Authority
- CN
- China
- Prior art keywords
- point number
- atomic
- floating
- floating point
- state function
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
Abstract
The invention relates to a floating point number error detection method and device based on an atomic state function. The invention carries out instrumentation on a source code or a program to obtain the internal state of the program during operation; calculating an atomic state function operated by each floating point number according to the internal state of the program in operation, mining the internal relation between the atomic state function and the floating point number error, and deducing the strong relevance between the atomic state function and the error; constructing a search framework, and obtaining a test case set which can trigger a high-risk atomic state function by using a search algorithm; the test case set is high in uncovering error rate and can trigger input of significant floating point number errors. Because the atomic state function is calculated without introducing high-precision floating point numbers and without depending on test predictions, the method is independent of the test predictions, high in error uncovering rate, small in running overhead, independent of the high-precision floating point numbers and fast in running time.
Description
Technical Field
The invention belongs to the technical field of software testing, relates to a numerical operation program and a floating-point program error detection method, and particularly relates to a floating-point error detection method and device based on an atomic state function. The method obviously improves the uncovering error probability and the operating efficiency of the floating point number error detection tool, so that a tester can detect more floating point number errors (defects) with larger errors in a shorter time in the test process.
Background
The floating point number error detection is the most effective means for ensuring the quality of numerical operation programs and floating point number programs. Methods such as static analysis and dynamic testing are widely applied to floating point number error detection technology. When numerical operation program and floating point program testers utilize a static analysis tool to detect errors, estimating the upper bound of program errors by using methods such as interval operation, affine (affine) operation and the like; when the dynamic analysis tool is used for error detection, a test prediction generation tool is used, and a search-based method is used for searching a floating point number test case which can trigger a significant error in a test space. The test prediction refers to the theoretically exact result of a floating-point program. Specifically, the test prediction generation tool performs high-precision synchronous simulation on the operation in the original floating-point program by using a high-precision floating-point number type, so as to expect to obtain an accurate operation result. And calculating the floating point number error in the operation result of each test case by comparing the original result with the high-precision result. And converting the problem into a search problem, defining a search space as all possible floating point number test cases, defining a search fitness function (fitness function) as a floating point number error in an operation result, and aiming at triggering the test cases with the floating point number errors as large as possible. According to the existing research, how to generate a floating-point number test case with higher error uncovering probability and larger trigger error in shorter running time is the main challenge at present.
For runtime issues, the main challenge is to test the prediction generation part. Because the test prediction generation tool uses a high-precision floating point type, the operation efficiency of the test prediction generation tool is greatly lower than that of a common floating point type, so that a large amount of calculation time is consumed in test prediction generation. The existing dynamic test tool generally depends on a test prediction, and floating point number errors in an operation result are obtained through the test prediction so as to guide the search direction. The latest research can improve the convergence speed of the search algorithm and improve the operation efficiency to a certain extent by a genetic algorithm specific to the structural characteristics of floating point numbers. However, experiments show that the efficiency improvement brought by the method is very limited, and the operation overhead of the analysis tool is too large, so that the error detection tool cannot be still deployed in a practical project.
The main challenge for error detection problems is to uncover the error capability section. The static analysis tool cannot generate a specific test case, and is less helpful for debugging a developer; the dynamic test method depends on test prediction, uses a black box test method, and does not utilize the internal running state of a floating-point program, so that the error detection capability of the dynamic test method is not strong, namely the error detection capability is not strong, and the accuracy is low.
From the above two perspectives, it can be seen that the challenges of the floating-point error detection tool remain severe. The existing floating point number error detection tool has the following defects:
(1) the existing method is highly dependent on test predictions and cannot be operated without test predictions. Because the fitness function searched in the prior art is directly defined as an error, the fitness function must depend on the error of the calculation operation of the test prediction, namely the difference between the high-precision operation result (test prediction) and the original operation result is the error. In the case of no test prediction, the floating-point number error is concealed (no error information), and therefore cannot be detected.
(2) The existing method is based on a black box testing technology, and the error rate is not high. Due to the complexity of floating-point arithmetic, the magnitude of the error has no obvious correlation with the value of the test case. The technology based on the black box test does not try to acquire the running state of the program, so that the search algorithm has little available information, the search direction cannot be effectively guided, the search effect is poor, and the test case triggering a significant error cannot be found.
(3) The prior art relies on high precision test predictions and slow run times. Due to the fact that a large number of common precision (32 bits and 64 bits) floating point numbers are applied in practice, a large number of operations are optimized on the levels of a compiler, an architecture, a hardware chip and the like, and the operation efficiency of the floating point numbers is very high. In comparison, the high-precision floating-point number can only be operated by software simulation, and the operation efficiency is far lower than that of the common floating-point number. The test predicate generation tool must operate using high precision floating point numbers, making it run long with overhead that can be 1000 times or more. A large amount of operation extra cost enables the prior art not to be applied to large projects in the running time level and has no practical feasibility.
Disclosure of Invention
Aiming at the defects of the prior art, the invention provides a floating point number error detection method and device based on an atomic state function. The method defines the concept of an atomic state function, and provides an error introduction, propagation and amplification model based on the atomic state function, and the model is used for analyzing and understanding floating point number errors. By utilizing the atomic state function, the stability of each floating point operation can be quantitatively calculated in a floating point program. The invention proves that the atomic state function is highly related to the floating point number error through an error accumulation model based on the atomic state function and is a decisive factor of the floating point number error. Based on the above findings, the present invention proposes a search framework that uses a search-based approach to detect floating-point number errors.
The principle of the invention is as follows:
direct calculation of floating-point number errors (i.e., exact results minus actual operation results) is difficult due to the difficulty in obtaining test predictions (i.e., exact operation results). The method finds strong correlation between the atomic state function and the floating point number error, uses the search method to generate the test case, uses the atomic state function as the fitness function of the search, and does not directly use the error as the fitness function any more, so that the method does not depend on the test prediction. Because the information of the atomic state function is richer, the search direction can be better guided, the search efficiency is improved, and the test case with higher error uncovering rate and larger trigger error is found.
The technical scheme of the invention is as follows:
a floating point number error detection method based on an atomic state function comprises the following steps:
performing instrumentation on the source code or program;
executing the program after the pile insertion, and acquiring the internal state of the program during the operation;
calculating an atomic state function on each floating point number atomic operation based on the internal state of the runtime;
and searching the largest atomic state function on each floating point number atomic operation to obtain a test case triggering the obvious floating point number error.
Further, the instrumented object includes all operations related to floating point arithmetic; the content of stake is: inserting an external function call before or after each floating-point number operation to acquire the internal state of the floating-point number operation, including the operation type, the operation parameter and the operation result; the pile inserting mode comprises the following steps: and in the source code compiling stage, instrumentation is carried out by adding an instrumentation function, dynamic instrumentation is carried out in the program running process, and instrumentation is carried out in the program compiling stage.
Furthermore, the atomic state function refers to a state function of floating-point atomic operation, and expresses a multiple of an error carried by an operand in the floating-point atomic operation, which is amplified by the floating-point atomic operation.
Further, the searching is to search a high-risk atomic state function by adopting an evolutionary algorithm specific to a floating point number type, use the atomic state function as a fitness function, and search a space for all possible floating point number inputs, namely test cases; in the searching process, for each floating point number atomic operation, searching the maximum atomic state function triggered by different test cases.
Further, the searching process comprises:
initializing a set of inputs, and calculating an atomic state function of each input on each floating-point number atomic operation;
performing P times of iterative search on each floating point number atomic operation, and generating M test cases in each iteration; in each iteration, selecting M test cases from the last iteration by using a selection operation, and carrying out mutation on the M test cases by using a mutation operation to obtain M test cases of the iteration;
and after all iterations are finished, reserving the test case for triggering the maximum atomic state function on the floating-point number atomic operation.
Further, in the selecting operation, each input is given a selection probability based on a geometric distribution according to an atomic state function of the input.
Further, in the mutation operation, for each selected input xiPlus a position parameter of 0 and a scale parameter of σkIs normally distributed with random variables to obtain an input x 'with a larger fitness function'i。
Based on the same inventive concept, the invention also provides a floating point number error detection device based on the atomic state function, which comprises:
the instrumentation module is used for performing instrumentation on the source code or the program to acquire the internal state of the instrumented program during running;
the inference module is used for calculating an atomic state function on each floating point number atomic operation based on the internal state in the runtime;
and the searching module is used for searching the largest atomic state function on each floating point number atomic operation to obtain the test case triggering the obvious floating point number error.
The invention carries out instrumentation on a numerical operation program and a floating point program in a compiling stage so as to obtain the internal state (comprising operation types, variable values and the like) of the program in operation; calculating an atomic state function operated by each floating point number according to the internal state of the program in operation, mining the internal relation between the atomic state function and the floating point number error, and deducing the strong relevance between the atomic state function and the error; constructing a search framework, and obtaining a test case set which can trigger a high-risk atomic state function by using a search algorithm; finally, the test case set is input with high uncovering error rate and can trigger obvious floating point number errors. Because the atomic state function is calculated without introducing high-precision floating point numbers and without depending on test predictions, the method has the following core advantages:
(1) independent of test prediction. The error detection work has better feasibility in practice.
(2) The error rate is high. Compared with the existing black box test technology, the atomic state function provides accurate error generation and accumulation information. The information can greatly improve the effectiveness of the search algorithm in error detection, improve the error rate and improve the practical significance.
(3) The running overhead is small, and the method does not depend on high-precision floating point numbers. The atomic state function can be directly calculated under ordinary precision, so that the method has the advantages of quick running time, low additional cost and high practical value at the running time level.
Experiments show that compared with the prior art, the method has the advantages that the running time is shortened to one percent to one thousandth of the original running time, and meanwhile, the error uncovering rate is obviously improved.
Drawings
FIG. 1 is a flow chart diagram of a floating point number error detection method based on an atomic state function according to the present invention.
FIG. 2 is a block diagram of the floating-point number error detection apparatus according to the present invention.
Detailed Description
The invention will be further described by way of examples, without in any way limiting the scope of the invention, with reference to the accompanying drawings.
Fig. 1 shows a flow of the method of the present invention, which specifically includes the following steps:
1) performing instrumentation on a source code or a program for acquiring runtime information;
2) executing the program after the pile insertion, and acquiring the internal state of the program during the operation;
3) calculating an atomic state function on each floating point number atomic operation based on the internal state in the operation;
4) searching the largest atomic state function on each floating point number atomic operation by using a search algorithm;
5) and obtaining a test case triggering large errors.
The invention includes a instrumentation phase, an inference phase, and a search phase.
1) Pile inserting stage
The purpose of instrumentation is to obtain the internal state (including operation type, variable values, etc.) of the program at runtime. The invention can adopt the following modes to carry out pile insertion:
a) and in the source code writing stage, the implementation is realized by adding an instrumentation function, namely the source code is instrumented before being compiled.
b) And performing dynamic instrumentation during running, and acquiring the internal state of the program during running by using a program tracking method.
c) At the compile time of the floating-point program, it is instrumented. Compared with dynamic instrumentation during operation, instrumentation operation cost during compiling is lower, and operation speed is higher.
1.1) object of pile insertion
The instrumented object includes all operations associated with floating point operations. Instrumented objects include, but are not limited to: four arithmetic operations, namely addition, subtraction, multiplication and division of floating point numbers; trigonometric function class, sin, cos, tan, asin, acos, atan, atan 2; hyperbolic function class, sinh, cosh, tanh; exponential and logarithmic function classes, exp, log, log 10; power function class, sqrt, pow. All floating-point operations can be instrumented and used to obtain internal states at runtime, and further used to compute atomic state functions in subsequent steps.
1.2) pile insertion Contents
The instrumentation content is to insert an external function call before (or after) each floating-point number operation to obtain the internal state of the floating-point number operation, including the operation type, the operation parameters and the operation result. For example, a function catchFP ("SIN", a, b) is inserted after b ═ SIN (a), and the operation type (SIN), the operation parameter (a), and the operation result (b) are transmitted to the external function catchFP to obtain runtime information.
2) Inference phase
The inference stage comprises the theoretical basis and the calculation method of the method. The method comprises the following parts of the definition of an atomic state function, an operational formula of the atomic state function and the strong correlation of the atomic state function and an error.
2.1) definition of atomic State function
The state function is an existing tool in the field of numerical analysis and is defined as
The invention proposes the concept of floating-point atomic arithmetic. Basic operations including floating point operations, including but not limited to: four arithmetic operations, namely addition, subtraction, multiplication and division of floating point numbers; trigonometric function class, sin, cos, tan, asin, acos, atan, atan 2; hyperbolic function class, sinh, cosh, tanh; exponential and logarithmic function classes, exp, log, log 10; power function class, sqrt, pow. In fact, all derivable functions can be classified in the category of atomic operations.
Based on the two concepts of the state function and the atomic operation, the invention provides the concept of the atomic state function. This concept is the core of the present invention. An atomic state function refers to a state function for floating-point atomic operations, e.g. for sin atomic operations, the atomic state function is
Different from the state function of complex operation, the state function has mathematical analysis expression due to the conductibility of atomic operation, and the specific value can be calculated more simply, conveniently and more quickly.
2.2) formula of atomic state function
Due to the guiding nature of atomic operations, the state function is mathematically expressed. Table 1 shows the atomic state function equations from the operations mentioned above.
TABLE 1 calculation formula of atomic state function
2.3) Strong correlation of atomic State function with error
The atomic state function expresses the number of times that an error carried by an operand is amplified by an atomic operation in the atomic operation. That is, if the atomic state function is 10000 and the input of the atomic operation contains a relative error of 0.000015, the operation result contains a relative error of 15%. In practice we find that almost all floating-point number errors are amplified by at least one high-risk (numerically extremely large) atomic state function. The atomic state function can be used as a fitness function for detecting floating point number errors.
3) Search phase
In order to find the high-risk atomic state function as efficiently as possible and find the obvious floating point number error, the invention adopts an evolutionary algorithm designed aiming at the characteristics of the floating point number to search the high-risk atomic state function. The search space is input for all possible floating point numbers (i.e., test cases). In the searching process, for each floating-point number atomic operation, the largest atomic state function triggered by different test cases is searched. The search includes fitness function, initialization, selection, mutation, and the like.
3.1) fitness function
The present invention uses an atomic state function as a fitness function. Unlike prior methods that use test predictions to calculate error as a fitness function. The atomic state function is used as the fitness function, and the method has the advantages of large information amount, good guidance, low operation overhead and the like.
3.2) search initialization
In the initialization stage, the method uniformly generates a large number of feasible inputs in the floating-point number space. For each input (test case), the atomic state function for each floating-point number atomic operation under that input is computed and recorded.
3.3) selection operation
For each floating-point number atomic operation, there is already a series of "input, atomic state function" pairs, denoted as { x }, during initializationi,CiIn which xiFor input, CiAs a function of the atomic state. The core idea in the selection step is that the input that would trigger a larger atomic state function should be more likely to enter the next generation population. Specifically, in this step, the present invention assigns a probability of being selected based on a geometric distribution to each input according to its atomic state function. Suppose an input xiIs ranked r among all the atomic state functions, then its probability of being selected is:
wherein M is the number of test cases in the population, and alpha is a parameter which can be set in the geometric distribution. Wherein the population refers to a group of test cases in each iteration process.
3.4) mutation operation
The core idea of the mutation step is that for each quiltThe selected input is searched "around" it in order to obtain an input with a larger fitness function. Specifically, in this step, the invention provides for each selected input xiPlus a position parameter of 0 and a scale parameter of σkIs normally distributed with random variables to obtain an input x 'with a larger fitness function'i。
x′i＝xi+xi*N(0,σk)
Wherein, P is the total iteration times, and k is the current iteration times. Sigma0And σPIs a settable parameter.
3.5) search method summary
In the search process, a set of inputs { x ] is first initialized1,x2,x3…, the atomic state function of each input on each atomic operation is computed. And then, for each atomic operation, P times of iterative search is carried out, and M test cases are generated in each iteration. In each iteration, M test cases are selected from the last iteration by using a selection operation, and the M test cases are mutated by using a mutation operation to obtain M test cases of the iteration. After all iterations are finished, the test case which triggers the maximum atomic state function on the atomic operation is reserved.
Key improvements created by the present invention include:
1. providing an atomic state function concept for analyzing floating point program errors;
2. the atomic state function is used as a fitness function of the search, so that the search effect is improved, and the running time expense is reduced;
3. the evolutionary algorithm is used for searching, and test cases with high error uncovering rate and large trigger errors are generated, so that the effect and efficiency of floating point number error detection are improved.
Experiments show that compared with the prior art, the method has the advantages that the running time is shortened to one percent to one thousandth of the original running time, and meanwhile, the error uncovering rate is obviously improved. The invention carries out error detection experiments on a widely used Scientific computational Library GNU Scientific Library, and the specific experimental results are as follows:
A) the error detection capability, namely the error uncovering rate, is greatly improved. As shown in table 2, the solution of the present invention is improved by 40% (28/20 ═ 1.4) compared to the prior art DEMC.
TABLE 2 error detection capability
| Significant errors are detected by the invention | 28 |
| DEMC detects significant errors | 20 |
B) The operating overhead is greatly reduced. As shown in table 3, compared with the prior art DEMC and LSGA, the scheme of the present invention is shortened to one hundredth to one thousandth (60/0.43: 139.5, 585.8/0.43: 1362).
TABLE 3 run time
| Average running time of the invention | 0.43 second |
| DEMC runtime | 585.8 seconds |
| LSGA run time | 60 seconds |
The search algorithm of the present invention does not necessarily have to use an evolutionary algorithm, nor does it necessarily have to use the specific selection operation or the specific mutation operation mentioned in the present invention. Other search algorithms may be used to detect floating point number errors. The core of the patent lies in proposing a search framework based on an atomic state function, which is not specific to a specific search algorithm.
Based on the same inventive concept, another embodiment of the present invention provides an apparatus for detecting floating point number errors based on atomic state functions, as shown in fig. 2, including:
the instrumentation module is used for performing instrumentation on the source code or the program to acquire the internal state of the instrumented program during running;
the inference module is used for calculating an atomic state function on each floating point number atomic operation based on the internal state in the runtime;
and the searching module is used for searching the largest atomic state function on each floating point number atomic operation to obtain the test case triggering the obvious floating point number error.
Wherein the specific implementation process of each module takes part in the description of the method of the present invention.
Based on the same inventive concept, another embodiment of the present invention provides an electronic device (computer, server, smartphone, etc.) comprising a memory storing a computer program configured to be executed by the processor and a processor, the computer program comprising instructions for performing the steps of the inventive method.
Based on the same inventive concept, another embodiment of the present invention provides a computer-readable storage medium (e.g., ROM/RAM, magnetic disk, optical disk) storing a computer program, which when executed by a computer, performs the steps of the inventive method.
It is noted that the disclosed embodiments are intended to aid in further understanding of the invention, but those skilled in the art will appreciate that: various substitutions and modifications are possible without departing from the spirit and scope of the invention and appended claims. Therefore, the invention should not be limited to the embodiments disclosed, but the scope of the invention is defined by the appended claims.
Claims (9)
1. A floating point number error detection method based on an atomic state function is characterized by comprising the following steps:
performing instrumentation on the source code or program;
executing the program after the pile insertion, and acquiring the internal state of the program during the operation;
calculating an atomic state function on each floating point number atomic operation based on the internal state of the runtime; the atomic state function is a state function of floating-point number atomic operation and expresses the multiple that the error carried by the operand in the floating-point number atomic operation is amplified by the floating-point number atomic operation;
and searching the largest atomic state function on each floating point number atomic operation to obtain a test case triggering the obvious floating point number error.
2. The method of claim 1, wherein the instrumented object includes all operations related to floating point operations; the content of stake is: inserting an external function call before or after each floating-point number operation to acquire the internal state of the floating-point number operation, including the operation type, the operation parameter and the operation result; the pile inserting mode comprises the following steps: and in the source code compiling stage, instrumentation is carried out by adding an instrumentation function, dynamic instrumentation is carried out in the program running process, and instrumentation is carried out in the program compiling stage.
3. The method of claim 1, wherein the searching is performed using an evolutionary algorithm specific to floating point number types to search for high risk atomic state functions, using the atomic state functions as fitness functions, and the search space is input for all possible floating point numbers; in the searching process, for each floating point number atomic operation, searching the maximum atomic state function triggered by different test cases.
4. The method of claim 3, wherein the searching comprises:
initializing a set of inputs, and calculating an atomic state function of each input on each floating-point number atomic operation;
performing P times of iterative search on each floating point number atomic operation, and generating M test cases in each iteration; in each iteration, selecting M test cases from the last iteration by using a selection operation, and carrying out mutation on the M test cases by using a mutation operation to obtain M test cases of the iteration;
and after all iterations are finished, reserving the test case for triggering the maximum atomic state function on the floating-point number atomic operation.
5. The method according to claim 4, characterized in that in the selection operation, for each input, according to its atomic state function, a selection probability based on a geometric distribution is assigned; hypothesis input
Is ranked r among all the atomic state functions, then its probability of being selected is:
wherein M is the number of test cases in the population,
is a parameter set in the geometric distribution.
6. The method of claim 4, wherein the mutation is performed in a mutation operationFor each selected input
Plus a position parameter of 0 and a scale parameter of
Normally distributing random variables to obtain an input with a larger fitness function
：
Wherein P is the total number of iterations, k is the current number of iterations,
and
is a set parameter.
7. An apparatus for detecting an error in a floating point number based on an atomic state function, comprising:
the instrumentation module is used for performing instrumentation on the source code or the program to acquire the internal state of the instrumented program during running;
the inference module is used for calculating an atomic state function on each floating point number atomic operation based on the internal state in the runtime; the atomic state function is a state function of floating-point number atomic operation and expresses the multiple that the error carried by the operand in the floating-point number atomic operation is amplified by the floating-point number atomic operation;
and the searching module is used for searching the largest atomic state function on each floating point number atomic operation to obtain the test case triggering the obvious floating point number error.
8. An electronic apparatus, comprising a memory and a processor, the memory storing a computer program configured to be executed by the processor, the computer program comprising instructions for performing the method of any of claims 1 to 6.
9. A computer-readable storage medium, characterized in that the computer-readable storage medium stores a computer program which, when executed by a computer, implements the method of any one of claims 1 to 6.
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911371673 | 2019-12-27 | ||
| CN2019113716737 | 2019-12-27 |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111290946A CN111290946A (en) | 2020-06-16 |
| CN111290946B true CN111290946B (en) | 2021-04-20 |
Family
ID=71028371
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010056313.4A Active CN111290946B (en) | 2019-12-27 | 2020-01-18 | Floating point number error detection method and device based on atomic state function |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111290946B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116431479A (en) * | 2023-03-16 | 2023-07-14 | 河南省核芯微电子科技有限公司 | Dyndinst-based floating point program precision loss detection method |
Family Cites Families (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7448026B1 (en) * | 2004-02-23 | 2008-11-04 | Sun Microsystems, Inc. | Method and apparatus for accuracy-aware analysis |
| CN110399286B (en) * | 2018-04-24 | 2023-05-12 | 西安邮电大学 | Independent path-based automatic test data generation method |
-
2020
- 2020-01-18 CN CN202010056313.4A patent/CN111290946B/en active Active
Also Published As
| Publication number | Publication date |
|---|---|
| CN111290946A (en) | 2020-06-16 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| Rubio-González et al. | Floating-point precision tuning using blame analysis | |
| Panchekha et al. | Automatically improving accuracy for floating point expressions | |
| US8539451B2 (en) | Systems and methods for model checking the precision of programs employing floating-point operations | |
| CN111104335B (en) | C language defect detection method and device based on multi-level analysis | |
| Li et al. | Discovery of potential parallelism in sequential programs | |
| Chen et al. | Coverage prediction for accelerating compiler testing | |
| US9329974B2 (en) | Technologies for determining binary loop trip count using dynamic binary instrumentation | |
| Liu et al. | Offline synthesis of online dependence testing: Parametric loop pipelining for HLS | |
| KR102013582B1 (en) | Apparatus and method for detecting error and determining corresponding position in source code of mixed mode application program source code thereof | |
| US20190095303A1 (en) | Systems and methods for measuring error in terms of unit in last place | |
| Saifullah et al. | Learning from examples to find fully qualified names of api elements in code snippets | |
| CN111290946B (en) | Floating point number error detection method and device based on atomic state function | |
| Chatelain et al. | VeriTracer: Context-enriched tracer for floating-point arithmetic analysis | |
| Févotte et al. | VERROU: Assessing floating-point accuracy without recompiling | |
| Févotte et al. | Debugging and optimization of HPC programs with the Verrou tool | |
| US6256776B1 (en) | Digital signal processing code development with fixed point and floating point libraries | |
| Saumya et al. | Xstressor: Automatic generation of large-scale worst-case test inputs by inferring path conditions | |
| Cummins et al. | Deep data flow analysis | |
| Damouche et al. | Transformation of a PID controller for numerical accuracy | |
| CN112016099A (en) | Method and system for analyzing static taint among binary program processes | |
| Févotte et al. | Debugging and optimization of HPC programs in mixed precision with the Verrou tool | |
| Pottenger | Induction variable substitution and reduction recognition in the Polaris parallelizing compiler | |
| Amaris et al. | Evaluating execution time predictions on gpu kernels using an analytical model and machine learning techniques | |
| Phalke et al. | Big-O time complexity analysis of algorithm | |
| Mosaner et al. | Compilation Forking: A Fast and Flexible Way of Generating Data for Compiler-Internal Machine Learning Tasks |
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 |