Conference Paper

Modeling Systems in CLP.

Conference: Logic Programming, 21st International Conference, ICLP 2005, Sitges, Spain, October 2-5, 2005, Proceedings
Source: DBLP

ABSTRACT We present a methodology for the modeling of complex program behavior in CLP. In the first part we present an informal description about how to represent a system in CLP. At its basic level, this representation captures the trace semantics of concurrent programs, or even high-level specifications, in the form of a predi- cate transformer. Based on traces, the method can also capture properties of the underlying runtime system such as the scheduler and the microarchitecture, so as to provide a foundation for reasoning about resources such as time and space. The second part presents a formal and compositional proof method for rea- soning about safety properties of the underlying system. The idea is that a safety property is simply a CLP goal, and is proof established by executing the goal by a CLP interpreter. However, a traditional CLP interpreter does not suffice. We thus introduce a technique of coinductive tabling to CLP. Essentially, this extends CLP so that it can inductively use proof obligations that are assumed but not yet proven, and it can generate new proof obligations assertions dynamically. 1 Outline We present a general CLP approach for program verification: We model a wide range of programs and systems in CLP We present a proof method to reason about any CLP program Poster structure: Modeling (Sec. 2) - Symbolic representation of transition relations in CLP - Modeling examples (Sec. 3) Sequential program Concurrent program: synchronous and asynchronous composition Scheduling

0 Followers
 · 
111 Views
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Program slicing is a technique to extract relevant parts of a pro- gram, and it is widely used in program debugging, parallelization, testing, reverse engineering, etc. This paper concerns static slic- ing and it follows the Weiser's definition of slicing that consis ts of computing what statements of the program might affect the value of some particular variable at a specified program point. We a rgue that although there is a broad variety of static slicing meth ods, it is commonly assumed that all paths are executable. However, this limitation may be completely unacceptable in, for instance, debug- ging and program understanding tasks since the slice is often quite big. In this paper, we present a fully path-sensitive slicing that iden- tifies infeasible paths in order to obtain accurate slices. I nfeasible paths are detected by performing symbolic execution of the pro- gram. The major challenge is that in general there are exponentially many paths. Our method traverses the symbolic execution tree, in a post-order manner, and discovers an interpolant which general- izes the execution context of the tree. This enhances the likelihood that the dependencies computed for that tree can be reused in mul- tiple contexts. Another key feature is that our algorithm st ores, for each dependency, the executable path that defines it, that is , the representative path formulathat gives rise to it. By doing so, the dependency information is accurate since it is only used if t he new context demonstrates that the representative is executabl e. In fact, for loop-free programs, our algorithm computes exactly the state- ments relevant to the slicing criterion.
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: We consider the problem of exploring the search tree of a CLP goal in pursuit of a target property. Essential to such a process is a method of tabling to prevent duplicate exploration. Typically, only actually traversed goals are memoed in the table. In this paper we present a method where, upon the successful traversal of a subgoal, a generalization of the subgoal is memoed. This enlarges the record of already traversed goals, thus providing more pruning in the subsequent search process. The key feature is that the abstraction computed is guaranteed not to give rise to a spurious path that might violate the target property. A driving application area is the use of CLP to model the behavior of other programs. We demonstrate the performance of our method on a benchmark of program verfication problems.
    Principles and Practice of Constraint Programming - CP 2009, 15th International Conference, CP 2009, Lisbon, Portugal, September 20-24, 2009, Proceedings; 01/2009
  • [Show abstract] [Hide abstract]
    ABSTRACT: In this paper, we show how the classic job-shop scheduling problem can be modeled and solved using Timed planning processes, including both deterministic and preemptive job-shop scheduling problems. In our approach, the job shop scheduling problems can be naturally modeled as Timed Planning processes, whose complete executions correspond to feasible schedulers. The optimal scheduler, which is an execution with the minimum execution time, can be found using CLP based reasoning mechanism. Besides our approach is capable to handle the extended job-shop scheduling problems, where there are more complicated compositional operational behaviors among all jobs, which allows communications between jobs. Moreover, each job can have deadlines and relative timing constraints. We present several algorithms and heuristics for finding the optimal scheduler and test their implementation on numerous benchmark examples.

Preview

Download
0 Downloads
Available from