An Automated Testing and Debugging Toolkit for Gate-Level Logic Synthesis Applications

  title={An Automated Testing and Debugging Toolkit for Gate-Level Logic Synthesis Applications},
  author={Siang-Yun Lee and Heinz Riener and Giovanni De Micheli},
Correctness and robustness are essential for logic synthesis applications, but they are often only tested with a limited set of benchmarks. Moreover, when the application fails on a large benchmark, the debugging process may be tedious and time-consuming. In some fields such as compiler con-struction, automatic testing and debugging tools are well-developed to support developers and provide minimal guarantees on program quality. In this paper, we adapt fuzz testing and delta debugging… 

Figures and Tables from this paper



Automated Whitebox Fuzz Testing

This work presents an alternative whitebox fuzz testing approach inspired by recent advances in symbolic execution and dynamic test generation, and implemented this algorithm in SAGE (Scalable, Automated, Guided Execution), a new tool employing x86 instruction-level tracing and emulation for white box fuzzing of arbitrary file-reading Windows applications.

Test-case reduction for C compiler bugs

It is concluded that effective program reduction requires more than straightforward delta debugging, so three new, domain-specific test-case reducers are designed and implemented based on a novel framework in which a generic fixpoint computation invokes modular transformations that perform reduction operations.

ddSMT 2.0: Better Delta Debugging for the SMT-LIBv2 Language and Friends

This work presents, the successor of the delta debugger, which improves and extends core concepts of and extends input language support to the entire family of SMT-LIBv2 language dialects and implements an alternative, orthogonal strategy based on hierarchical input minimization.

KLEE: Unassisted and Automatic Generation of High-Coverage Tests for Complex Systems Programs

A new symbolic execution tool, KLEE, capable of automatically generating tests that achieve high coverage on a diverse set of complex and environmentally-intensive programs, and significantly beat the coverage of the developers' own hand-written test suite is presented.

The EPFL Logic Synthesis Libraries

This work presents a collection of modular open source C++ libraries for the development of logic synthesis applications that can be readily used as core components in complex logic synthesis systems.

Language fuzzing using constraint logic programming

This work proposes the use of constraint logic programming (CLP) for program generation, which subsumes and generalizes the stochastic grammar approach and allows testers to write declarative predicates specifying interesting programs, including syntactic features and semantic behaviors.

The Art, Science, and Engineering of Fuzzing: A Survey

This paper presents a unified, general-purpose model of fuzzing together with a taxonomy of the current fuzzing literature, and methodically explores the design decisions at every stage of the model fuzzer by surveying the related literature and innovations in the art, science, and engineering that make modern-day fuzzers effective.

Program-Adaptive Mutational Fuzzing

The design of an algorithm to maximize the number of bugs found for black-box mutational fuzzing given a program and a seed input is presented, and the result is promising: it finds an average of 38.6% more bugs than three previous fuzzers over 8 applications using the same amount of fuzzing time.

Robust Boolean reasoning for equivalence checking and functional property verification

The authors present a combination of techniques for Boolean reasoning based on BDDs, structural transformations, an SAT procedure, and random simulation natively working on a shared graph representation of the problem to results in a powerful summation of their orthogonal strengths.

Simplifying and Isolating Failure-Inducing Input

The delta debugging algorithm generalizes and simplifies the failing test case to a minimal test case that still produces the failure, and isolates the difference between a passing and a failingTest case.