14,376 research outputs found
Detection of global state predicates
The problem addressed here arises in the context of Meta: how can a set of processes monitor the state of a distributed application in a consistent manner? For example, consider the simple distributed application as shown here. Each of the three processes in the application has a light, and the control processes would each like to take an action when some specified subset of the lights are on. The application processes are instrumented with stubs that determine when the process turns its lights on or off. This information is disseminated to the control processes, each of which then determines when its condition of interest is met. Meta is built on top of the ISIS toolkit, and so we first built the sensor dissemination mechanism using atomic broadcast. Atomic broadcast guarantees that all recipients receive the messages in the same order and that this order is consistent with causality. Unfortunately, the control processes are somewhat limited in what they can deduce when they find that their condition of interest holds
Monitoring Partially Synchronous Distributed Systems using SMT Solvers
In this paper, we discuss the feasibility of monitoring partially synchronous
distributed systems to detect latent bugs, i.e., errors caused by concurrency
and race conditions among concurrent processes. We present a monitoring
framework where we model both system constraints and latent bugs as
Satisfiability Modulo Theories (SMT) formulas, and we detect the presence of
latent bugs using an SMT solver. We demonstrate the feasibility of our
framework using both synthetic applications where latent bugs occur at any time
with random probability and an application involving exclusive access to a
shared resource with a subtle timing bug. We illustrate how the time required
for verification is affected by parameters such as communication frequency,
latency, and clock skew. Our results show that our framework can be used for
real-life applications, and because our framework uses SMT solvers, the range
of appropriate applications will increase as these solvers become more
efficient over time.Comment: Technical Report corresponding to the paper accepted at Runtime
Verification (RV) 201
Permission-Based Separation Logic for Multithreaded Java Programs
This paper presents a program logic for reasoning about multithreaded
Java-like programs with dynamic thread creation, thread joining and reentrant
object monitors. The logic is based on concurrent separation logic. It is the
first detailed adaptation of concurrent separation logic to a multithreaded
Java-like language. The program logic associates a unique static access
permission with each heap location, ensuring exclusive write accesses and
ruling out data races. Concurrent reads are supported through fractional
permissions. Permissions can be transferred between threads upon thread
starting, thread joining, initial monitor entrancies and final monitor exits.
In order to distinguish between initial monitor entrancies and monitor
reentrancies, auxiliary variables keep track of multisets of currently held
monitors. Data abstraction and behavioral subtyping are facilitated through
abstract predicates, which are also used to represent monitor invariants,
preconditions for thread starting and postconditions for thread joining.
Value-parametrized types allow to conveniently capture common strong global
invariants, like static object ownership relations. The program logic is
presented for a model language with Java-like classes and interfaces, the
soundness of the program logic is proven, and a number of illustrative examples
are presented
Global Versus Local Computations: Fast Computing with Identifiers
This paper studies what can be computed by using probabilistic local
interactions with agents with a very restricted power in polylogarithmic
parallel time. It is known that if agents are only finite state (corresponding
to the Population Protocol model by Angluin et al.), then only semilinear
predicates over the global input can be computed. In fact, if the population
starts with a unique leader, these predicates can even be computed in a
polylogarithmic parallel time. If identifiers are added (corresponding to the
Community Protocol model by Guerraoui and Ruppert), then more global predicates
over the input multiset can be computed. Local predicates over the input sorted
according to the identifiers can also be computed, as long as the identifiers
are ordered. The time of some of those predicates might require exponential
parallel time. In this paper, we consider what can be computed with Community
Protocol in a polylogarithmic number of parallel interactions. We introduce the
class CPPL corresponding to protocols that use , for some k,
expected interactions to compute their predicates, or equivalently a
polylogarithmic number of parallel expected interactions. We provide some
computable protocols, some boundaries of the class, using the fact that the
population can compute its size. We also prove two impossibility results
providing some arguments showing that local computations are no longer easy:
the population does not have the time to compare a linear number of consecutive
identifiers. The Linearly Local languages, such that the rational language
, are not computable.Comment: Long version of SSS 2016 publication, appendixed version of SIROCCO
201
Permission-Based Separation Logic for Multithreaded Java Programs
This paper motivates and presents a program logic for reasoning about multithreaded Java-like programs with concurrency primitives such as dynamic thread creation, thread joining and reentrant object monitors. The logic is based on concurrent separation logic. It is the first detailed adaptation of concurrent separation logic to a multithreaded Java-like language. The program logic associates a unique static access permission with each heap location, ensuring exclusive write accesses and ruling out data races. Concurrent reads are supported through fractional permissions. Permissions can be transferred between threads upon thread starting, thread joining, initial monitor entrancies and final monitor exits.\ud
This paper presents the basic principles to reason about thread creation and thread joining. It finishes with an outlook how this logic will evolve into a full-fledged verification technique for Java (and possibly other multithreaded languages)
Merlin: A Language for Provisioning Network Resources
This paper presents Merlin, a new framework for managing resources in
software-defined networks. With Merlin, administrators express high-level
policies using programs in a declarative language. The language includes
logical predicates to identify sets of packets, regular expressions to encode
forwarding paths, and arithmetic formulas to specify bandwidth constraints. The
Merlin compiler uses a combination of advanced techniques to translate these
policies into code that can be executed on network elements including a
constraint solver that allocates bandwidth using parameterizable heuristics. To
facilitate dynamic adaptation, Merlin provides mechanisms for delegating
control of sub-policies and for verifying that modifications made to
sub-policies do not violate global constraints. Experiments demonstrate the
expressiveness and scalability of Merlin on real-world topologies and
applications. Overall, Merlin simplifies network administration by providing
high-level abstractions for specifying network policies and scalable
infrastructure for enforcing them
Expressiveness of Generic Process Shape Types
Shape types are a general concept of process types which work for many
process calculi. We extend the previously published Poly* system of shape types
to support name restriction. We evaluate the expressiveness of the extended
system by showing that shape types are more expressive than an implicitly typed
pi-calculus and an explicitly typed Mobile Ambients. We demonstrate that the
extended system makes it easier to enjoy advantages of shape types which
include polymorphism, principal typings, and a type inference implementation.Comment: Submitted to Trustworthy Global Computing (TGC) 2010
Visual Relationship Detection with Relative Location Mining
Visual relationship detection, as a challenging task used to find and
distinguish the interactions between object pairs in one image, has received
much attention recently. In this work, we propose a novel visual relationship
detection framework by deeply mining and utilizing relative location of
object-pair in every stage of the procedure. In both the stages, relative
location information of each object-pair is abstracted and encoded as auxiliary
feature to improve the distinguishing capability of object-pairs proposing and
predicate recognition, respectively; Moreover, one Gated Graph Neural
Network(GGNN) is introduced to mine and measure the relevance of predicates
using relative location. With the location-based GGNN, those non-exclusive
predicates with similar spatial position can be clustered firstly and then be
smoothed with close classification scores, thus the accuracy of top recall
can be increased further. Experiments on two widely used datasets VRD and VG
show that, with the deeply mining and exploiting of relative location
information, our proposed model significantly outperforms the current
state-of-the-art.Comment: Accepted to ACM MM 201
- …