Resilient distributed collection through information speed thresholds

Part 6: Large-Scale Decentralised SystemsInternational audienceOne of the key coordination problems in physically-deployed distributed systems, such as mobile robots, wireless sensor networks, and IoT systems in general, is to provide notions of “distributed sensing” achieved by the strict, continuous cooperation and interaction among individual devices. An archetypal operation of distributed sensing is data summarisation over a region of space, by which several higher-level problems can be addressed: counting items, measuring space, averaging environmental values, and so on. A typical coordination strategy to perform data summarisation in a peer-to-peer scenario, where devices can communicate only with a neighbourhood, is to progressively accumulate information towards one or more collector devices, though this typically exhibits problems of reactivity and fragility, especially in scenarios featuring high mobility. In this paper, we propose coordination strategies for data summarisation involving both idempotent and arithmetic aggregation operators, with the idea of controlling the minimum information propagation speed, so as to improve the reactivity to input changes. Given suitable assumptions on the network model, and under the restriction of no data loss, these algorithms achieve optimal reactivity. By empirical evaluation via simulation, accounting for various sources of volatility, and comparing to other existing implementations of data summarisation algorithms, we show that our algorithms are able to retain adequate accuracy even in high-variability scenarios where all other algorithms are significantly diverging from correct estimations

Field-based Coordination with the Share Operator

Field-based coordination has been proposed as a model for coordinating collective adaptive systems, promoting a view of distributed computations as functions manipulating data structures spread over space and evolving over time, called computational fields. The field calculus is a formal foundation for field computations, providing specific constructs for evolution (time) and neighbor interaction (space), which are handled by separate operators (called rep and nbr, respectively). This approach, however, intrinsically limits the speed of information propagation that can be achieved by their combined use. In this paper, we propose a new field-based coordination operator called share, which captures the space-time nature of field computations in a single operator that declaratively achieves: (i) observation of neighbors' values; (ii) reduction to a single local value; and (iii) update and converse sharing to neighbors of a local variable. We show that for an important class of self-stabilising computations, share can replace all occurrences of rep and nbr constructs. In addition to conceptual economy, use of the share operator also allows many prior field calculus algorithms to be greatly accelerated, which we validate empirically with simulations of frequently used network propagation and collection algorithms

From distributed coordination to field calculus and aggregate computing

open6siThis work has been partially supported by: EU Horizon 2020 project HyVar (www.hyvar-project .eu), GA No. 644298; ICT COST Action IC1402 ARVI (www.cost -arvi .eu); Ateneo/CSP D16D15000360005 project RunVar (runvar-project.di.unito.it).Aggregate computing is an emerging approach to the engineering of complex coordination for distributed systems, based on viewing system interactions in terms of information propagating through collectives of devices, rather than in terms of individual devices and their interaction with their peers and environment. The foundation of this approach is the distillation of a number of prior approaches, both formal and pragmatic, proposed under the umbrella of field-based coordination, and culminating into the field calculus, a universal functional programming model for the specification and composition of collective behaviours with equivalent local and aggregate semantics. This foundation has been elaborated into a layered approach to engineering coordination of complex distributed systems, building up to pragmatic applications through intermediate layers encompassing reusable libraries of program components. Furthermore, some of these components are formally shown to satisfy formal properties like self-stabilisation, which transfer to whole application services by functional composition. In this survey, we trace the development and antecedents of field calculus, review the field calculus itself and the current state of aggregate computing theory and practice, and discuss a roadmap of current research directions with implications for the development of a broad range of distributed systems.embargoed_20210910Viroli, Mirko; Beal, Jacob; Damiani, Ferruccio; Audrito, Giorgio; Casadei, Roberto; Pianini, DaniloViroli, Mirko; Beal, Jacob; Damiani, Ferruccio; Audrito, Giorgio; Casadei, Roberto; Pianini, Danil

Computation Against a Neighbour

Recent works in contexts like the Internet of Things (IoT) and large-scale Cyber-Physical Systems (CPS) propose the idea of programming distributed systems by focussing on their global behaviour across space and time. In this view, a potentially vast and heterogeneous set of devices is considered as an "aggregate" to be programmed as a whole, while abstracting away the details of individual behaviour and exchange of messages, which are expressed declaratively. One such a paradigm, known as aggregate programming, builds on computational models inspired by field-based coordination. Existing models such as the field calculus capture interaction with neighbours by a so-called "neighbouring field" (a map from neighbours to values). This requires ad-hoc mechanisms to smoothly compose with standard values, thus complicating programming and introducing clutter in aggregate programs, libraries and domain-specific languages (DSLs). To address this key issue we introduce the novel notion of "computation against a neighbour", whereby the evaluation of certain subexpressions of the aggregate program are affected by recent corresponding evaluations in neighbours. We capture this notion in the neighbours calculus (NC), a new field calculus variant which is shown to smoothly support declarative specification of interaction with neighbours, and correspondingly facilitate the embedding of field computations as internal DSLs in common general-purpose programming languages -- as exemplified by a Scala implementation, called ScaFi. This paper formalises NC, thoroughly compares it with respect to the classic field calculus, and shows its expressiveness by means of a case study in edge computing, developed in ScaFi.Comment: 50 pages, 16 figure

Progettazione di una piattaforma web per la simulazione di programmi aggregati

La programmazione aggregata è un approccio innovativo nato in tempi recenti per far fronte alla necessità di un punto di vista nuovo nella programmazione di sistemi distribuiti. In particolare, basandosi sull'impianto teorico del field calculus, negli ultimi anni sono stati realizzati, da parte dell'Università di Bologna, linguaggi e framework innovativi per la sua applicazione in contesti d'uso reale: Protelis e ScaFi. La principale criticità che mina la diffusione di questo tipo di linguaggi è legata alla configurazione del sistema per l'esecuzione: è infatti necessario avere a disposizione una rete, reale o fisica, di dispositivi per l'esecuzione del codice e, soprattutto in contesto didattico, la necessità di dispiegare un certo numero di dispositivi o configurare un simulatore può costituire un ulteriore gradino di complessità. Lo scopo di questa tesi è progettare una piattaforma web che permetta di realizzare semplici programmi aggregati senza configurazione alcuna. È stato realizzato un sistema composto da un server esecutore, che si avvale del simulatore Alchemist per eseguire il codice Protelis, e da un'applicazione web in React che permetta la scrittura del codice e il monitoring dell'esecuzione

A Kotlin multi-platform implementation of aggregate computing based on XC

The integration of technology in everyday activities is rising, with objects being increasingly equipped with computational capabilities and interconnected to form the Internet of Things, leading to the need for innovative cyber-physical services capable of creating a fast bridge between the real and virtual world. The central idea of this thesis focuses on leveraging Kotlin Multiplatform to enhance aggregate computing based on XC principles, addressing challenges in developing versatile solutions across different environments, with the need of efficient and scalable applications operating from cloud to edge to mesh networks. This thesis combines theoretical analysis, software development, and performance evaluation to assess the effectiveness of the objective, demonstrating versatility and efficiency. There is a notable improvement in performance, scalability, and adaptability across different network environments. With the proposed approach, the developed solution appears to be more efficient and effective in addressing complex challenges within systems rather than the current state of the art. The results demonstrate the transformative potential of this technology, suggesting that it can lead to more efficient and versatile service development. In summary, this thesis shows the feasibility of using Kotlin Multiplatform to implement aggregate computing based on XC, demonstrating that the proposed approach is more efficient and scalable than the state of the art. Improved performance and scalability are emphasised through this approach, which opens doors for more efficient and adaptable solutions. This study sets the stage for future developments that could improve service efficiency and effectiveness

Towards Aggregate Programming in pure Kotlin through compiler-level metaprogramming

The last few decades have seen significant technological advancements in computing, the internet, and mobile technology, leading to the growth of the Internet of Things (IoT). This has resulted in a network of physical devices embedded with sensors, software, and connectivity, which can collect and share data. However, this growth has also brought new challenges, such as the need for complex software engineering to take advantage of the computational infrastructure available while considering unpredictability and communication heterogeneity. This thesis explores the aggregate programming, which is a paradigm based on field calculus, and it allows for the easy manipulation of data across devices, making it possible to perform operation on the data of distributed systems, in a simple and efficient manner. The paradigm has been implemented in various programming languages and platforms, such as Protelis, Scafi and FCPP. This thesis proposes a new implementation of the aggregate programming paradigm, called Collektive. The aggregate programming paradigm requires the communication of the devices to be coordinated through the alignment, which keeps track of the computational state of each device. The work done in this thesis explores different Kotlin metaprogramming techniques in order to solve this problem, illustrating the final solution achieved through the implementation of a Kotlin compiler plugin, which is totally transparent and portable. The project provides the user a minimal DSL, which is compatible with multiple platforms, such as JVM, JavaScript and Kotlin Native. This is possible because of the features offered by Kotlin Multiplatform, which is used for the implementation of the DSL. Moreover, this thesis addresses the validation process carried out to test the correct behavior of the system, which guarantees that Collektive can be considered at the same level of the existing aggregate programming implementations

Space-Time Universality of Field Calculus

International audienceRecent work in the area of coordination models and collective adaptive systems promotes a view of distributed computations as functional blocks manipulating data structures spread over space and evolving over time. In this paper, we address expressiveness issues of such computations, and specifically focus on the field calculus, a prominent emerging language in this context. Based on the classical notion of event structure, we introduce the cone Turing machine as a ground for studying computability issues, and first use it to prove that field calculus is space-time universal. We then observe that, in the most general case, field calculus computations can be rather inefficient in the size of messages exchanged, but this can be remedied by an encoding to nearly similar computations with slower information speed. We capture this concept by a notion of delayed space-time universality, which we prove to hold for the set of message-efficient algorithms expressible by field calculus. As a corollary, it is derived that field calculus can implement with message-size efficiency all self-stabilising distributed algorithms