Dependencies and Simultaneity in Membrane Systems

Membrane system computations proceed in a synchronous fashion: at each step all the applicable rules are actually applied. Hence each step depends on the previous one. This coarse view can be refined by looking at the dependencies among rule occurrences, by recording, for an object, which was the a rule that produced it and subsequently (in a later step), which was the a rule that consumed it. In this paper we propose a way to look also at the other main ingredient in membrane system computations, namely the simultaneity in the rule applications. This is achieved using zero-safe nets that allows to synchronize transitions, i.e., rule occurrences. Zero-safe nets can be unfolded into occurrence nets in a classical way, and to this unfolding an event structure can be associated. The capability of capturing simultaneity of zero-safe nets is transferred on the level of event structure by adding a way to express which events occur simultaneously

Zero-safe net models for transactions in Linda

Abstract Zero-safe nets are a variation of Petri nets, where transactions can be suitably modeled. The idea is to distinguish between stable places (whose markings define observable states) and zero-safe places (where tokens can only be temporarily allocated, defining hidden states): Transactions must start and end in observable states. We propose an extension of the coordination language Linda, called TraLinda, where a few basic primitives for expressing transactions are introduced by means of different typing of tuples. By exploiting previous results of Busi, Gorrieri and Zavattaro on the net modeling of Linda-like languages, we define a concurrent operational semantics based on zero-safe nets for TraLinda, where the typing of tuples reflects evidently on the distinction between stable and zero-safe places

An Event Based Semantics of P Systems

Membrane systems have many similarities with classical concurrency models. In particular notions like parallelism, causality and concurrency seem to belong to membrane computing, though they are not yet regarded as central or cornerstone notions. Recently the interest in comparing membrane systems and other models for concurrency has grown. In this paper we propose a translation of membrane system into zero safe nets and then we show how to associate an event automaton to the 1-unfolding of these nets. Thus we propose an event based view of computations of a membrane system

Transactions and Zero-Safe Nets

When employing Petri nets to model distributed systems, one must be aware that the basic activities of each component can vary in duration and can involve smaller internal activities, i.e., that transitions are conceptually refined into transactions. We present an approach to the modeling of transactions based on zero-safe nets. They extend ordinary pt nets with a simple mechanism for transition synchronization. We show that the net theory developed under the two most diffused semantic interpretations (collective token and individual token philosophies) can be uniformly adapted to zero-safe nets. In particular, we show that each zero-safe net has associated two pt nets which represent the abstract counterparts of the modeled system according to the two philosophies. We show several applications of the framework, a distributed interpreter for zs nets based on classical net unfolding (here extended with a commit rule) and discuss some extensions to other net flavours

A zero-safe’s agenda

Join calculus, transactions and zero-safe nets Many different proposals (e.g., Petri nets, Linda and other tuple-space languages, CHAM, Join calculus) for applying formal methods to distributed systems rely on two fundamental design postulates: (1) states are multisets; and (2) elementary actions can atomically fetch (or release) several state components, thus synchronizing them at the event level. However, they often miss a third feature which is instead very useful for programming reliable services, namely the definition of transactions, grouping events into work units that either completely succeed or have no effect. Note that we are interested in transactions denoting atomic computations in a concurrent and causal scenario (as opposed to a sequential one). Though ad-hoc transaction mechanisms are integrated in languages such as BizTalk Orchestration and JavaSpaces, we think the issue deserves a uniform treatment along the many calculi proposed in the literature. Building on points (1) and (2) above, it is in fact possible to define a taxonomy of models with increasing expressiveness. 1 Starting from PT Petri nets, where tokens are seen as non structure