Zero-safe net models for transactions in Linda1 1Research supported by the TMR Network GETGRATS and by the MURST Project TOSCA

Roberto Bruni, Ugo Montanari
2001 Electronical Notes in Theoretical Computer Science  
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
more » ... 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. ÖÙÒ Ò ÅÓÒØ Ò Ö ¯z ero-safe nets (ZS nets) introduces "transition synchronization" (as opposed to token synchronization discussed in point (ii) above), hence regarding suitable finite, but possibly complex and concurrent, computations as atomic events; nets with inhibitor arcs (i-nets) allow for testing the "absence of tokens," an operation that makes the framework Turing complete (as opposed to the models discussed so above, where reachability and deadlock are decidable). Moreover: colored or high-level nets allows for using "structured data" as tokens; in reconfigurable nets, transition postsets may depend on the values got from the presets (whereas in all the above models connections are static), addressing network reconfigurability; in dynamic nets, not only a firing can modify the current marking, but can also increase the set of transitions (i.e., the control). The different flavors of nets are too many to be mentioned here (e.g., with time, probability, priorities). An interesting correspondence between some of the above models and typed subclasses of Join agents [15] has been hinted at in [1] and formally drawn in [8] . Note that certain features are to some extent orthogonal and can be mixed together with a minimum effort. For example, read and inhibitor arcs can be easily combined together to model a general concept of positive/negative context in ri-nets, 3 while in [6] we introduced read arcs inside the zero-safe framework. Points (i-ii) are also at the basis of the coordination language Linda [16], which represents the distributed environment as a tuple space (a multiset-based store where structured data are allowed), with agents built on primitives for adding tuples to and retrieving tuples from the store, reading without consuming, and testing for presence of a particular tuple. These operations make Linda suitable for expressing non-atomic process coordination in a concurrent setting. When tuples are seen as non-structured data, the concurrent semantics of Linda can be suitably modeled via ri-nets [10, 9] . In particular, it is interesting the distinction between the ordered and unordered semantics of Linda-like process algebras drawn in [12, 11, 9] : in the former semantics, the output of a tuple is seen as the atomic execution of the emission of the message followed by its rendering in the tuple space (making it available to other agents), whereas in the latter view these two phases are made autonomous (emitted messages can be rendered asynchronously). This distinction reflects on the expressivity of the language: the ordered semantics originates a Turing complete language, whilst, in the unordered case, deadlock is decidable [12] . Building on these representation results, our aim is twofold: on the one hand we want to extend the zero-safe approach to handle inhibitor arcs, and on the other hand, the nets obtained in this way can find straightforward application to the concurrent modeling of Linda-like languages equipped with a primitive mechanism for transactions (along either the ordered or unordered semantics). In fact, though ad-hoc transaction mechanisms are integrated in languages such as BizTalk Orchestration and JavaSpaces, we look for a uniform treatment of transactions for the many calculi proposed in the literature.
doi:10.1016/s1571-0661(04)00239-7 fatcat:i3ojahq5wbbtlffkksesoi2tji