Programming Distributed Collective Processes in the eXchange Calculus

TL;DR

This work advances a decentralized programming approach for collective systems by introducing distributed collective processes (dcp) as a unifying abstraction. It formalizes dcp in the eXchange Calculus (XC), complemented by an FCPP implementation, and validates the idea through two case studies: multi-hop message propagation and distributed monitoring via replication. The contributions include generalizing aggregate processes to allow sender-controlled propagation, providing a formal XC semantics, and demonstrating practical benefits in resource usage and reaction speed. The framework supports privacy-preserving computation, dynamic ensemble formation, and space-based coordination, offering a flexible tool for designing scalable, distributed, self-organising systems with potential impact across IoT, sensor networks, and swarm-like applications.

Abstract

Recent trends like the Internet of Things (IoT) suggest a vision of dense and multi-scale deployments of computing devices in nearly all kinds of environments. A prominent engineering challenge revolves around programming the collective adaptive behaviour of such computational ecosystems. This requires abstractions able to capture concepts like ensembles (dynamic groups of cooperating devices) and collective tasks (joint activities carried out by ensembles). In this work, we consider collections of devices interacting with neighbours and that execute in nearly-synchronised sense-compute-interact rounds, where the computation is given by a single program mapping sensing values and incoming messages to output and outcoming messages. To support programming whole computational collectives, we propose the abstraction of a distributed collective process, which can be used to define at once the ensemble formation logic and its collective task. We formalise the abstraction in the eXchange Calculus (XC), a core functional language based on neighbouring values (maps from neighbours to values) where state and interaction is handled through a single primitive, exchange, and provide a corresponding implementation in the FCPP language. Then, we exercise distributed collective processes using two case studies: multi-hop message propagation and distributed monitoring of spatial properties. Finally, we discuss the features of the abstraction and its suitability for different kinds of distributed computing applications.

Figures (17)

• Figure 1: Example of an event structure modelling a distributed system execution. Nodes labelled by $\epsilon_k^\delta$ denote the $k$-th round of device $\delta$. The yellow background highlights a reference event, from which its past (green) and future (blue) are identified through the causal relationship implied by the arrows denoting neighbour events.
• Figure 2: Example of a gradient computation (cf. \ref{['ex:gradient']}) on the same event structure of \ref{['fig:event-structure-example']}. Assume that device 4 becomes source at its 2nd round, i.e., at event $\epsilon_2^4$, and that neighbouring events are at a unit distance, i.e., $D_\epsilon(d(\epsilon)')=1$ for all $\epsilon \rightsquigarrow \epsilon'$. Then, the output of the gradient computation at some event is shown with a red label above that event. In each event, the gradient value is computed by taking the gradient values at past neighbour events (excluding past events of the same device), adding the corresponding distance (which we assume any device is able to estimate locally), and selecting the minimum of them. For instance, $\epsilon_5^2$ gathers $[\epsilon_3^3 \mapsto 1, \epsilon_3^1 \mapsto 4]$, adds neighbouring distances to get $[\epsilon_3^3 \mapsto 2, \epsilon_3^1 \mapsto 5]$, and selects the minimum value, i.e., $2$. If there are no neighbouring events (as in $\epsilon_1^4$ or $\epsilon_4^2$), then $\infty$ is produced as the result of minimisation.
• Figure 3: Syntax (top), free variables (middle) and syntactic sugar (bottom) for XC expressions.
• Figure 4: Typing of XC expressions.
• Figure 5: Device big-step operational semantics of XC.

Theorems & Definitions (8)

• Example 3.1: Gradient
• Example 3.2: Gradient Semantics
• Definition 3.3: Augmented Event Structure
• Definition 3.4: Space-Time Value
• Definition 3.5: Program Evaluation on Event structures
• Example 4.1: Multi-gradient
• Example 4.2: Multi-gradient Implementation
• Remark 5.1: SLCS variants