1,306 research outputs found
Towards Efficient Abstractions for Concurrent Consensus
Consensus is an often occurring problem in concurrent and distributed
programming. We present a programming language with simple semantics and
build-in support for consensus in the form of communicating transactions. We
motivate the need for such a construct with a characteristic example of
generalized consensus which can be naturally encoded in our language. We then
focus on the challenges in achieving an implementation that can efficiently run
such programs. We setup an architecture to evaluate different implementation
alternatives and use it to experimentally evaluate runtime heuristics. This is
the basis for a research project on realistic programming language support for
consensus.Comment: 15 pages, 5 figures, symposium: TFP 201
Distributed execution of bigraphical reactive systems
The bigraph embedding problem is crucial for many results and tools about
bigraphs and bigraphical reactive systems (BRS). Current algorithms for
computing bigraphical embeddings are centralized, i.e. designed to run locally
with a complete view of the guest and host bigraphs. In order to deal with
large bigraphs, and to parallelize reactions, we present a decentralized
algorithm, which distributes both state and computation over several concurrent
processes. This allows for distributed, parallel simulations where
non-interfering reactions can be carried out concurrently; nevertheless, even
in the worst case the complexity of this distributed algorithm is no worse than
that of a centralized algorithm
KLAIM: A Kernel Language for Agents Interaction and Mobility
We investigate the issue of designing a kernel programming language for mobile computing and describe KLAIM, a language that supports a programming paradigm where processes, like data, can be moved from one computing environment to another. The language consists of a core Linda with multiple tuple spaces and of a set of operators for building processes. KLAIM naturally supports programming with explicit localities. Localities are first-class data (they can be manipulated like any other data), but the language provides coordination mechanisms to control the interaction protocols among located processes. The formal operational semantics is useful for discussing the design of the language and provides guidelines for implementations. KLAIM is equipped with a type system that statically checks access rights violations of mobile agents. Types are used to describe the intentions (read, write, execute, etc.) of processes in relation to the various localities. The type system is used to determine the operations that processes want to perform at each locality, and to check whether they comply with the declared intentions and whether they have the necessary rights to perform the intended operations at the specific localities. Via a series of examples, we show that many mobile code programming paradigms can be naturally implemented in our kernel language. We also present a prototype implementaton of KLAIM in Java
Verifying Programs with Logic and Extended Proof Rules: Deep Embedding v.s. Shallow Embedding
Many foundational program verification tools have been developed to build
machine-checked program correctness proofs, a majority of which are based on
Hoare logic. Their program logics, their assertion languages, and their
underlying programming languages can be formalized by either a shallow
embedding or a deep embedding. Tools like Iris and early versions of Verified
Software Toolchain (VST) choose different shallow embeddings to formalize their
program logics. But the pros and cons of these different embeddings were not
yet well studied. Therefore, we want to study the impact of the program logic's
embedding on logic's proof rules in this paper. This paper considers a set of
useful extended proof rules, and four different logic embeddings: one deep
embedding and three common shallow embeddings. We prove the validity of these
extended rules under these embeddings and discuss their main challenges.
Furthermore, we propose a method to lift existing shallowly embedded logics to
deeply embedded ones to greatly simplify proofs of extended rules in specific
proof systems. We evaluate our results on two existing verification tools. We
lift the originally shallowly embedded VST to our deeply embedded VST to
support extended rules, and we implement Iris-CF and deeply embedded Iris-Imp
based on the Iris framework to evaluate our theory in real verification
projects
On Spatial Conjunction as Second-Order Logic
Spatial conjunction is a powerful construct for reasoning about dynamically
allocated data structures, as well as concurrent, distributed and mobile
computation. While researchers have identified many uses of spatial
conjunction, its precise expressive power compared to traditional logical
constructs was not previously known. In this paper we establish the expressive
power of spatial conjunction. We construct an embedding from first-order logic
with spatial conjunction into second-order logic, and more surprisingly, an
embedding from full second order logic into first-order logic with spatial
conjunction. These embeddings show that the satisfiability of formulas in
first-order logic with spatial conjunction is equivalent to the satisfiability
of formulas in second-order logic. These results explain the great expressive
power of spatial conjunction and can be used to show that adding unrestricted
spatial conjunction to a decidable logic leads to an undecidable logic. As one
example, we show that adding unrestricted spatial conjunction to two-variable
logic leads to undecidability. On the side of decidability, the embedding into
second-order logic immediately implies the decidability of first-order logic
with a form of spatial conjunction over trees. The embedding into spatial
conjunction also has useful consequences: because a restricted form of spatial
conjunction in two-variable logic preserves decidability, we obtain that a
correspondingly restricted form of second-order quantification in two-variable
logic is decidable. The resulting language generalizes the first-order theory
of boolean algebra over sets and is useful in reasoning about the contents of
data structures in object-oriented languages.Comment: 16 page
- …