Automated Design Debugging With Maximum Satisfiability

Vennsa Technol., Inc., Toronto, ON, Canada
IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems (Impact Factor: 1.2). 12/2010; DOI: 10.1109/TCAD.2010.2061270
Source: IEEE Xplore

ABSTRACT As contemporary very large scale integration designs grow in complexity, design debugging has rapidly established itself as one of the largest bottlenecks in the design cycle today. Automated debug solutions such as those based on Boolean satisfiability (SAT) enable engineers to reduce the debug effort by localizing possible error sources in the design. Unfortunately, adaptation of these techniques to industrial designs is still limited by the performance and capacity of the underlying engines. This paper presents a novel formulation of the debugging problem using MaxSAT to improve the performance and applicability of automated debuggers. Our technique not only identifies errors in the design but also indicates when the bug is excited in the error trace. MaxSAT allows for a simpler formulation of the debugging problem, reducing the problem size by 80% compared to a conventional SAT-based technique. Empirical results demonstrate the effectiveness of the proposed formulation as run-time improvements of 4.5 × are observed on average. This paper introduces two performance improvements to further reduce the time required to find all error sources within the design by an order of magnitude.

  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: After functional verification detects a failure, design debugging aims to find all locations in the design that could be responsible for the observed error. The task of debugging becomes more difficult in modern designs because of the presence of multiple design errors. Multiple design errors exponentially increase the solution space of the debugging problem, leading to an intractable problem. This work aims to manage the complexity of multiple design errors within existing automated design debugging frameworks by using unsatisfiable cores to reduce the solution space. It builds upon previous work to generalize the generation and application of unsatisfiable cores for this purpose. An iterative debugging algorithm is presented in which unsatisfiable cores are generated as a by-product of the solving process to aid in reducing the search space for multiple design errors. Experiments on large designs for multiple errors show an average reduction in run-time of 22% with minimal impact to peak memory.
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Counterexample-guided inductive synthesis CEGIS is used to synthesize programs from a candidate space of programs. The technique is guaranteed to terminate and synthesize the correct program if the space of candidate programs is finite. But the technique may or may not terminate with the correct program if the candidate space of programs is infinite. In this paper, we perform a theoretical analysis of counterexample-guided inductive synthesis technique. We investigate whether the set of candidate spaces for which the correct program can be synthesized using CEGIS depends on the counterexamples used in inductive synthesis, that is, whether there are good mistakes which would increase the synthesis power. We investigate whether the use of minimal counterexamples instead of arbitrary counterexamples expands the set of candidate spaces of programs for which inductive synthesis can successfully synthesize a correct program. We consider two kinds of counterexamples: minimal counterexamples and history bounded counterexamples. The history bounded counterexample used in any iteration of CEGIS is bounded by the examples used in previous iterations of inductive synthesis. We examine the relative change in power of inductive synthesis in both cases. We show that the synthesis technique using minimal counterexamples MinCEGIS has the same synthesis power as CEGIS but the synthesis technique using history bounded counterexamples HCEGIS has different power than that of CEGIS, but none dominates the other.
    07/2014; 157. DOI:10.4204/EPTCS.157.10
  • [Show abstract] [Hide abstract]
    ABSTRACT: Register-transfer level (RTL) debug has become a resource-intensive bottleneck in modern very large scale integration computer-aided design flows, consuming as much as 32% of the total verification effort. This paper aims to advance the state-of-the-art in automated RTL debuggers, which return all potential bugs in the RTL, called solutions, along with corresponding corrections. First, an iterative algorithm is presented to compute the dominance relationships between RTL blocks. These relationships are leveraged to discover implied solutions with every new solution, thus significantly reducing the number of formal engine calls. Furthermore, a modern Boolean satisfiability (SAT) solver is tailored to detect debugging nonsolutions, sets of RTL blocks guaranteed to be bug-free, and to imply other nonsolutions using the precomputed RTL dominance relationships. Extensive experiments on industrial designs show a three-fold reduction in the number of SAT calls due to solution implications, coupled with faster SAT run-times due to nonsolution implications, resulting in a 2.63x overall speedup in total SAT solving time, demonstrating the robustness and practicality of the proposed approach.
    IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 01/2014; 33(1):153-166. DOI:10.1109/TCAD.2013.2278491 · 1.20 Impact Factor


Available from