The rise of technologies like AI and IoT has increased the need for high-performance, low-latency computing. Edge computing addresses this by extending cloud resources closer to client applications. Effective workload distribution across this edge-cloud continuum must however consider both network proximity and available computing resources to avoid potential overloads. To achieve this, we developed a computing-aware framework for dynamic traffic steering using Kubernetes API, MP-BGP, and SRv6. Specifically, we use Kubernetes APIs to determine computing capacity and BGP to advertise it, while SRv6 steers traffic based on proximity, resource availability, and QoS requirements. We implemented a proof-of-concept of the proposed framework and validated it using GNS3 and Unix-based routers running FRRouting, demonstrating its effectiveness and performance.

The rise of Digital Twin (DT) technology has revolutionized various sectors, offering simulation, monitoring, and optimization capabilities for complex systems. However, the rapid expansion of DT platforms, coupled with the need to deploy twins across the edge-to-cloud computing spectrum, has led to significant fragmentation and management challenges. These complexities should not hinder the application layer’s goal of achieving interoperability and integrated management of DT instances. This paper introduces the Digital Twin Continuum (DTC) as a unified framework to address the challenges of DT coordination, hiding platform intricacies, while tackling the orchestration of communication and computing resources in the edge-to-cloud continuum. In this study, we define the concept of DTC, outlining its modeling principles, core functionalities and architectural components. We conduct an initial experimental evaluation of a DTC prototype in a realistic automotive use case, targeting two reference DT runtimes.

The quest for trustworthiness in Artificial Intelligence (AI) is increasingly urgent, especially in the field of next-generation wireless networks. Future Beyond 5G (B5G)/6G networks will connect a huge amount of devices and will offer innovative services empowered with AI and Machine Learning tools. Nevertheless, private user data, which are essential for training such services, are not an asset that can be unrestrictedly shared over the network, mainly because of privacy concerns. To overcome this issue, Federated Learning (FL) has recently been proposed as a paradigm to enable collaborative model training among multiple parties, without any disclosure of private raw data. However, the initiative to natively integrate FL services into mobile networks is still far from being accomplished. In this paper we propose a novel FL-as-a-Service framework that provides the B5G/6G network with flexible mechanisms to allow end users to exploit FL services, and we describe its applicability to a Quality of Experience (QoE) forecasting service based on a vehicular networking use case. Specifically, we show how FL of eXplainable AI (XAI) models can be leveraged for the QoE forecasting task, and induces a benefit in terms of both accuracy, compared to local learning, and trustworthiness, thanks to the adoption of inherently interpretable models. Such considerations are supported by an extensive experimental analysis on a publicly available simulated dataset. Finally, we assessed how the learning process is affected by the system deployment and the performance of the underlying communication and computation infrastructure, through system-level simulations, which show the benefits of deploying the proposed framework in edge-based environments.

Interoperability is one of the main issues concerning the Internet of Things (IoT). The Arrowhead Framework (AHF) is an open-source platform that aims at tackling this problem. In this work, we first integrate a set of legacy IoT devices (i.e., an ECG and a smart plug) into the AHF by leveraging W3C Web of Things (WoT) as an interface between the two worlds. The result is an architecture where AHF consumers are deployed in a local cloud and consume Web Things, which can be deployed on IoT devices as well as on servers at the network edge to provide edge computing services. In this context, IoT device mobility raises a problem. When the IoT device moves, indeed, the edge-hosted service needs to follow it to preserve proximity, which is key to edge computing. In this case, the IP addresses of both the Web Things (i.e., the one hosted on the IoT device and the one hosted at the edge) may change, causing problems of mutual reachability after mobility/migration. WoT does not currently handle this issue. In this work, we extend WoT in this direction and evaluate our approach over a small-scale edge computing testbed.

ETSI MEC is a standard for edge computing which allows the execution of services - called MEC applications - on hosts in user proximity. One of the emerging concepts within ETSI MEC is that of MEC application relocation, i.e., the migration of a MEC application between edge hosts. ETSI MEC identifies several approaches to relocate a MEC application along with its internal state. However, some of these approaches devote the transfer of the application state to the application itself, whereas others rely on costly virtual-machine migration procedures. To overcome the above limitations, in this work we extend ETSI MEC to support MEC application relocation by exploiting container-migration technologies. We evaluate the performance of our implementation over a small-scale edge testbed, showing the overall benefits of the proposed approach.

Edge computing allows to run microservices in close proximity to end user devices. This proximity lets edge computing support emerging 5G application scenarios that need low latency and high bandwidth (e.g., augmented reality, autonomous vehicles). Given its interest, edge computing is fastly gaining momentum and is currently being standardised by the European Telecommunications Standards Institute (ETSI) as Multi-Access Edge Computing (MEC). Notwithstanding its strengths, edge computing is significantly challenged by device mobility, as this can reduce proximity to the edge microservice, putting edge computing benefits at risk. A way to solve this problem is to migrate the edge microservice across edge servers, to let it follow the application component running on the mobile device. Besides, if the microservice is stateful (i.e., it maintains a state associated to the user), its state needs to be migrated as well. Within ETSI MEC, this concept is expressed as stateful application relocation. The standard identifies three different high-level ways to transfer the application state. However, all of them assume that it is up to the application to actually relocate the state. In this work, we assume that applications at the edge run as containers, and we extend ETSI MEC to let it support stateful application relocation by leveraging container migration techniques. This approach allows to transfer the application state in a transparent way to the application itself. We implemented our solution and tested it over a small-scale edge computing testbed to extract initial results.

In modern cloud and edge computing environments, services are typically provided as Virtual Machines (VMs). More recently, containers have been gaining momentum as a lightweight form of VMs. Container migration is used for several reasons, one of which being to maintain proximity between edge computing services and mobile users. When migrating containers, however, it is important to consider that they typically have ongoing communications with other endpoints, e.g., users' applications. Moreover, in case of connection-oriented protocols, communicating endpoints share a state (i.e., the connection), which needs to be migrated as well. Connection-oriented protocols like TCP were not designed having connection migration in mind, thus their connections cannot survive a change of IP address or port number. On the other hand, the QUIC protocol provides a mechanism for client-side connection migration, i.e., when a client device changes IP address (e.g., after a wireless handover), QUIC transparently migrates ongoing connections to the new address. Nonetheless, server-side connection migration in QUIC is not yet implemented nor investigated. In this paper, we extend QUIC to support server-side connection migration when a container is migrated between hosts. More specifically, we design two different strategies to achieve this purpose. Besides, we describe a proof-of-concept implementation based on aioquic, a Python open-source implementation of QUIC. We also verify that our implementation does not break QUIC specification nor undermines aioquic interoperability. Finally, we evaluate our solution by testing both the considered strategies using different container migration techniques and against a no-migration scenario.

This paper describes the SAPIENT system, a real-time monitoring and control infrastructure for Air Traffic Management. Within the latter, aircrafts constantly measure the state and quality of their datalinks, and report these measurements to a ground entity, tagging them with a time/space reference. The ground entity, then, builds a map of the monitored portion of the sky, and can feed back information to the aircrafts themselves regarding conditions that they would not be able to measure otherwise. This allows optimal vertical handover decisions to be made, increasing service continuity and improving communication performance. We show that the SAPIENT system can be implemented using existing technologies, without the need for expensive hardware. Moreover, we show via simulation that a small, negligible increase in the communication overhead due to SAPIENT reporting brings about considerable benefits.

Multi-access Edge Computing (MEC) allows users to run applications on demand near their mobile access points. MEC applications will exploit 5G infrastructure, and they will have to be designed by taking into account the characteristics of 5G mobile networks. This work describes how to use a system-level simulator of 5G networks - namely Simu5G, which evolves the popular 4G network simulator SimuLTE - as a real-time 5G net-work emulator. This allows designers of networked applications - and MEC ones in particular - to use it as a testbed during the deployment. We describe the system setup of Simu5G as an emulator, and its emulation capabilities and scale. Moreover, we present a case study of a MEC testbed using Intel's Open Network Edge Services Software (OpenNESS) toolkit, based on a recent demon-stration in 5GAA (5G Automotive Association).

This paper presents Simu5G, a new OMNeT++-based system-level simulator of 5G networks. Simu5G is built starting from the SimuLTE simulation library, which models 4G (i.e., LTE/LTE-A) networks, and is compatible with the latter, thus allowing the simulation of 4G-5G coexistence and transition scenarios. We discuss the modelling of the protocol layers, network entities and functions, and validate our abstraction of the physical layer using 3GPP-based scenarios. Moreover, we report profiling results related to Simu5G execu-tion, and we describe how it can be employed to evaluate Radio Access Network configurations, as well as end-to-end scenarios involving communication and computation, e.g., with Multi-access Edge Computing ap-plications.

The integration between fog computing and the Internet of Things (IoT) creates plenty of new opportunities. Fog computing nodes run complex tasks on behalf of IoT devices, and the topological proximity of fog computing to the IoT enables several advantages (e.g., low latency). However, some IoT devices are mobile, and mobility may compromise the fog advantages. When a device moves, the communication path to the corresponding fog service may increase, with an impact on the fog advantages (which are a consequence of fog proximity) and overall performance. To overcome this issue, the fog service may be migrated across the fog computing infrastructure and maintained close enough to the served IoT device(s). It is worth noting, though, that service migration comes at a cost and may affect application Quality of Service (QoS). In this paper, we consider a fog service to be implemented as multiple containers, having one of them encapsulating an MQTT broker. Our contribution is the evaluation of the impact of container migration, which is considered in various flavours, on application QoS as perceived by mobile things. To this purpose, we consider an augmented reality application based on the MQTT protocol and conduct a set of experiments over a real fog computing testbed. Results show how migrating the fog service gives some benefits on the experienced QoS with respect to a case where no migration is performed.

Integration between fog computing and the Internet of Things (IoT) paves the way to a plethora of promising opportunities. Device mobility might however impair fog computing benefits (e.g., low latency), which are indeed an outcome of fog proximity to end users/devices. A solution to this problem is to migrate the fog service across the fog infrastructure, thus to keep the distance to the served mobile device as low as possible. In this paper, we consider a fog service to be implemented as the combination of two containers, and we detail the demo through which we plan to show the impact of fog service migration on application performance. To this purpose, we plan to deploy an Augmented Reality (AR) application that detects vehicles in video frames and augments the latter with bounding boxes built around the detected vehicles. We offer to the audience the possibility to: (i) interact with the employed testbed by triggering device mobility; (ii) visualise the difference between migrating and not migrating the fog service in response to device mobility.

Recent Information Technologies are progressively dramatically changing how industrial processes are carried out. This is leading to a new industrial revolution, Industry 4.0, in which productivity, efficiency and safety are improved significantly. Safety of workers and operators, in particular, is expected to improve thanks to pervasive technologies like wearable devices and sensors. In this paper we present a demo of a sensorized glove for industrial safety based on Near-Field Communication (NFC). The demonstration is a proof-of-concept implementation that shows how an NFC-enabled sensor installed in the glove of a worker can be exploited to monitor worker's action and report dangerous situations in advance in order to prevent accidents and injuries.

Wireless Sensor Networks (WSNs) are one of the main building blocks of the future Internet of Things (IoT). Thanks to the introduction of the 6LoWPAN standard, WSNs can also be integrated into IP networks in a seamless manner. In a previous work, we defined SD-6LoWPAN, an architecture specifically designed to enable software defined networking in 6LoWPANs. In this work, we focus on the implementation of the proposed SDN solution on top of real constrained devices powered by the Contiki operating system. We illustrate the main challenges discovered, and how they have been addressed by extending the Contiki network stack in order to provide a working prototype of SD-6LoWPAN. The latter is then validated by running a set of experiments on a real testbed.

Wireless Sensor Networks (WSNs)play a major role in the expansion of the Internet of Things (IoT)market as they allow the deployment of low cost and low power networks possibly in large areas. The introduction of the 6LoWPAN standard allowed WSN to move into the IPv6 era, with a seamless integration of sensors into external networks. The recent application of IoT in industrial systems is now introducing new traffic patterns - machine to machine (M2M)above the others - and communication challenges that can modify the classical multipoint-to-point pattern of WSN, having the sink as the root of every communication. To solve these problems, we propose an architecture to enable an efficient and controlled multi-hop forwarding over 6LoWPANs. We base our approach on the standard 6LoWPAN protocol stack and we exploit the Software Defined Networking paradigm to achieve network reconfigurability. We evaluate the performance of our architecture in a simulated environment, with both multipoint-to-point and M2M traffic, and we demonstrate its feasibility in a real testbed.

Cellular network nodes should be dynamically switched on/off based on the load requirements of the network, to save power and minimize inter-cell interference. This should be done keeping into account global interference effects, which requires a centralized approach. In this paper, we present an architecture, realized within the Flex5GWare EU project, that manages a large-scale cellular network, switching on and off nodes based on load requirements and context data. We describe the architectural framework and the optimization model that is used to decide the activity state of the nodes. We present simulation results showing that the framework adapts to the minimum power level based on the cell loads.

One-to-one device-to-device (D2D) communications are expected to play a major role in future releases of LTE-A, as well as in future 5G networks . Despite the abundance of works on resource allocation for D2D communications, few works, if any, discuss how D2D should be realized within the LTE-A protocol stack. While it is generally understood that D2D endpoints should be able to communicate both on the direct path or sidelink (SL) and on the relayed path (RP) through the eNB, little has been said on how this can be achieved in practice. In this paper we present a comprehensive proposal for a data-plane architecture for D2D communication: we define how communications should occur on the SL and the RP, and propose a solution for the challenges associated with mode switching between the SL and the RP. In particular, we argue that two different communication modes on the RP are required to allow D2D connections to be kept alive across cell borders in a multicell environment. Our proposal is scalable, since it does not require any signaling, and is guaranteed to not introduce losses. We evaluate our proposal through detailed system-level simulations, also focusing on its interplay with transport-layer protocols.

In an LTE-Advanced network, network-controlled Device-to-Device (D2D) communications can be combined in a multihop fashion to distribute broadcasts over user-defined (and possibly large) areas, with small latencies and occupying few resources. Such a service may be exploited for several purposes, (e.g. Internet of Things, Vehicular communications). Engineering a multihop D2D-based broadcast service requires working at both the application level on the User Equipment (UE) and at the resource-allocation level within the eNodeBs. This paper describes the necessary modifications at both the UE and the eNodeB, what the main issues are, and how to solve them efficiently. We evaluate the performance of the above service using system-level simulations, and demonstrate its advantages over standard broadcasting techniques.

Direct (or device-to-device, D2D) communications are being investigated in the framework of LTE- Advanced. They allow one-to-one communications between two endpoints, under the control of the eNodeB, which allocates resources for the d2d flow, but does not act as a relay for its traffic. The direct link can also be used for file transfer or proximity-based browsing, i.e. applications running on TCP. In this paper, we evaluate the performance of TCP-based traffic transported through the direct link, in several scenarios. We show and explain non-intuitive results, which arise from the interplay of TCP and LTE-A protocol mechanisms, and compare the existing TCP versions in a dynamic environment, where mode switches between the direct and the infrastructure link may induce periodic losses.

Direct (or D2D) communications allow two UEs to communicate without passing through the eNodeB. However, the two UEs may still need to relay their communication through the eNB from time to time, hence should be able to switch from the direct to the re-layed mode seamlessly, without this affecting the QoS. In this paper we show that in conventional systems a mode switching may cause relevant losses, and propose two architectures to miti-gate or solve this problem. Our proposals do not require extra signaling or additional functionalities to be added to the network, hence are scalable and inexpensive. We assess their effectiveness through detailed system-level simulations.