155 research outputs found
Tracing and Explaining Execution of CLP(FD) Programs
Previous work in the area of tracing CLP(FD) programs mainly focuses on
providing information about control of execution and domain modification. In
this paper, we present a trace structure that provides information about
additional important aspects. We incorporate explanations in the trace
structure, i.e. reasons for why certain solver actions occur. Furthermore, we
come up with a format for describing the execution of the filtering algorithms
of global constraints. Some new ideas about the design of the trace are also
presented. For example, we have modeled our trace as a nested block structure
in order to achieve a hierarchical view. Also, new ways about how to represent
and identify different entities such as constraints and domain variables are
presented.Comment: 16 pages; Alexandre Tessier, editor; WLPE 2002,
http://xxx.lanl.gov/abs/cs.SE/020705
Design and Implementation of a Tracer Driver: Easy and Efficient Dynamic Analyses of Constraint Logic Programs
Tracers provide users with useful information about program executions. In
this article, we propose a ``tracer driver''. From a single tracer, it provides
a powerful front-end enabling multiple dynamic analysis tools to be easily
implemented, while limiting the overhead of the trace generation. The relevant
execution events are specified by flexible event patterns and a large variety
of trace data can be given either systematically or ``on demand''. The proposed
tracer driver has been designed in the context of constraint logic programming;
experiments have been made within GNU-Prolog. Execution views provided by
existing tools have been easily emulated with a negligible overhead.
Experimental measures show that the flexibility and power of the described
architecture lead to good performance. The tracer driver overhead is inversely
proportional to the average time between two traced events. Whereas the
principles of the tracer driver are independent of the traced programming
language, it is best suited for high-level languages, such as constraint logic
programming, where each traced execution event encompasses numerous low-level
execution steps. Furthermore, constraint logic programming is especially hard
to debug. The current environments do not provide all the useful dynamic
analysis tools. They can significantly benefit from our tracer driver which
enables dynamic analyses to be integrated at a very low cost.Comment: To appear in Theory and Practice of Logic Programming (TPLP),
Cambridge University Press. 30 pages
Towards declarative diagnosis of constraint programs over finite domains
The paper proposes a theoretical approach of the debugging of constraint
programs based on a notion of explanation tree. The proposed approach is an
attempt to adapt algorithmic debugging to constraint programming. In this
theoretical framework for domain reduction, explanations are proof trees
explaining value removals. These proof trees are defined by inductive
definitions which express the removals of values as consequences of other value
removals. Explanations may be considered as the essence of constraint
programming. They are a declarative view of the computation trace. The
diagnosis consists in locating an error in an explanation rooted by a symptom.Comment: In M. Ronsse, K. De Bosschere (eds), proceedings of the Fifth
International Workshop on Automated Debugging (AADEBUG 2003), September 2003,
Ghent. cs.SE/030902
The ciao system
Abstract is not available
The Design, modeling and simulation of switching fabrics: For an ATM network switch
The requirements of today\u27s telecommunication systems to support high bandwidth and added flexibility brought about the expansion of (Asynchronous Transfer Mode) ATM as a new method of high-speed data transmission. Various analytical and simulation methods may be used to estimate the performance of ATM switches. Analytical methods considerably limit the range of parameters to be evaluated due to extensive formulae used and time consuming iterations. They are not as effective for large networks because of excessive computations that do not scale linearly with network size. One the other hand, simulation-based methods allow determining a bigger range of performance parameters in a shorter amount of time even for large networks. A simulation model, however, is more elaborate in terms of implementation. Instead of using formulae to obtain results, it has to operate software or hardware modules requiring a certain amount of effort to create. In this work simulation is accomplished by utilizing the ATM library - an object oriented software tool, which uses software chips for building ATM switches. The distinguishing feature of this approach is cut-through routing realized on the bit level abstraction treating ATM protocol data units, called cells, as groups of 424 bits. The arrival events of cells to the system are not instantaneous contrary to commonly used methods of simulation that consider cells as instant messages. The simulation was run for basic multistage interconnection network types with varying source arrival rate and buffer sizes producing a set of graphs of cell delays, throughput, cell loss probability, and queue sizes. The techniques of rearranging and sorting were considered in the simulation. The results indicate that better performance is always achieved by bringing additional stages of elements to the switching system
Automated Black Box Generation of Structured Inputs for Use in Software Testing
A common problem in automated software testing is the need to generate many inputs with complex structure in a black-box fashion. For example, a library for manipulating red-black trees may require that inputs are themselves valid red-black trees, meaning anything invalid is not suitable for testing. As another example, in order to test code generation in a compiler, it is necessary to use input programs which are both syntactically valid and well-typed. Despite the importance of this problem, we observe that existing solutions are few in number and have severe drawbacks, including unreasonably slow performance and a lack of generality to testing different systems.This thesis presents a solution to this problem of black-box structured input generation. I observe that test inputs can be described as solutions to systems of logical constraints, and that more expressive constraints can lead to more complex tests. In order to test effectively and generate many tests, we need high-performance constraint solvers capable of finding many solutions to these constraints. I observe that constraint logic programming (CLP) offers an expressive constraint language paired with a high-performance constraint solver, and thus serves as a potential solution to this problem. Via a series of case studies, I have found that CLP (1) is applicable to testing a wide variety of systems; (2) can scale to more complex constraints than ever previously described; and (3) is often orders of magnitude faster than competing solutions. These case studies have also exposed dozens of bugs in high-profile software, including the Rust compiler and the Z3 SMT solver
- …