The increasing energy consumption of Information and Communication Technologies (ICT) contributes significantly to global greenhouse gas emissions, requiring strategies for energy reduction. Techniques such as Diagonal Scaling and Brownout, originally proposed for managing peak loads through the degradation of quality of service, also present a promising opportunity for energy savings. However, a lack of case studies applying these techniques to real-world, production-grade applications persists. This paper presents a case study that applies feature degradation to the widely adopted, open-source Overleaf LaTeX editor, built on a microservices architecture, to reduce its energy consumption. First, an energy profile of all major services under load was conducted on the Grid'5000 testbed. This profiling identified the LaTeX compilation process as the primary energy consumer, responsible for approximately 90% of the application's total energy use. Focusing on this service, the energy savings achieved by enabling Overleaf's “fast mode”, a compilation setting that reduces processing load, were then evaluated. Experimental results across various load levels demonstrate that activating this mode reduces the energy consumed per compilation request by 4% to 15%. Finally, strategies to mitigate the potential rebound effect through the integration of behavioural and economic approaches into software design are discussed.

The growing energy footprint of Information and Communication Technology (ICT) services has become a critical environmental concern. While current approaches mainly focus on optimizing existing architectures, this position paper advocates for investigating a more fundamental shift: moving from Cloud-centric to Local-First Software architectures, where data and computation primarily reside on end-user devices. Through a preliminary study, we examine the energy consumption implications of such an architectural shift. We first develop a framework identifying the main potential impacts across the service stack (server, network, and client devices). We then discuss these impacts through three real-world examples, demonstrating how Local-First Software approaches could reduce energy consumption. Our analysis reveals both opportunities and challenges in this architectural transformation. While most impacts could contribute to energy reduction, particularly through decreased server and network usage, some negative impacts emerge, mainly around synchronization and client-side computation. These initial findings suggest that Local-First Software architectures, when appropriately implemented, could significantly reduce the energy footprint of digital services. This position paper aims to stimulate discussion and research in energy-efficient software architectures, laying the groundwork for future empirical studies on Local-First Software approaches in sustainable computing.

Fog Computing consists in decentralizing the Cloud by geographically distributing computation, storage, network resources, and related services. Among other benefits, it allows reducing bandwidth usage, limiting latency, or minimizing data transfers. However, Fog systems engineering remains challenging and quite often error-prone. Following best practices in software engineering, verification tasks can be performed before such systems are concretely deployed. Works already exist on verifying non-functional properties of Fog systems at different previous steps of the life cycle. This paper goes one step further and presents the VeriFogOps approach. This approach allows to automatically select deployment tools, based on expressed Quality of Service (QoS) requirements, and then generate relevant CI/CD pipelines supporting the deployment of Fog systems. We implemented and validated our approach via two realistic use cases, considering different QoS solutions and deployment tools. This work, developed in direct collaboration with our industrial partner Smile, goes towards the direction of a more comprehensive support for the entire life cycle of Fog systems, from design to actual deployment and execution.

The dominance of Software-as-a-Service (SaaS) has raised sustainability concerns due to its reliance on centralized cloud infrastructure and increasing energy consumption. This paper investigates a core principle of the Local-First Software (LoFi) paradigm, local processing (LP), as a potential alternative. Through a controlled empirical study using SeekTune, an open-source music recognition application, we compare the end-user device and server energy consumption and data usage of an LP architecture against a traditional SaaS model for a computationally intensive task. Our results demonstrate that, while LP consumes more energy on the client device, the combined energy cost of data transmission and server-side computation in the SaaS model often results in a larger total systemic footprint. In addition, LP transmits considerably less data over the network than SaaS. For modern mobile devices, processing locally can be significantly more energy-efficient overall. These findings challenge the long-held assumption that cloud offloading is inherently superior, and position the LP aspect of LoFi as a crucial consideration for sustainable software design.

The computing continuum aggregates edge, fog, and cloud infrastructure layers, promising lower latencies and improved performance for data-driven applications. In this context, keeping service-level objectives (SLOs) is challenging due to fluctuations in resource capacities and network uncertainties. We present an adaptive runtime that manages software configuration parameters, application placement, and scaling at runtime to enforce SLOs. Our approach aims to maintain a separation between developers and providers roles while providing performance estimations for previously unseen configurations. This paper describes the proposed architecture, event model, and preliminary results over the Grid'5000 testbed.

Despite continuous improvements, cloud physical resources remain underused, hence severely impacting the efficiency of these infrastructures at large. To overcome this inefficiency, Infrastructure-as-a-Service (IaaS) providers usually compensate for oversized Virtual Machines (VMs) by offering more virtual resources than are physically available on a host. However, this technique—known as oversubscription —may hinder performances when a statically-defined oversubscription ratio results in resource contention of hosted VMs. Therefore, instead of setting a static and cluster-wide ratio, this article studies how a greedy increase of the oversubscription ratio per Physical Machine (PM) and resources type can preserve performance goals. Keeping performance unchanged allows our contribution to be more realistically adopted by production-scale IaaS infrastructures. This contribution, named SCROOGEVM, leverages the detection of PM stability to carefully increase the associated oversubscription ratios. Based on metrics shared by public cloud providers, we investigate the impact of resource oversubscription on performance degradation. Subsequently, we conduct a comparative analysis of SCROOGEVM with state-ofthe- art oversubscription computations. The results demonstrate that our approach outperforms existing methods by leveraging the presence of long-lasting VMs, while avoiding live migration penalties and performance impacts for stakeholders.

Cloud providers generally expose a large catalog of Virtual Machine (VM) offers, some being categorized as premium-guaranteeing dedicated resources-and others being hosted in oversubscribed environments, where virtual resources can exceed the physical capabilities of Physical Machines (PMs). The latter strategy is often employed to increase platform utilization, as hosted VMs are unlikely to fully utilize all their allocated resources simultaneously [1]. However, managing multiple oversubscribed VM levels introduces an additional layer of complexity for Cloud providers, often leading them to provision isolated clusters of PMs for each category of offers. In this paper, we introduce SLACKVM, a novel Cloud-shared architecture wherein VMs from various oversubscription levels coexist on the same cluster of PMs. In particular, we demonstrate that oversubscription levels can be complementary, meaning they do not saturate the same resource components. By leveraging this complementarity, Cloud providers can couple multiple levels to better consolidate VM offers onto PMs, and reduce the size of their clusters by up to 9.6%. These resource savings result in both an operational cost reduction and a reduced ecological footprint for Cloud infrastructures, with a limited impact on the Quality of Service (QoS).

Fog Computing is a paradigm decentralizing the Cloud by geographically distributing computation, storage, network resources and related services. It provides benefits such as reducing the number of bottlenecks, limiting unwanted data movements, etc. However, managing the size, complexity and heterogeneity of the Fog systems to be engineered is challenging and can quickly become costly. According to best practices in software engineering, verification tasks could be performed on a system design prior to its implementation and deployment. We propose a generic model-based approach for verifying Fog systems at design time, also enabling the automatic generation of corresponding deployment configuration files. Named VeriFog, this approach is notably based on a customizable Fog Modeling Language (FML). We experimented in practice by modeling three use cases, from three different application domains, and by considering three main types of non-functional properties to be verified. From this modeling and verification effort, we show that we are able to automatically generate usable deployment configuration files for different deployment tools. Indirect collaboration with our industrial partner Smile, the approach and underlying language presented in this paper are necessary steps towards a more global model-based support for the complete life cycle of Fog systems.

Due to the rapid growth of Cloud services, data centers have become major energy consumers, resulting in significant CO2 emissions. Several infrastructure-focused strategies, such as resource consolidation, have been used to reduce the carbon footprint of Cloud infrastructure. However, end-users are often left out of the picture. Since they are the primary target of Cloud applications, it would be beneficial to actively involve them in reducing the carbon footprint of Cloud applications. In this paper, we offer end-users a way to influence the carbon footprint of Cloud applications they use. To this end, we ask end-users to select a high-level mode to control the carbon footprint of a Cloud application. We then design a dynamic adaptation algorithm that determines an appropriate configuration for the application for each request, based on the end-user mode and on the carbon intensity of the infrastructure energy sources. We implement and evaluate our system on a simple image-resizing application. We run experiments on SeDuCe, a Cloud infrastructure testbed partially powered by solar panels. Our results show that we save energy consumption by up to 84% when all end-users agree to degrade the quality of the application's output, and we provide a good quality-energy trade-off when end-users make heterogeneous choices. In addition, we are able to improve quality by leveraging the available green energy budget.

The adoption of computing resources oversubscription in cloud environments is conventionally limited to a restricted subset of Virtual Machines (VMs) within the providers’ offerings, primarily driven by performance considerations. So far, VMs schedulers mostly implement all-or-nothing oversubscription strategies, wherein all VM resources are either oversubscribed or remain unaltered. While the former strategy offers higher consolidation rates, the latter delivers better performance guarantees.In this paper, we conducted an empirical study of the individual usage of virtual CPUs (vCPUs) in the OVHCloud production environment and we demonstrate that, as they are not uniformly utilized, the current holistic approach may not be appropriate. Based on these observations, we introduce a novel approach, named SweetspotVM, where oversubscription ratios are applied at the granularity of individual vCPU, instead of the whole VMs. This novel paradigm unlocks a more flexible oversubscription management strategy, pinning oversubscription ratios per vCPU within VMs. We present a prototype of SweetspotVM to illustrate the feasibility of accommodating multiple oversubscription levels within a single host and assigning them to individual vCPU.We assess the viability of our approach on a physical platform, demonstrating the possibility of dividing the cost of hosting VMs by 3, while maintaining the VMs performance at the level of non-oversubscribed platforms. We, therefore, believe that SweetspotVM opens new avenues to boost the consolidation of VMs on a reduced number of servers, with positive impacts on the environmental footprint of cloud computing.

Fog Computing is a new paradigm aiming at decentralizing the Cloud by geographically distributing away computation, storage and network resources as well as related services. In order to design, develop, deploy, maintain and evolve Fog systems, languages are required for properly modeling both their entities (e.g., infrastructures, topologies, resources configurations) and their specific features such as the locality concept, QoS constraints applied on resources (e.g., energy, data privacy, latency) and their dependencies, the dynamicity of considered workloads, the heterogeneity of both applications and devices, etc. This paper provides a detailed overview of the current state-of-the-art in terms of Fog modeling languages. We relied on our long-term experience in Cloud Computing and Cloud Modeling to contribute a feature model describing what we believe to be the most important characteristics of Fog modeling languages. We also performed a systematic scientific literature search and selection process to obtain a list of already existing Fog modeling languages. Then, we evaluated and compared these Fog modeling languages according to the characteristics expressed in our feature model. As a result, we discuss in this paper the main capabilities of these Fog modeling languages and propose a corresponding set of open research challenges in this area. We expect the presented work to be helpful to both current and future researchers or engineers working on/with Fog systems, as well as to anybody genuinely interested in Fog Computing or more generally in distributed systems.

Fog Computing is a paradigm aiming to decentralize the Cloud by geographically distributing away computation, storage and network resources as well as related services. This notably reduces bottlenecks and data movement. However, managing Fog resources is a major challenge because the targeted systems are large, geographically distributed, unreliable and very dynamic. Cloud systems are generally managed via centralized autonomic controllers automatically optimizing both application QoS and resource usage. To leverage the self-management of Fog resources, we propose to orchestrate a fleet of autonomic controllers in a decentralized manner, each with a local view of its own resources. In this paper, we present our SeMaFoR (Self-Management of Fog Resources) vision that aims at collaboratively operating Fog resources. SeMaFoR is a generic approach made of three cornerstones: an Architecture Description Language for the Fog, a collaborative and consensual decision-making process, and an automatic coordination mechanism for reconfiguration.

Cloud infrastructures are large-scale and complex platforms designed to host a wide diversity of applications and workloads. Given these complexity and scale factors, simulators and benchmarks are broadly adopted in vitro to study their behaviors, prototype new software components and heuristics, and evaluate their effective performances.However, both state-of-the-art simulations and benchmarks may suffer from a representativeness problem, as the reported results can vary depending on their input workloads. For example, a Infrastructure-as-a-Service (IaaS) platform aims to host Virtual Machines (VMs), whose characteristics (resource configurations, workload intensity, arrival/departure rate, etc.) can greatly differ depending on Cloud providers and public/private deployments. Addressing this IaaS representativeness thus requires Cloud providers to share production-scale datasets, which might be considered sensitive. Moreover, Simulations and benchmarks require a specific experiment scenario that cannot be easily generated from Cloud providers characteristics.To address these issues, this paper introduces CloudFactory, a IaaS workload generator. Our contribution is first composed of a library that can be used by Cloud providers to share IaaS statistics, instead of raw datasets. Then, we introduce a generator designed to produce realistic VM workloads that match these statistics. CloudFactory is made available as open-source software that can be adopted by Cloud providers and researchers to foster the evaluation of new contributions.As an example, we perform an analysis on scheduling evolution for different IaaS workload intensity of two different Cloud providers: Microsoft Azure and Chameleon. We also report on OVHcloud statistics computed from CloudFactory and compare them to other Cloud providers.

Digital twins have been a trending concept in recent years. As a result, the number of digital twins has been steadily growing, and their reuse and composition are open questions. For example, The Thing In The Future (Thing'In) platform gives the possibility to represent a complex system as a Property Graph of Digital Twins (DT)s. However, the representation of the graph hinders understanding of the system and raises the question of modeling more complex digital twins and synchronizing the graph with the system it represents. In this paper, we propose an approach for creating Composite Digital Twins (CDT)s of complex systems based on a graph of Digital Twins (DT)s. The approach is articulated between a Data Plane (DP) which hosts the graph representation of a complex system and a Control Plane (CP) that synchronizes the DP and the Physical Plane (PP) hosting the complex system. In our solution, we provide mechanisms to create user-defined CDTs that are a composition of other DTs. We also propose transparent mechanisms to ensure the synchronisation of CDTs with the physical world. We explain the main steps of our approach illustrated by an example and discuss possible use cases.

A rich ecosystem of blockchain-based projects has emerged since the introduction of Bitcoin in 2008. New protocols seek to improve the performances of blockchain systems. In particular, the energy consumption of blockchains has been particularly decried. Unfortunately, those new proposals are often evaluated with ad hoc tools and experimental environments. Therefore, reproducibility and comparison of these new contributions with the state of the art of blockchain technologies are complicated. To the best of our knowledge, only a few tools partially address the design of a generic benchmarking of blockchain technologies (e.g., load generation). This paper introduces BCTMark, a generic framework for benchmarking blockchain technologies on an emulated network in a reproducible way. Based on this novel framework, we studied a key aspect of modern blockchains’ energy consumption: smart-contract execution. Based on experiments and the analysis of one year of real-world Ethereum transactions, we measured and modeled smart-contracts’ energy consumption on Ethereum. Furthermore, this study details how the replication of contract calls execution can impact their energy cost. In particular, we give insights on the energy consumed by smart-contracts on Ethereum over one year.

Smart contracts, scripts at the heart of blockchain-based applications, are meant to be available forever once deployed. However, this property has a price. The amount of space required to store new contracts keeps increasing. This increase impacts each participating node's performance and makes it inconvenient for low-end devices to participate in the network. Among all contracts deployed in the blockchain, a vast majority will lead to little if any usage. We demonstrate that, in the course of one year, 70 % of deployed contracts lead to no use. Unfortunately, unused contracts keep occupying space on the blockchain. To tackle this issue, we propose a new protocol to identify and delete unused contracts. Through simulation, based on Ethereum historical data, we show that deletion of smart contracts after an inactivity period of 90 days could lead to a 66 % reduction in the number of contracts stored over a year.

Over the last years, research activities on blockchain technologies have fairly increased. Firstly introduced with Bitcoin, some projects have since emerged to create or improve blockchain features like privacy while others propose to overcome technical limitations such as scalability and energy consumption. New proposals are often evaluated with ad hoc tools and experimental environments. Reproducibility and comparison of these new contributions with the state of the art of the blockchain technologies are therefore complicated. To the best of our knowledge, only a few tools partially address the design of a generic benchmarking of blockchain technologies (e.g., load generation). In this paper, we introduce BCTMark, a generic framework for benchmarking blockchain technologies on an emulated network in a reproducible way. To illustrate the portability of experiments using BCTMark, we have conducted some experiments on two different testbeds: a cluster of Dell PowerEdge R630 servers (Grid'5000) and one of Raspberry Pi 3+. Experiments have been conducted on three different blockchain systems (Ethereum Clique/Ethash and Hyperledger Fabric) to measure their CPU consumption and energy footprint for different numbers of clients.

Fog systems are a recent trend of distributed computing having vastly ubiquitous architectures and distinct requirements making their design difficult and complex. Fog computing is based on an idea that consists of leveraging both resource-scarce computing nodes around the Edge to perform latency and delay sensitive tasks and Cloud servers for the more intensive computation. A convenient way to address the challenge of designing Fog systems is through the use of formal methods, which provide the needed precision and high-level assurance for their specification through formal verification. In this paper, we present a novel formal model defining spatial and structural aspects of Fog-based systems using Bigraphical Reactive Systems, a fully graphical process algebraic formalism. The model is extended with reaction rules to represent the dynamic behavior of Fog systems in terms of self-adaptation. The notion of bigraph patterns is used in conjunction with boolean and temporal operators to encode spatio-temporal properties inherent to Fog systems and applications. The feasibility of the modelling approach is demonstrated via a motivating case study and various self-adaptation scenarios.