8,928 research outputs found
Symmetry reduction and heuristic search for error detection in model checking
The state explosion problem is the main limitation of model checking. Symmetries in the system being verified can be exploited in order to avoid this problem by defining an equivalence (symmetry) relation on the states of the system, which induces a semantically equivalent quotient system of smaller size. On the other hand, heuristic search algorithms can be applied to improve the bug finding capabilities of model checking. Such algorithms use
heuristic functions to guide the exploration. Bestfirst
is used for accelerating the search, while A* guarantees optimal error trails if combined with admissible estimates. We analyze some aspects of combining both approaches, concentrating on the problem of finding the optimal path to the equivalence class of a given error state. Experimental
results evaluate our approach
Group Mutual Exclusion in Linear Time and Space
We present two algorithms for the Group Mutual Exclusion (GME) Problem that
satisfy the properties of Mutual Exclusion, Starvation Freedom, Bounded Exit,
Concurrent Entry and First Come First Served. Both our algorithms use only
simple read and write instructions, have O(N) Shared Space complexity and O(N)
Remote Memory Reference (RMR) complexity in the Cache Coherency (CC) model. Our
first algorithm is developed by generalizing the well-known Lamport's Bakery
Algorithm for the classical mutual exclusion problem, while preserving its
simplicity and elegance. However, it uses unbounded shared registers. Our
second algorithm uses only bounded registers and is developed by generalizing
Taubenfeld's Black and White Bakery Algorithm to solve the classical mutual
exclusion problem using only bounded shared registers. We show that contrary to
common perception our algorithms are the first to achieve these properties with
these combination of complexities.Comment: A total of 21 pages including 5 figures and 3 appendices. The bounded
shared registers algorithm in the old version has a subtle error (that has no
easy fix) necessitating replacement. A correct, but fundamentally different,
bounded shared registers algorithm, which has the same properties claimed in
the old version is presented in this new version. Also, this version has an
additional autho
Stochastic Matrix Product States
The concept of stochastic matrix product states is introduced and a natural
form for the states is derived. This allows to define the analogue of Schmidt
coefficients for steady states of non-equilibrium stochastic processes. We
discuss a new measure for correlations which is analogous to the entanglement
entropy, the entropy cost , and show that this measure quantifies the bond
dimension needed to represent a steady state as a matrix product state. We
illustrate these concepts on the hand of the asymmetric exclusion process
Recommended from our members
Simple and Fast Biased Locks
Locks are used to ensure exclusive access to shared memory locations. Unfortunately, lock operations are expensive, so much work has been done on optimizing their performance for common access patterns. One such pattern is found in networking applications, where there is a single thread dominating lock accesses. An important special case arises when a single-threaded program calls a thread-safe library that uses locks. An effective way to optimize the dominant-thread pattern is to "bias" the lock implementation so that accesses by the dominant thread have negligible overhead. We take this approach in this work: we simplify and generalize existing techniques for biased locks, producing a large design space with many trade-offs. For example, if we assume the dominant process acquires the lock infinitely often (a reasonable assumption for packet processing), it is possible to make the dominant process perform a lock operation without expensive fence or compare-and-swap instructions. This gives a very low overhead solution; we confirm its efficacy by experiments. We show how these constructions can be extended for lock reservation, re-reservation, and to reader-writer situations
Constant RMR Group Mutual Exclusion for Arbitrarily Many Processes and Sessions
Group mutual exclusion (GME), introduced by Joung in 1998, is a natural synchronization problem that generalizes the classical mutual exclusion and readers and writers problems. In GME a process requests a session before entering its critical section; processes are allowed to be in their critical sections simultaneously provided they have requested the same session.
We present a GME algorithm that (1) is the first to achieve a constant Remote Memory Reference (RMR) complexity for both cache coherent and distributed shared memory machines; and (2) is the first that can be accessed by arbitrarily many dynamically allocated processes and with arbitrarily many session names. Neither of the existing GME algorithms satisfies either of these two important properties. In addition, our algorithm has constant space complexity per process and satisfies the two strong fairness properties, first-come-first-served and first-in-first-enabled. Our algorithm uses an atomic instruction set supported by most modern processor architectures, namely: read, write, fetch-and-store and compare-and-swap
An Object-Oriented Framework for Explicit-State Model Checking
This paper presents a conceptual architecture for an object-oriented framework to support the development of formal veriļ¬cation tools (i.e. model checkers). The objective of the architecture is to support the reuse of algorithms and to encourage a modular design of tools. The conceptual framework is accompanied by a C++ implementation which provides reusable algorithms for the simulation and veriļ¬cation of explicit-state models as well as a model representation for simple models based on guard-based process descriptions. The framework has been successfully used to develop a model checker for a subset of PROMELA
- ā¦