Adding distribution and fault tolerance to Jason

• Published in: Science of computer programming Vol. 98; pp. 205 - 232
• Main Authors: Fernández-Díaz, Á., Benac-Earle, C., Fredlund, L.
• Format: Journal Article
• Language: English
• Published: Elsevier B.V 01.02.2015
• Subjects: eJason; Erlang programming language; Fault tolerance; Jason programming language; Multi-agent systems; Fault tolerance; Jason programming language; eJason; Erlang programming language; Multi-agent systems
• ISSN: 0167-6423; 1872-7964
• DOI: 10.1016/j.scico.2014.01.007

In this article we describe an extension of the multi-agent system programming language Jason with constructs for distribution and fault tolerance. This extension is completely integrated into Jason in the sense that distributing a Jason multi-agent system does not require the use of another programming language. This contrasts with the standard Java based Jason implementation, which often requires writing Java code in order to distribute Jason-based agent systems. These extensions to Jason are being implemented in eJason, an Erlang-based implementation of Jason. We introduce two different fault tolerance mechanisms that allow fault detection and recovery. A low-level agent monitoring mechanism allows a monitoring agent to detect, and possibly recover, when another agent experiences difficulties such as e.g. hardware failures or due to network partitioning. More novel is the second fault tolerance mechanism, supervision, whereby one agent acts as a supervisor to a second agent. The supervision mechanism is in addition to handling low-level faults such as the above, also capable of detecting higher-level failures such as e.g. “event overload” (an agent is incapable of timely handling all its associated events and plans) and “divergence” (an agent is not completing any iteration of its reasoning cycle). Moreover, mechanisms exist for another agent to inform a supervisor that one of its supervised agents is misbehaving. Although these extensions are inspired by the distribution and fault tolerance mechanisms of Erlang, due to the agent perspective, the details are quite different. For instance, the supervisor mechanism of eJason is much more capable than the supervisor behaviour of Erlang, corresponding to the more abstract/higher-level perspective offered by agent-oriented programming (Jason) compared with process-oriented programming (Erlang). As another example, from the perspective of agent programming we consider it natural to support the flexibility of the supervision trees, i.e. allow the evolution of supervision relations over time. For instance, the supervisor of an agent, as well as the supervision policy maintained for that same agent, may vary as the system evolves. •We present a distribution schema for the Jason programming language.•The monitoring technique introduced can be used to avoid fault propagation.•The supervision mechanism presented enables fault recovery in multi-agent systems.•The runtime system supports the extensions and can be used in a declarative way.•Various use cases expose the potential of the extensions.