The complexity of modern microservice architectures has surpassed the capabilities of traditional orchestration tools, which rely on static, manual workflows. This limits scalability and adaptability, especially to dynamic workloads. This paper argues for a paradigm shift towards self-managing, intent-driven microservices orchestration systems, where human operators express high-level goals in natural language. As a foundational step towards this vision of autonomous orchestration agents, we introduce LEMON: a new architecture that leverages Large Language Models (LLMs) for intelligent microservice monitoring. We also propose a comprehensive classification to structure this emerging field. Our evaluation demonstrates that fine-tuning Small Language Models (SLMs) for intent classification significantly enhances accuracy while ensuring the model's output is reliably structured for automation. Furthermore, our analysis of the trade-offs between model size, precision, and latency provides a practical guide for deploying these systems. We foresee this monitoring capability as the critical ”sense” component toward autonomous microservices orchestration loops. By diagnosing performance bottlenecks from natural language queries, LEMON enables future systems to automatically suggest and execute solutions. This work lays the groundwork for truly self-managing, intent-driven systems.

In critical scenarios like disaster response or real-time monitoring, efficient and adaptive task scheduling is essential. This paper presents a decentralized framework using Nash Q-learning, a game-theoretic reinforcement learning technique, for urgent edge computing. Tasks are allocated among agents based on strategies derived from multi-agent interactions modeled as a Markov Game. The method promotes decentralized cooperation and improves responsiveness by adapting to dynamic conditions. We provide a formal model and outline its applicability to various edge environments.

We present Rusty-Cracker, a high-performance Rust library that implements a parallel version of the Cracker algorithm for efficiently identifying connected components in large-scale graphs. Designed to address the growing demands of graph analytics in fields such as social network analysis, bioinformatics, and infrastructure modeling, Rusty-Cracker leverages Rust's concurrency and memory safety features to ensure both speed and reliability. The adapted Cracker algorithm capitalizes on modern multi-core architectures through parallel processing, effectively minimizing synchronization overhead and optimizing workload distribution. This design significantly reduces computational time while maintaining accuracy. We present the implementation details and evaluate its performance on a real-world dataset of undirected graphs.

We present FastFlow-Python, a framework that brings parallelism to Python for stream-processing applications. FastFlow-Python enables developers to build high-throughput, low-latency data-flow networks by instantiating high-level, ready-to-use parallel building blocks. Built on the C++ FastFlow library, it leverages Python bindings via the C/Python API to efficiently manage parallel execution using both subinterpreters and multiprocessing, all abstracted by the framework. We demonstrate the performance benefits of FastFlow-Python through a comparative analysis with a pure Python stream-processing implementation, highlighting its effectiveness in overcoming the limitations imposed by the Global Interpreter Lock (GIL). Experimental results show almost linear scalability when increasing the number of workers.

This paper presents SPARE, a novel serverless platform that supports self-adaptive resource allocation and reconfiguration, thereby increasing the availability of computing resources for time-critical tasks in urgent events. In emergency scenarios, SPARE reallocates resources by forwarding serverless function invocations to the nearest edge nodes having sufficient capacity. Additionally, the platform employs the use of unikernels and lightweight virtualization through Firecracker, which helps to reduce cold start times and improve function responsiveness. The experimental results demonstrate that SPARE is capable of releasing up to one-third of edge nodes within a serverless edge platform, while only experiencing a mild increase in latency, thus maintaining service continuity.

The Compute Continuum paradigm addresses the challenges of heterogeneous and dynamic computing resources, facilitating distributed application execution while enhancing data locality, performance, availability, adaptability, and energy efficiency. By integrating IoT, edge, and cloud resources into a cohesive continuum, applications can operate closer to data sources and end users. This approach supports refined adaptation strategies tailored to specific infrastructure components, enabling reduced latency, optimized bandwidth use, and improved privacy. To fully realize the Compute Continuum’s potential, autonomous and proactive management is essential, leveraging interdisciplinary methods from optimization theory, control theory, machine learning, and artificial intelligence. This special issue highlights advancements in three key areas: resource characterization and scheduling, middleware for application deployment and reconfiguration, and applications in the Compute Continuum. These contributions highlight innovative solutions for resource optimization, dynamic management, and real-world implementations, showcasing the potential of the Compute Continuum to revolutionize distributed computing across diverse domains.

This paper presents a novel algorithm for the Vertex Cover problem, inspired by the Think-Like-A-Vertex (TLAV) paradigm. The Vertex Cover problem, a fundamental challenge in graph theory, finds significant relevance in the context of the compute continuum, where the optimal placement of application images across a diverse range of computational resources is a critical concern. Our proposed TLAV-based algorithm addresses this challenge by leveraging local information at each vertex to make intelligent decisions, thereby reducing the global complexity of the problem. While this approach could potentially lead to resource overprovisioning, we argue that in the context of the compute continuum, this trade-off can provide more flexibility and redundancy, enhancing the reliability of the system. Through extensive analysis and experimental results, we demonstrate the efficiency and scalability of our algorithm on large-scale graphs, making a significant contribution to the field of resource management in the compute continuum.

Federated Echo State Networks proved their efficiency in learning low-resource collaborative settings where data is regulated privacy. In this work, we broaden the applicability of this machine learning approach to a decentralized setting, where we have a set of peers connected through a logical communication topology and cannot rely on a centralized aggregation entity. In particular, we propose Decentralized Incremental Federated Learning (DIncFed), where multiple agents collaborate to learn a readout by leveraging exact consensus strategies. Such strategies include mechanisms for collaboratively aggregating knowledge towards consensus, as well as policies for dynamically updating the communication topology. Experiments prove the efficacy and the efficiency of the proposed learning methodology against a state-of-the-art iterative competitor on multiple benchmarks characterized by different levels of statistical heterogeneity.

Nowadays, as the need for capacity continues to grow, entirely novel services are emerging. A solid cloud-network integrated infrastructure is necessary to supply these services in a real-time responsive, and scalable way. Due to their diverse characteristics and limited capacity, communication and computing resources must be collaboratively managed to unleash their full potential. Although several innovative methods have been proposed to orchestrate the resources, most ignored network resources or relaxed the network as a simple graph, focusing only on cloud resources. This paper fills the gap by studying the joint problem of communication and computing resource allocation, dubbed CCRA, including function placement and assignment, traffic prioritization, and path selection considering capacity constraints and quality requirements, to minimize total cost. We formulate the problem as a non-linear programming model and propose two approaches, dubbed B&B-CCRA and WF-CCRA, based on the Branch & Bound and Water-Filling algorithms to solve it when the system is fully known. Then, for partially known systems, a Double Deep Q-Learning (DDQL) architecture is designed. Numerical simulations show that B&B-CCRA optimally solves the problem, whereas WF-CCRA delivers near-optimal solutions in a substantially shorter time. Furthermore, it is demonstrated that DDQL-CCRA obtains near-optimal solutions in the absence of request-specific information.

An increasing number of application domains require high-throughput processing to extract insights from massive data streams. The Data Stream Processing (DSP) paradigm provides formal approaches to analyze structured data streams considered as special, unbounded relations. The most used class of stateful operators in DSP are the ones running sliding-window aggregation, which continuously extracts insights from the most recent portion of the stream. This article presentsSpringald, an efficient sliding-window operator leveraging GPU devices.Springald, incorporated in theWindFlowparallel library, processes out-of-order data streams with watermarks propagation. These two features—GPU processing and out-of-orderliness—makeSpringalda novel contribution to this research area. This article describes the methodology behindSpringald, its design and implementation. We also provide an extensive experimental evaluation to understand the behavior ofSpringalddeeply, and we showcase its superior performance against state-of-the-art competitors.

This article proposes an approach to the data-aware multi-service application placement problem in Cloud-Edge settings. We propose both declarative programming and a Mixed-Integer Linear Programming (MILP) approach to determine eligible placements that minimise operational costs and reduce the number of used nodes to contain the amount of data transfers. After assessing the performance of both approaches, we reconcile them into a methodology that combines the best of the two worlds by exploiting a declarative pre-processing step to boost the MILP solver while determining optimal solutions. We open-sourced the methodology into a prototype that is l0x faster than pure MILP, determines optimal results, and easily accommodates non-numerical constraints on application placements.

The transition from Cloud Computing to a Cloud-Edge continuum brings many new exciting possibilities for interactive and data-intensive Next Generation applications, but as many challenges. Approaches and solutions that successfully worked in the Cloud space now need to be rethought for the Edge's distributed, heterogeneous and dynamic ecosystem. The placement of application images needs to be proactively devised to reduce as much as possible the image transfer time and comply with the dynamic nature and strict requirements of the applications. To this end, this paper proposes an approach based on the combination of Graph Neural Networks and actor-critic Reinforcement Learning. The approach is analyzed empirically and compared with a state-of-the-art solution. The results show that the proposed approach exhibits a larger execution times but generally better results in terms of application image placement.

This paper proposes a continuum-aware programming model enabling the execution of application workflows across the compute continuum: cloud, fog and edge resources. It simplifies the management of heterogeneous nodes while alleviating the burden of programmers and unleashing innovation. This model optimizes the continuum through advanced development experiences by transforming workflows into autonomous service collaborations. It reduces complexity in positioning/interconnecting services across the continuum. A meta-model introduces high-level workflow descriptions as service networks with defined contracts and quality of service, thus enabling the deployment/management of workflows as first-class entities. It also provides automation based on policies, monitoring and heuristics. Tailored mechanisms orchestrate/manage services across the continuum, optimizing performance, cost, data protection and sustainability while managing risks. This model facilitates incremental development with visibility of design impacts and seamless evolution of applications and infrastructures. In this work, we explore this new computing paradigm showing how it can trigger the development of a new generation of tools to support the compute continuum progress.

Intent-based Networking (IBN) aims at simplifying network configuration and management by using high-level objectives that express the desired state of the network rather than the details of how to implement it. In this article, we propose a declarative methodology and an associated open-source Prolog prototype (i) to model IBN intents related to the provisioning of Virtual Network Function (VNF) chains, and (ii) to process those intents to assemble and place a VNF chain that fulfils them. Our prototype is assessed over a lifelike motivating scenario.

Emerging cross-reality (XR) applications, including holography, augmented, virtual, and mixed reality, are characterized by unprecedented requirements for Quality of Experience (QoE), largely exceeding those currently attainable. To cope with these requirements, noticeable efforts and a number of initiatives are ongoing to enhance the current communications technologies, especially in the direction of supporting ultralow latency and increased bandwidth. This work proposes an architecture that puts together the key enablers to support future XR applications, highlighting the shortcomings of existing technologies and leveraging the ongoing innovations. It demonstrates the feasibility of the proposed architecture by describing the processes driving the platform with relevant use case scenarios, and mapping the envisioned functionality to existing tools.

Federated learning is a popular framework that enables harvesting edge resources' computational power to train a machine learning model distributively. However, it is not always feasible or profitable to have a centralized server that controls and synchronizes the training process. In this paper, we consider the problem of training a machine learning model over a network of nodes in a fully decentralized fashion. In particular, we look for empirical evidence on how sensitive is the training process for various network characteristics and communication parameters. We present the outcome of several simulations conducted with different network topologies, datasets, and machine learning models.

To assure a timely fruition of media and interactive applications to end users is a complex challenge, especially when potentially spread worldwide, at home or in mobility. It in fact requires a careful placement of the software services on the right computational resources, such that those services are placed as close as possible to end users to mitigate the effect of network on the user experience. In this demo paper, we present a tool that aims to facilitate the placement of latency sensitive applications on computational resources, by considering the geographical positioning of the user demand, the user experience, and the budget limitation of application owners.

The ubiquity of data streams in different fields of computing has led to the emergence of Stream Processing Systems (SPSs) used to program applications that extract insights from unbounded sequences of data items. Streaming applications demand various kinds of optimizations. Most of them are aimed at increasing throughput and reducing processing latency, and need cost models used to analyze the steady-state performance by capturing complex aspects like backpressure and bottleneck detection. In those systems, the tendency is to support dynamic optimizations of running applications which, although with a substantial run-time overhead, are unavoidable in case of unpredictable workloads. As an orthogonal direction, this paper proposes SpinStreams, a static optimization tool able to leverage cost models that programmers can use to detect and understand the inefficiencies of an initial application design. SpinStreams suggests optimizations for restructuring applications by generating code to be run on the SPS. We present the theory behind our optimizations, which cover more general classes of application structures than the ones studied in the literature so far. Then, we assess the accuracy of our models in Akka, an actor-based streaming framework providing a Java and Scala API.

Finding connected components is a fundamental task in applications dealing with graph analytics, such as social network analysis, web graph mining and image processing. The exponentially growing size of today's graphs has required the definition of new computational models and algorithms for their efficient processing on highly distributed architectures. In this paper we present CRACKER, an efficient iterative MapReduce-like algorithm to detect connected components in large graphs. The strategy of CRACKER is to transform the input graph in a set of trees, one for each connected component in the graph. Nodes are iteratively removed from the graph and added to the trees, reducing the amount of computation at each iteration. We prove the correctness of the algorithm, evaluate its computational cost and provide an extensive experimental evaluation considering a wide variety of synthetic and real-world graphs. The experimental results show that CRACKER consistently outperforms state-of-the-art approaches both in terms of total computation time and volume of messages exchanged.

Statistical authorities promote and safeguard the production and publication of official statistics that serve the public good. One of their duties is to monitor the presence of individuals region by region. Traditionally this activity has been conducted by means of censuses and surveys. Nowadays technologies open new possibilities such as a continuous sensing of the presences by leveraging the data associated to mobile devices, e.g., the behaviour of users on doing calls. In this paper first we propose a specifically conceived similarity function able to capture similarity between individuals call behaviours. Second we make use of a clustering algorithm able to handle arbitrary metric leading to a good internal and external consistency of clusters. The approach provides better population estimation with respect to state of the art comparing with real census data. The scalability and flexibility that characterises the proposed framework enables novel scenarios for the characterization of people by means of data derived from mobile users, ranging from the nearly-realtime estimation of presences to the definition of complex, uncommon user archetypes.

The problem of finding connected components in a graph is common to several applications dealing with graph analytics, such as social network analysis, web graph mining and image processing. The exponentially growing size of graphs requires the definition of appropriated computational models and algorithms for their processing on high throughput distributed architectures. In this paper we present cracker, an efficient iterative algorithm to detect connected components in large graphs. The strategy of cracker is to iteratively grow a spanning tree for each connected component of the graph. Nodes added to such trees are discarded from the computation in the subsequent iterations. We provide an extensive experimental evaluation considering a wide variety of synthetic and real-world graphs. The experimental evaluation shows that cracker consistently outperforms state-of-the-art approaches both in terms of total computation time and volume of messages exchanged.

The broad diffusion of Cloud Computing has fostered the proliferation of a large number of cloud computing providers. The need of Cloud Brokers arises for helping consumers in discovering, considering and comparing services with different capabilities and offered by different providers. Also, consuming services exposed by different providers, when possible, may alleviate the vendor lock-in. While it can be straightforward to choose the best provider when deploying small and homogeneous applications, things get harder if the size and complexity of applications grow up. In this paper we propose a genetic approach for Cloud Brokering, focusing on finding Infrastructure-as-a-Service (IaaS) resources for satisfying Quality of Service (QoS) requirements of applications. We performed a set of experiments with an implementation of such broker. Results show that our broker can find near-optimal solutions even when dealing with hundreds of providers, trying at the same time to mitigate the vendor lock-in.

Cloud Federation is a promising approach to enhance cross-cloud application execution. Nevertheless, such approach emphasizes open challenges in Cloud Computing, such as revoking long-lasting authorization on resources as soon as conditions granting the access right are no longer valid. To tackle this kind of issues, we built a prototype of Cloud Federation that leverages the concept of Usage Control (UCON), by continuously monitoring and reassessing the users right on resources. We exploited an extension of the XACML standard and measured the overhead caused by different security policies and distributions of requests. Results suggest that the UCON model can be effectively applied in Cloud Federations and its performance is sustainable when applied to the relevant actions of the lifecycle of applications.

Over recent years, we experienced a huge diffusion of internet connected computing devices. As a consequence, this leaded to research for efficient and scalable approaches for managing the burden caused by the highly increased volume of data to be exchanged and processed. Efficient communication protocols are fundamental building blocks for realizing such approaches [1], [2]. Thus, several peer-to-peer protocols have been proposed. Gossip protocols [3]-[7] are a family of peer-to-peer protocols that proved to be well-suited for supporting a scalable and decentralized strategy for peer and data aggregation and diffusion. However, one of the typical limitation of Gossip protocols consists in the selfish behavior adopted by peers in defining their neighborhood and, as a consequence, the topology of the overlay they build. GROUP [8] is a Gossip protocol we conceived to overcome this limitation. It builds explicit defined communities of peers that are identified by their leaders, each one elected in a distributed fashion. This protocol experimentally proved to be efficient and effective with respect to its aim. Anyhow, no analytical study has been realized so far. This work presents a currently ongoing work we are conducting for exploring the properties of GROUP in a more formal way. We conduct this preliminary investigation using a formalization based on Markov chains.

P2P overlays based on Delaunay triangulations have been recently exploited to implement systems providing efficient routing and data broadcast solutions. Several applications such as Distributed Virtual Environments and geographical nearest neighbours selection benefit from this approach. This paper presents a novel distributed algorithm for the incremental construction of a Delaunay overlay in a P2P network. The algorithm employs a distributed version of the classical Edge Flipping procedure. Each peer builds the Delaunay links incrementally by exploiting a random peer sample returned by the underlying gossip level. The algorithm is then optimized by considering the Euclidean distance between peers to speed up the overlay convergence. We present theoretical results that prove the correctness of our approach along with a set of experiments that assess the convergence rate of the distributed algorithm.

Autonomic management can be used to improve the QoS provided by parallel/distributed applications. We discuss behavioural skeletons introduced in earlier work: rather than relying on programmer ability to design "from scratch" efficient autonomic policies, we encapsulate general autonomic controller features into algorithmic skeletons. Then we leave to the programmer the duty of specifying the parameters needed to specialise the skeletons to the needs of the particular application at hand. This results in the programmer having the ability to fast prototype and tune distributed/parallel applications with non-trivial autonomic management capabilities. We discuss how behavioural skeletons have been implemented in the framework of GCM (the grid component model developed within the CoreGRID NoE and currently being implemented within the GridCOMP STREP project). We present results evaluating the overhead introduced by autonomic management activities as well as the overall behaviour of the skeletons. We also present results achieved with a long running application subject to autonomic management and dynamically adapting to changing features of the target architecture. Overall the results demonstrate both the feasibility of implementing autonomic control via behavioural skeletons and the effectiveness of our sample behavioural skeletons in managing the "functional replication" pattern(s).