25,416 research outputs found
Benchmarking Optimization Solvers and Symmetry Breakers for the Automated Deployment of Component-based Applications in the Cloud (EXTENDED ABSTRACT)
Optimization solvers based on methods from constraint programming (OR-Tools,
Chuffed, Gecode), optimization modulo theory (Z3), and mathematical programming
(CPLEX) are successfully applied nowadays to solve many non-trivial examples.
However, for solving the problem of automated deployment in the Cloud of
component-based applications, their computational requirements are huge making
automatic optimization practically impossible with the current general
optimization techniques. To overcome the difficulty, we exploited the sweet
spots of the underlying problem in order to identify search space reduction
methods. We came up with 15 symmetry breaking strategies which we tested in a
static symmetry breaking setting on the solvers enumerated above and on 4
classes of problems. As a result, all symmetry breaking strategies led to
significant improvement of the computational time of all solvers, most notably,
Z3 performed the best compared to the others. As an observation, the symmetry
breaking strategies confirmed that, when applied in a static setting, they may
interact badly with the underlying techniques implemented by the solvers.Comment: Presented at 7th International Workshop on Satisfiability Checking
and Symbolic Computation (SC-square), Part of IJCAR 22, at FLOC 2022, August
12, 2022, Haifa, Israel. arXiv admin note: substantial text overlap with
arXiv:2006.0540
Mapping Fusion and Synchronized Hyperedge Replacement into Logic Programming
In this paper we compare three different formalisms that can be used in the
area of models for distributed, concurrent and mobile systems. In particular we
analyze the relationships between a process calculus, the Fusion Calculus,
graph transformations in the Synchronized Hyperedge Replacement with Hoare
synchronization (HSHR) approach and logic programming. We present a translation
from Fusion Calculus into HSHR (whereas Fusion Calculus uses Milner
synchronization) and prove a correspondence between the reduction semantics of
Fusion Calculus and HSHR transitions. We also present a mapping from HSHR into
a transactional version of logic programming and prove that there is a full
correspondence between the two formalisms. The resulting mapping from Fusion
Calculus to logic programming is interesting since it shows the tight analogies
between the two formalisms, in particular for handling name generation and
mobility. The intermediate step in terms of HSHR is convenient since graph
transformations allow for multiple, remote synchronizations, as required by
Fusion Calculus semantics.Comment: 44 pages, 8 figures, to appear in a special issue of Theory and
Practice of Logic Programming, minor revisio
Enhancing Predicate Pairing with Abstraction for Relational Verification
Relational verification is a technique that aims at proving properties that
relate two different program fragments, or two different program runs. It has
been shown that constrained Horn clauses (CHCs) can effectively be used for
relational verification by applying a CHC transformation, called predicate
pairing, which allows the CHC solver to infer relations among arguments of
different predicates. In this paper we study how the effects of the predicate
pairing transformation can be enhanced by using various abstract domains based
on linear arithmetic (i.e., the domain of convex polyhedra and some of its
subdomains) during the transformation. After presenting an algorithm for
predicate pairing with abstraction, we report on the experiments we have
performed on over a hundred relational verification problems by using various
abstract domains. The experiments have been performed by using the VeriMAP
transformation and verification system, together with the Parma Polyhedra
Library (PPL) and the Z3 solver for CHCs.Comment: Pre-proceedings paper presented at the 27th International Symposium
on Logic-Based Program Synthesis and Transformation (LOPSTR 2017), Namur,
Belgium, 10-12 October 2017 (arXiv:1708.07854
Automated Verification of Practical Garbage Collectors
Garbage collectors are notoriously hard to verify, due to their low-level
interaction with the underlying system and the general difficulty in reasoning
about reachability in graphs. Several papers have presented verified
collectors, but either the proofs were hand-written or the collectors were too
simplistic to use on practical applications. In this work, we present two
mechanically verified garbage collectors, both practical enough to use for
real-world C# benchmarks. The collectors and their associated allocators
consist of x86 assembly language instructions and macro instructions, annotated
with preconditions, postconditions, invariants, and assertions. We used the
Boogie verification generator and the Z3 automated theorem prover to verify
this assembly language code mechanically. We provide measurements comparing the
performance of the verified collector with that of the standard Bartok
collectors on off-the-shelf C# benchmarks, demonstrating their competitiveness
- …