On Synchronous and Asynchronous Interaction in Distributed Systems

When considering distributed systems, it is a central issue how to deal with interactions between components. In this paper, we investigate the paradigms of synchronous and asynchronous interaction in the context of distributed systems. We investigate to what extent or under which conditions synchronous interaction is a valid concept for specification and implementation of such systems. We choose Petri nets as our system model and consider different notions of distribution by associating locations to elements of nets. First, we investigate the concept of simultaneity which is inherent in the semantics of Petri nets when transitions have multiple input places. We assume that tokens may only be taken instantaneously by transitions on the same location. We exhibit a hierarchy of `asynchronous’ Petri net classes by different assumptions on possible distributions. Alternatively, we assume that the synchronisations specified in a Petri net are crucial system properties. Hence transitions and their preplaces may no longer placed on separate locations. We then answer the question which systems may be implemented in a distributed way without restricting concurrency, assuming that locations are inherently sequential. It turns out that in both settings we find semi-structural properties of Petri nets describing exactly the problematic situations for interactions in distributed systems.

💡 Research Summary

The paper investigates the fundamental question of how synchronous and asynchronous interaction can be realised in distributed systems, using 1‑safe Petri nets as a precise behavioural model. The authors first introduce a location function that assigns each place and transition to a physical location. Under the assumption that a transition can instantaneously consume tokens only from co‑located places, any remote token removal incurs a delay. This simple premise allows the authors to formalise two complementary research strands.

1. Asynchronising a Synchronous Specification
The authors model the replacement of a synchronous firing (where a transition simultaneously removes tokens from all its pre‑places) by inserting silent τ‑transitions that request and later receive tokens from remote places. To judge whether the transformed net faithfully reproduces the original behaviour, they adopt step‑readiness equivalence: two nets are equivalent if they have the same set of step‑ready pairs, i.e., the same reachable markings together with the same sets of multisets of actions that can be performed next. This equivalence preserves causality, concurrency, and limited divergence, making it suitable for the analysis.

Depending on how the location function is constrained, three increasingly permissive classes of asynchronous nets emerge:

• Fully Asynchronous (FA) – every transition may have its pre‑places on distinct locations; all synchronisations are replaced by asynchronous communication.
• Symmetrically Asynchronous (SA) – a transition and all its pre‑places must share the same location, but different transitions may be placed arbitrarily; synchronisation is allowed only within a single location.
• Asymmetrically Asynchronous (AA) – a hybrid where some pre‑places may be co‑located with the transition while others are remote, allowing a partial asynchronous treatment.

For each class the paper provides a semi‑structural characterisation: a net fails to be FA precisely when it contains an M‑structure (two transitions sharing a place but placed on different locations); it fails to be SA when it contains a conflict‑cycle where two transitions compete for a token that must be synchronously consumed across locations; and it fails to be AA when a more subtle pattern of mixed co‑location and remote pre‑places occurs. These characterisations give a purely graph‑theoretic test for membership in each class.

2. Enforcing Synchronous Behaviour as a System Property
In the second line of inquiry the authors assume that the synchronisations expressed by the net are essential and must be preserved in any implementation. Consequently, a transition and all its pre‑places are forced to be co‑located, while each location itself is sequential (no internal concurrency). A net that can be implemented under these constraints while preserving step‑readiness equivalence is called distributable. The authors again derive a semi‑structural condition: a net is non‑distributable if it contains a cross‑conflict pattern where two transitions require tokens from places that cannot be placed on the same location without violating sequentiality. They prove a strong impossibility theorem (Theorem 3) showing that any net exhibiting this pattern cannot be distributed, even when arbitrary τ‑nets are allowed as implementations.

Conversely, the paper presents a constructive lower bound: for a large subclass of nets (essentially those without the problematic patterns) the authors give an explicit distributed implementation using buffers and local synchronisers, thereby demonstrating that the identified conditions are not only necessary but also sufficient for distributability.

Technical Contributions and Impact

• Introduction of a location‑based model for asynchronous implementation of Petri nets.
• Use of step‑readiness equivalence, which is stronger than plain trace or failures equivalence, to compare original and transformed nets.
• A clear hierarchy of asynchronous net classes together with exact semi‑structural characterisations.
• A dual perspective that treats synchronisation as either optional (to be removed) or mandatory (to be preserved), yielding complementary notions of “asynchronous” and “distributable” nets.
• Concrete construction techniques that serve as lower bounds for distributability, bridging the gap between impossibility results and practical implementations.

In summary, the paper provides a rigorous, structure‑based taxonomy of when synchronous interactions can be safely replaced by asynchronous communication in distributed settings, and when they must be retained. By grounding the analysis in Petri nets and step‑readiness semantics, the results are both mathematically robust and directly applicable to the design of distributed protocols, concurrent hardware, and coordination languages.