• FaaS@Edge is a decentralized Function-as-a-Service framework that leverages volunteer computing resources at the network edge, by combining Apache OpenWhisk and IPFS technologies. • The system achieves robust operational reliability across both function submissions and invocations while efficiently managing distributed edge node resources. • While introducing some initial submission overhead, the system maintains competitive execution speeds compared to local deployments and demonstrates efficient bandwidth usage that scales well with increasing nodes, also validated in scenarios with variable network conditions, and on actual edge devices. • The framework implements a flexible prosumer model where edge nodes can simultaneously provide and consume resources, enabling effective operation within edge device constraints. Function-as-a-Service (FaaS) emerges as a sophisticated cloud computing paradigm critically suited to processing the exponentially increasing data volumes generated by Internet of Things (IoT) infrastructures. Deploying computational models proximal to data generation sources addresses critical latency and bandwidth constraints inherent in edge-distributed applications. Edge computing environments present complex architectural challenges characterized by large-scale decentralized infrastructures and resource-constrained devices, which substantially impede contemporary Function-as-a-Service implementation strategies. This research introduces FaaS@Edge, a novel framework that leverages volunteered edge node resources discovered through the InterPlanetary File System (IPFS) network and deployed via Apache OpenWhisk. The proposed system addresses computational resource distribution challenges by enabling FaaS runtime deployments across heterogeneous edge infrastructure. Comprehensive experimental evaluation shows that FaaS@Edge introduces marginal latency during function submission while maintaining performance comparable to local OpenWhisk implementations. Empirical results demonstrate request success rates that approximate 98 % for function submission and invocation processes. These findings shows FaaS@Edge’s potential as an efficient computational model for edge computing environments, characterized by low-latency performance and optimized resource allocation.

• Introduces a novel checkpoint algorithm for divisible states, possibly larger-than-memory, named Progressive State Transfer, that partitions states into smaller components for faster, efficient fault recovery in large persistent systems. • Defines divisible state and state partition formally, proposing a generalized methodology and differential checkpoint algorithm for key-value stores, enabling customizable part sizes, and allowing distributing the recovery effort across all replicas. • Separates transfer process from checkpoint creation, allowing the development of application-specific partitioning methods using the proposed state transfer method for generic parts. • Analyzes and compares our algorithm experimentally with a nondivisible, i.e., the traditional approach, state algorithm, highlighting advantages, disadvantages, and suitable scenarios for each. Efficient recovery of replicas is a key but often overlooked practical requirement to make Byzantine Fault Tolerant State Machine Replication (BFT-SMR) systems viable for real world use. The state transfer part of recovery consists of transferring a checkpoint of the state and a log of operations executed after the checkpoint was created. Unlike the log, which is efficient to record, and often bounded, checkpoints grow according to the state size. Consequently, the transfer and creation of checkpoints can have increasingly negative impacts on system performance. In this paper, we introduce Progressive State Transfer, a checkpoint state transfer algorithm that is designed for divisible state applications. Along with this algorithm, we explore the concept of divisible state, presenting a differential checkpoint creation method that builds partitioned incremental checkpoints. Progressive state transfer receives small parts rather than a complete state, which allows us to reduce the amount of information transferred from other replicas. Moreover, it allows a recovering replica to gather parts in parallel from different replicas, further reducing recovery time and balancing effort across replicas. We also present a differential checkpoint algorithm, that only updates the parts of the state that changed since the last checkpoint; this enables checkpoints to be performed incrementally and thus can vastly reduce checkpoint times in sizable states, consequently minimizing the impact of checkpointing on overall throughput. In our analysis, we compare our approach to a traditional non-divisible checkpoint algorithm, examining the differences in performance. The findings indicate that progressive state transfer can lead to a significant reduction in state transfer time, achieving up to twelve times faster transfers under similar conditions. Additionally, the implementation of differential checkpoints shows improved performance, maintaining similar levels of performance in less optimal scenarios.

Function-as-a-Service has emerged as a trending paradigm that provides attractive solutions to execute fine-grained and short-lived workloads referred to as functions. Functions are typically developed in a managed language such as Java and execute atop a language runtime. However, traditional language runtimes such as the HotSpot JVM are designed for peak performance as considerable time is spent profiling and Just-in-Time compiling code. As a consequence, warmup time and memory footprint are impacted. We observe that FaaS workloads, which are short-lived, do not fit this profile.

Function-as-a-Service provides attractive solutions to execute fine-grained and short-lived functions. Functions are typically developed in a managed language and execute atop a language runtime. However, traditional runtimes are designed for peak performance as considerable time is spent profiling and Just-in-Time compiling code. We observe that short-lived FaaS workloads do not fit this profile.

The InterPlanetary File System (IPFS) is a hypermedia distribution protocol enabling the creation of completely distributed applications. One of the most efficient and effective ways to distribute information is through notifications, with a producer of content (publisher) sharing content with other interested parts (subscribers). IPFS already implements topic-based publish-subscribe systems under an experimental flag. The goal of this work is to advance on that, by developing a content-based pub-sub system (with subscriptions as predicates about event content) to disseminate information on top of IPFS in an efficient and decentralized way, leveraging its infrastructure. We design two protocols: ScoutSubs that is completely decentralized; FastDelivery that is centered in the publisher. With these two approaches, we show the different advantages of having each of these protocols simultaneously by comparing ScoutSubs’ full decentralization, and FastDelivery’s centralization at data sources.

The InterPlanetary File System (IPFS) is an hypermedia distribution protocol, addressed by content and identities. It aims to make the web faster, safer, and more open. The JavaScript implementation of IPFS runs on the browser, benefiting from the mass adoption potential that it yields. Startrail takes advantage of the IPFS ecosystem and strives to further evolve it, making it more scalable and performant through the implementation of an adaptive network caching mechanism. Our solution aims to add resilience to IPFS and improve its overall scalability, by avoiding overloading the nodes providing highly popular content, particularly during flash-crowd-like conditions where popularity and demand grow suddenly. We add a novel crucial key component to enable an IPFS-based decentralized Content Distribution Network (CDN). Following a peer-to-peer architecture, it runs on a scalable, highly available network of untrusted nodes that distribute immutable authenticated objects which are cached progressively towards the sources of requests.

Small-scale data centers at the edge are becoming prominent in offering various services to the end-users following the cloud model while avoiding the high latency inherent to the classic cloud environments when accessed from remote Internet regions. However, we should address several challenges to facilitate the end-users finding and consuming the relevant services from the edge at the Internet scale. First, the scale and diversity of the edge hinder seamless access. Second, a framework where researchers openly share their services and data in a secured manner among themselves and with external consumers over the Internet does not exist. Third, the lack of a unified interface and trust across the service providers hinder their interchangeability in composing workflows by chaining the services. Thus, creating a workflow from the services deployed on the various edge nodes is presently impractical. This paper designs Viseu, a latency-aware blockchain framework to provide Virtual Internet Services at the Edge. Viseu aims to solve the puzzle of network service discovery at the edge, considering the peers' reputation and latency when choosing the service instances. Viseu enables peers to share their computational resources, services, and data among each other in an untrusted environment, rather than relying on a set of trusted service providers. By composing workflows from the peers' services, rather than confining them to the pre-established service provider and consumer roles, Viseu aims to facilitate scientific collaboration across the peers natively. Furthermore, by offering services from multiple peers close to the end-users, Viseu also minimizes end-to-end latency and data loss in the service execution at the Internet scale.

Cloud providers host compute and storage resources used by multiple services. To be able to provide these services to millions of people with great reliability, large data centers are needed. However, some limitations of this centralized model are well known, such as bandwidth, because data has to be transferred from edge devices, and also latency, due to the distance between those data centers and personal devices. To overcome this, Edge Computing promotes computations or other types of operations on devices closer to users' personal devices. These devices have less power than data-centers but provide a shorter delay and as they are closer to end-users, data is immediately processed. Resources of these edge devices have the potential do host applications due to being underutilized. These applications can be allocated in various ways, voluntarily, or by exchange. This work focus on the trading process leading to the allocation of resources to an application. An auction-based trading algorithm is proposed, using an open-cry approach (i.e. all users knows the bids of others) and double side (i.e. buyers and sellers can bid and ask to a given item). The algorithm was implemented in a P2P overlay network and the Kademlia DHT. Results show a high success match rate, meaning all buyers found their respective sellers and vice-versa. Also, the memory consumption doesn't grow with the number of nodes that exist in the overlay.

The publish-subscribe paradigm is a wildly popular form of communication in complex distributed systems. The properties offered by it make it an ideal solution for a multitude of applications, ranging from social media to content streaming and stock exchange platforms. Consequently, a lot of research exists around it, with solutions ranging from centralised message brokers, to fully decentralised scenarios (peer to peer). Within the pub-sub realm not every solution is the same of course and trade-offs are commonly made between the ability to distribute content as fast as possible or having the assurance that all the members of the network will receive the content they have subscribed to. Delivery guarantees is something quite common within the area of centralised pub-sub solutions, there is, however, a clear lack of decentralised systems accounting for this. Specifically, a reliable system with the ability to provide message delivery guarantees and, more importantly, persistence guarantees. To this end, we present Pulsarcast, a decentralised, highly scalable, pub-sub, topic based system seeking to give guarantees that are traditionally associated with a centralised architecture, such as persistence and eventual delivery guarantees. The aim of Pulsarcast is to take advantage of the network infrastructure and protocols already in place. Relying on a structured overlay and a graph based data structure, we build a set of dissemination trees through which our events will be distributed. Our work also encompasses a software module that implements Pulsarcast, with our experimental results showing that is a viable and quite promising solution within the pub-sub and peer to peer ecosystem.

This paper presents Palpatine, the first in-memory application-level cache for Distributed Key-Value (DKV) data stores, capable of prefetching data that is likely to be accessed in an immediate future. To predict data accesses, Palpatine continuously captures frequent access patterns to the back store by means of data mining techniques. With these patterns, Palpatine builds a stochastic graph of accessed items, and makes prefetching decisions based on it. Experimental evaluation indicates that Palpatine can improve the latency of a specific DKV store by more that an order of magnitude.

Summary Sharing of computing resources and workload across different big data frameworks is challenging due to their lack of interoperable interfaces. In contrast, web services natively support an interoperable execution. Therefore, an increasing number of big data workflows are composed of data services and web service implementations that access and process big data. On the other hand, big data execution in the wide area networks needs to minimize latency and communication overheads to be able to scale seamlessly. Lack of network‐awareness of classic web service execution beyond data centers significantly challenges the scope of data services. Software‐Defined Networking (SDN) offers better control and management to the network, by unifying the control plane centrally, away from the distributed data plane devices. In this paper, we propose Software‐Defined Data Services (SDDS), an SDN‐based distributed service composition and workflow placement approach for data services in wide area networks. We first present the design of an SDDS framework that models the big data executions as composable data service workflows in multi‐domain network environments. We then evaluate the performance of a prototype SDDS framework through microbenchmarks. The benchmarks highlight the efficiency of SDDS in data service execution inside and beyond data centers.

Automatic human activity detection, mainly transport-wise, is very relevant for architects and urban planners (among many others) when designing cities, roads, public transportation systems, etc. Such detection allows to better plan our cities and has been made possible with the widespread use of smartphones carrying several different sensors. We developed edgeTrans, a system based on a smartphone application (app, for short), a database, and a server. The database stores the trips that were done, the server runs a machine learning algorithm that generates a model (i.e., a classifier) which is then integrated into the edgeTrans app. This app, after being installed, when running in a smartphone indicates the transport mode that is being used without requiring a network connection; it can now be downloaded from the Android Play Store or from the iOS iTunes (the app is called Woorti). The results obtained in a real-world setting are very encouraging taking into account the requirements (e.g., accuracy, and low cost).

Latency sensitive services such as credit-card fraud detection and website targeted advertisement rely on Big Data platforms which run on top of memory managed runtimes, such as the Java Virtual Machine (JVM). These platforms, however, suffer from unpredictable and unacceptably high pause times due to inadequate memory management decisions (e.g., allocating objects with very different lifetimes next to each other, resulting in severe memory fragmentation). This leads to frequent and long application pause times, breaking Service Level Agreements (SLAs). This problem has been previously identified, and results show that current memory management techniques are ill-suited for applications that hold in memory massive amounts of long-lived objects (which is the case for a wide spectrum of Big Data applications).

Community networks (CNs) have gained momentum in the last few years with the increasing number of spontaneously deployed WiFi hotspots and home networks. These networks, owned and managed by volunteers, offer various services to their members and to the public. While Internet access is the most popular service, the provision of services of local interest within the network is enabled by the emerging technology of CN micro-clouds. By putting services closer to users, micro-clouds pursue not only a better service performance, but also a low entry barrier for the deployment of mainstream Internet services within the CN. Unfortunately, the provisioning of these services is not so simple. Due to the large and irregular topology, high software and hardware diversity of CNs, a “careful” placement of micro-clouds services over the network is required to optimize service performance. This paper proposes to leverage state information about the network to inform service placement decisions, and to do so through a fast heuristic algorithm, which is critical to quickly react to changing conditions. To evaluate its performance, we compare our heuristic with one based on random placement in Guifi.net, the biggest CN worldwide. Our experimental results show that our heuristic consistently outperforms random placement by 2x in bandwidth gain. We quantify the benefits of our heuristic on a real live video-streaming service, and demonstrate that video chunk losses decrease significantly, attaining a 37% decrease in the packet loss rate. Further, using a popular Web 2.0 service, we demonstrate that the client response times decrease up to an order of magnitude when using our heuristic. Since these improvements translate in the QoE (Quality of Experience) perceived by the user, our results are relevant for contributing to higher QoE, a crucial parameter for using services from volunteer-based systems and adapting CN micro-clouds as an eco-system for service deployment.

To extract value from evergrowing volumes of data and to drive decision making, organizations frequently resort to the composition of data processing workflows. The typical workflow model enforces strict temporal synchronization across processing steps without accounting the actual effect of intermediate computations on the final workflow output. However, this is not the most desirable in a multitude of scenarios. We identify a class of applications for continuous data processing where the workflow output changes slowly and without great significance in a short time window, thus squandering compute resources with current approaches.

Community networks (CNs) have gained momentum in the last few years with the increasing number of spontaneously deployed WiFi hotspots and home networks. These networks, owned and managed by volunteers, offer various services to their members and to the public. To reduce the complexity of service deployment, community micro-clouds have recently emerged as a promising enabler for the delivery of cloud services to community users. By putting services closer to consumers, micro-clouds pursue not only a better service performance, but also a low entry barrier for the deployment of mainstream Internet services within the CN. Unfortunately, the provisioning of the services is not so simple. Due to the large and irregular topology, high software and hardware diversity of CNs, it requires of a "careful" placement of micro-clouds and services over the network. To achieve this, this paper proposes to leverage state information about the network to inform service placement decisions, and to do so through a fast heuristic algorithm, which is vital to quickly react to changing conditions. To evaluate its performance, we compare our heuristic with one based on random placement in Guifi.net, the biggest CN worldwide. Our experimental results show that our heuristic consistently outperforms random placement by 211% in terms of bandwidth gain. We quantify the benefits of our heuristic on a real live video-streaming service, and demonstrate that video chunk losses decrease significantly, attaining a 37% decrease in the loss packet rate. Further, using a popular Web 2.0 service, we demonstrate that the client response times decrease up to an order of magnitude when using our heuristic.

Internet access has become a requirement to participate in society; however, the majority of the world's population is not yet online. Citizens can self-organize cooperatively to crowdsource community network infrastructures and achieve Internet access. In order to help address that challenge, this paper provides an analysis of a crowdsourced Internet access mechanism: the distributed Web proxy service in one of the largest community networks in the world. Several perspectives were considered in this analysis, e.g., data traffic, networking issues, and proxies responsiveness. The evaluation results show how the current manual proxy choice, based on social clues, becomes a popular service plagued with hot spots and inefficiencies, which opens several opportunities for improving these infrastructures. By taking advantage of it, our research shows that the trade-offs between informed proxy selection and admission control in proxies, could alleviate imbalances and uncertainty, and also improve the service with little additional burden. This represents an explicit and direct mechanism for improving the service provided by these community networks, and a clear benefit for its members.

Citizens develop Wireless Mesh Networks (WMN) in many areas as an alternative or their only way for local interconnection and access to the Internet. This access is often achieved through the use of several shared web proxy gateways. These network infrastructures consist of heterogeneous technologies and combine diverse routing protocols. Network-aware state-of-art proxy selection schemes for WMNs do not work in this heterogeneous environment. We developed a client-side gateway selection mechanism that optimizes the client-gateway selection, agnostic to underlying infrastructure and protocols, requiring no modification of proxies nor the underlying network. The choice is sensitive to network congestion and proxy load, without requiring a minimum number of participating nodes. Extended Vivaldi network coordinates are used to estimate client-proxy network performance. The load of each proxy is estimated passively by collecting the Time-to-First-Byte of HTTP requests, and shared across clients. Our proposal was evaluated experimentally with clients and proxies deployed in guifi.net, the largest community wireless network in the world. Our selection mechanism avoids proxies with heavy load and slow internal network paths, with overhead linear to the number of clients and proxies.

Leveraging Software-Defined Networking (SDN) and middleboxes, application-level policies can be propagated to the network. SMART is an SDN middlebox architecture that differentiates network flows based on tenant inputs. By leveraging FlowTags software middlebox in addition to the OpenFlow rules, it supports a larger scope of tenant preferences and rules from the application layer to alter the network flow behaviour. It thus ensures timely delivery of priority flows by dynamically diverting them to a less congested path or even cloning the packets of higher priority flows along with the original flow.

Cloud networks are tested over simulation, emulation, and physical environments at different stages of development. Configuration management tools manage deployments and migrations across different cloud platforms, mitigating tedious system administration efforts. However, currently a cloud networking simulation cannot be migrated into an emulation, or vice versa, without rewriting and manually re-deploying the simulated application. This paper presents SENDIM, a Simulation, Emulation, aNd Deployment Integration Middleware for cloud networks. As an orchestration platform for incrementally building Software-Defined Cloud Networks (SDCN), SENDIM manages the development and deployment of algorithms and architectures the entire length from visualization, simulation, emulation, to physical deployments.

eScience consists of computation-intensive workflows executing on highly distributed networks. Service compositions aggregate web services to automate scientific and enterprise business processes. Along with the increased demand for data quality and Quality of Service (QoS) for an accurate outcome in a shorter completion time, execution of the eScience workflows and service compositions are also required to be distributed efficiently across various geo-distributed nodes. This paper presents Mayan,1a Software-Defined Networking (SDN) based approach for service composition. Mayan i) facilitates an adaptive execution of scientific workflows, ii) offers a more efficient service composition by leveraging distributed execution frameworks, in addition to the traditional web service engines, and iii) enables a very large-scale reliable service composition by finding and consuming the current best-fit among the multiple implementations or deployments of the same service.

Seamless computing and service sharing in community networks (CNs) have gained momentum due to the emerging technology of community network micro-clouds (CNMCs). However, deploying and running services in CNMCs confront enormous challenges to cope with, such as the dynamic nature of micro-clouds, limited capacity of nodes and links, asymmetric quality of wireless links, geographic singularity based deployment model rather than network QoS based, etc. CNMCs have been increasingly used by network-intensive services which exchange significant amounts of data between nodes, therefore their performance heavily relies on the available bandwidth resource in a network. This paper proposes a novel bandwidth-aware service placement algorithm which aims to replace the current random placement adopted by Guifi.net. Our experimental results show that the proposed BASP algorithm consistently outperforms the random placement in Guifi.net by 35% regarding its bandwidth gain. More promisingly, as the number of services increases, the gain tends to increase accordingly.

Data centers offer computational resources with various levels of guaranteed performance to the tenants, through differentiated Service Level Agreements (SLA). Typically, data center and cloud providers do not extend these guarantees to the networking layer. Since communication is carried over a network shared by all the tenants, the performance that a tenant application can achieve is unpredictable and depends on factors often beyond the tenant's control. We propose ViTeNA, a Software-Defined Networking-based virtual network embedding algorithm and approach that aims to solve these problems by using the abstraction of virtual networks. Virtual Tenant Networks (VTN) are isolated from each other, offering virtual networks to each of the tenants, with bandwidth guarantees. Deployed along with a scalable OpenFlow controller, ViTeNA allocates virtual tenant networks in a work-conservative system. Preliminary evaluations on data centers with tree and fat-tree topologies indicate that ViTeNA achieves both high consolidation on the allocation of virtual networks and high data center resource utilization.

In this paper we propose a task based load distribution framework for Massively Multiplayer Online Games running in hybrid cloud environments. Our solution breaks down high level tasks into subtasks in such a way that i) core subtasks (those with strong timing constraints) are executed at private resources owned by game operators; while ii) background subtasks (those with looser timing/reliability constraints) can be offloaded to temporary resources acquired from a public cloud. Our approach is lightweight and allows for faster deployment of newly acquired servers, making it more suitable for temporary overload situations. We present evaluation results confirming our solution as a viable alternative to traditional strategies.

Data-intensive and long-lasting applications running in the form of workflows are being increasingly dispatched to cloud computing systems. Current scheduling approaches for graphs of dependencies fail to deliver high resource efficiency while keeping computation costs low, especially for continuous data processing workflows, where the scheduler does not perform any reasoning about the impact new input data may have in the workflow final output. To face such a challenge, we introduce a new scheduling criterion, Quality-of-Data (QoD), which describes the requirements about the data that are worthy of the triggering of tasks in workflows. Based on the QoD notion, we propose a novel service-oriented scheduler planner, for continuous data processing workflows, that is capable of enforcing QoD constraints and guide the scheduling to attain resource efficiency, overall controlled performance and task prioritization. To contrast the advantages of our scheduling model against others, we developed WaaS (Workflow-as-a-Service), a workflow coordinator system for the Cloud where data is shared among tasks via cloud columnar database.

Summary Community networks are self‐organized and decentralized communication networks built and operated by citizens, for citizens. The consolidation of today's cloud technologies offers now, for community networks, the possibility to collectively develop community clouds, building upon user‐provided networks and extending toward cloud services. Cloud storage, and in particular secure and reliable cloud storage, could become a key community cloud service to enable end‐user applications. In this paper, we evaluate in a real deployment the performance of Tahoe least‐authority file system (Tahoe‐LAFS), a decentralized storage system with provider‐independent security that guarantees privacy to the users. We evaluate how the Tahoe‐LAFS storage system performs when it is deployed over distributed community cloud nodes in a real community network such as Guifi.net. Furthermore, we evaluate Tahoe‐LAFS in the Microsoft Azure commercial cloud platform, to compare and understand the impact of homogeneous network and hardware resources on the performance of the Tahoe‐LAFS. We observed that the write operation of Tahoe‐LAFS resulted in similar performance when using either the community network cloud or the commercial cloud. However, the read operation achieved better performance in the Azure cloud, where the reading from multiple nodes of Tahoe‐LAFS benefited from the homogeneity of the network and nodes. Our results suggest that Tahoe‐LAFS can run on community network clouds with suitable performance for the needed end‐user experience. Copyright © 2015 John Wiley & Sons, Ltd.

Cloud SLAs compensate customers with credits when average availability drops below certain levels. This is too inflexible because consumers lose non-measurable amounts of performance being only compensated later, in next charging cycles. We propose to schedule virtual machines (VMs), driven by range-based non-linear reductions of utility, different for classes of users and across different ranges of resource allocations: partial utility. This customer-defined metric, allows providers transferring resources between VMs in meaningful and economically efficient ways. We define a comprehensive cost model incorporating partial utility given by clients to a certain level of degradation, when VMs are allocated in overcommitted environments (Public, Private, Community Clouds). CloudSim was extended to support our scheduling model. Several simulation scenarios with synthetic and real workloads are presented, using datacenters with different dimensions regarding the number of servers and computational capacity. We show the partial utility-driven driven scheduling allows more VMs to be allocated. It brings benefits to providers, regarding revenue and resource utilization, allowing for more revenue per resource allocated and scaling well with the size of datacenters when comparing with an utility-oblivious redistribution of resources. Regarding clients, their workloads' execution time is also improved, by incorporating an SLA-based redistribution of their VM's computational power.

Community networks are decentralized communication networks built and operated by citizens, for citizens. We consider service discovery for clouds in such community networks. The currently employed solutions for service discovery are static and are not able to follow the dynamics in cloud service provision. We propose a novel service discovery mechanism based on the common Linux tool Avahi combined with TincVPN, in which the VPN allows Avahi to reach nodes beyond the local link. The concept of the micro-cloud is introduced which contains the nodes reached with the extended broadcast domain of Avahi. We evaluate the performance of the proposed service discovery mechanism in a real community cloud deployment consisting of 25 geographically distributed nodes. In experiments with different settings and number of services, we measure the number of services discovered as a function of the discovery time. Our results show that while a client eventually discovers all the services, a significant time is needed to achieve a complete service discovery. The proposed mechanism therefore seems appropriate for the case of community clouds with many replicas of a sought service, where the fast discovery of just a few providers satisfies the requirements of a client. By applying standard Linux tools, an advantage of our solution is that it is by default available on most Linux distribution, which allows our solution to be easily used for real deployments.

Wireless community networks (CNs) are large-scale, self-organized and decentralized communication infrastructures built and operated by citizens for citizens. CN cloud infrastructures have been recently introduced to run services inside the network, without the need to consume them from the Internet. We have developed a Linux-based distribution code-named Cloudy, which fosters the service deployment and automation in CN clouds. In this paper, we present two ways provisioned by Cloudy to integrate the services and improve the user QoS in these clouds. First, we present a distributed service discovery mechanism that helps users with service quality metrics to choose the best service from a pool of instances. Second, we experiment with a live video streaming service deployed in CN environments, using more than 50 real CN nodes distributed across Europe for the evaluation. Our analysis shows that, tuning the vital parameters of this service as neighborhood peer selection strategy and source node dispersion strategy, improves the video streaming QoS in the CNs. Our results indicate that both ways help the user to experience improved service performance. Automated service selection, needed once the number of micro service providers becomes larger, is the next step that can be built upon our results.

Software-defined networking (SDN) increases the network programmability, promoting an effective development of networked systems of cloud scale. As the scale of the networks and systems is growing larger and larger with time, programmability of the systems and networks is researched intensively. Many emulators are proposed and implemented to emulate large and complex networks inside a single computer, or a cluster of computers in the research lab. However, the emulators lack the ability to represent large systems such as data center networks or content delivery networks. Many of the network algorithms and design choices can also be tested for their functionality and efficiency in a simulator environment. While network emulators and simulators exist, a generic network flow simulator that is easy to program a variety of highly distributed and gigantic systems is still lacking. This paper presents xSDN, an expressive simulator for dynamic network flows. Adhering to the principles of software-defined networking paradigm from the design, xSDN focuses to be lean, light-weight, easy to learn and configure, and efficient, that can simulate networks of a scale of million nodes within a few seconds.

Graph data stores are a popular choice for a number of applications: social networks, recommendation systems, authorization and control access, and more. Such data stores typically support both distribution and replication of vertexes across physical nodes.

A new era of High-Performance Computing has been coming about during the last decade. The overabundance of resources lying idle throughout the Internet, for long periods of time, calls for resource-sharing infrastructures operating in the settings of the Cluster, Grid, P2P and Cloud. Many organizations own grids, frequently underutilized, but impose several restrictions to their usage by outside users. Despite the already extensive study in the field of Grid and Cloud computing, no solution was ever successful in reaching out to typical home users and their resource-intensive commodity applications. This is especially lacking in an open environment with no cost and low access barriers (e.g. authentication, configuration). We propose C|$^3$|P, a comprehensive distributed cycle-sharing framework for enabling the sharing of computational resources in a decentralized and free computing cloud platform, across large-scale networks and thus improve the performance of commonly used applications. C|$^3$|P encompasses the following activities: application adaptation, job scheduling, resource discovery, reliability of job results and overlay network management. C|$^3$|P evaluation shows that any ordinary Internet user is able to easily and effectively take advantage of remote resources, namely CPU cycles, for their own benefit; or provide spare cycles to other users, getting incentives in return, in a free, yet fair and managed global infrastructure.

Energy consumption is increasing in the IT sector and a remarkable part of this energy is consumed in data centers. Numerous techniques have been proposed to solve the energy efficiency issue in cloud systems. Recently, there are some efforts to decentralize the cloud via distributing data centers in diverse geographical positions. In this paper, we elaborate on the energy consumption of different cloud architectures, from a mega-datacenter to a P2P-cloud that provides extreme decentralization in terms of datacenter size. P2P-cloud is defined as a set of commodity host machines, connected to each other to serve a community. Our evaluation results reveal the fact that the more decentralized the system is, the less energy may be consumed in the system. Studying the energy efficiency of P2P-cloud infrastructure shows that the additional system design complexity involved is warranted with improved energy-efficiency and better locality for some services. Our analysis indicates that such P2P-cloud outperforms the classic datacenter model as long as it meets the locality conditions, which are commonplace in communities. Moreover, we illustrate how much energy can be saved for MapReduce applications with a diverse range of specifications by switching to P2P-cloud.

Cloud Computing researches involve a tremendous amount of entities such as users, applications, and virtual machines. Due to the limited access and often variable availability of such resources, researchers have their prototypes tested against the simulation environments, opposed to the real cloud environments. Existing cloud simulation environments such as CloudSim and EmuSim are executed sequentially, where a more advanced cloud simulation tool could be created extending them, leveraging the latest technologies as well as the availability of multi-core computers and the clusters in the research laboratories. This research seeks to develop Cloud2Sim, a concurrent and distributed cloud simulator, extending CloudSim while exploiting the features provided by Hazel cast, Infinispan and Hibernate Search to distribute the storage and execution of the simulation.

Traditionally, commercial MMOGs are deployed on large privately owned server clusters with hundreds of computing devices linked through high bandwidth connections. In this scenario, the dynamic and unpredictable workload variability of MMOGs frequently leads to resources being under/over used with negative impact on playability and/or cost-effectiveness. In our research work, we see cloud computing as a fundamental approach to mitigate the problem of inefficient resource provisioning, due to its inherent elasticity properties. Thus, we propose a cloud-aware middleware for MMOGs, in which virtual machines obtained from cloud providers are added and removed from the system according to load changes observed at runtime. In this paper, we report on our first steps towards such an infrastructure.

This paper presents Rubah, the first dynamic software updating system for Java that: is portable, implemented via libraries and bytecode rewriting on top of a standard JVM; is efficient, imposing essentially no overhead on normal, steady-state execution; is flexible, allowing nearly arbitrary changes to classes between updates; and isnon-disruptive, employing either a novel eager algorithm that transforms the program state with multiple threads, or a novel lazy algorithm that transforms objects as they are demanded, post-update. Requiring little programmer effort, Rubah has been used to dynamically update five long-running applications: the H2 database, the Voldemort key-value store, the Jake2 implementation of the Quake 2 shooter game, the CrossFTP server, and the JavaEmailServer.

Cooperative editing applications enable geographically distributed users to concurrently edit a shared document space over a computer network. These applications present several technical challenges related to the scalability of the system and the promptness with which relevant updates are disseminated to the concerned users. This paper presents Cooperative Semantic Locality Awareness (CoopSLA), a consistency model for cooperative editing applications that is scalable and efficient with regards to user needs. In CoopSLA, updates to different parts of the document have different priorities, depending on the relative interest of the user in the region in which the update is performed; updates that are considered relevant are sent to the user promptly, while less important updates are postponed. As a result, the system makes a more intelligent usage of the network resources, since (1) it saves bandwidth by merging postponed updates and (2) it issues fewer accesses to the network resources as a result of both update merging and message aggregation. We have implemented a collaborative version of the open source Tex editor TexMaker using the CoopSLA approach. We present evaluation results that support our claim that CoopSLA is very effective regarding network usage while fulfilling user needs (e.g. ensuring that relevant updates are disseminated in time).

Given that data are replicated in multiple geo-graphically distributed data centers, and to meet the increasing requirements of distributed applications, many cloud data stores adopt eventual consistency and therefore allow to run data intensive operations under low latency. This comes at the cost of data staleness. In this work, we prioritize data replication based on a set of flexible data semantics that can best suit all types of Big Data applications, avoiding overloading both network and systems during large periods of disconnection or partitions in the network. Therefore, we integrated these data semantics into the core architecture of a well-known NoSQL data store (e.g., HBase), which leverages a three-dimensional vector-field mdel (i.e., regarding timeliness, number of pending updates and divergence bounds) to provision data selectively in an on-demand fashion to applications. This enhances the former consistency model by providing a number of required levels of consistency to different applications such as, social networks or ecommerce sites, where priority of updates also differ. In addition, our implementation of the model into HBase allows updates to be tagged and grouped atomically in logical batches, akin to transactions, ensuring atomic changes and correctness of updates as they are propagated.

Cloud platforms are becoming more prevalent in every computational domain, particularly in e-Science. A typical scientific workload will have a long execution time or be data intensive. Providing an execution environment for these applications, which belong to different tenants, has to deal with the horizontal scaling of execution flows (i.e. threads) and an effective allocation of resources that takes into account the effective progress made by each tenant. While this is trivial for Bag-of-Tasks and embarrassingly parallel jobs, it is hard for HPC single-process multi-threaded applications because they cannot be scaled up automatically just by adding more virtual machines to execute the workload. In this paper we present MengTian, a distributed execution environment or platform capable of addressing the issues above. It encompasses several extensions to the Java execution environment, ranging from middleware to the virtual machine code and libraries. Our Java-based platform provides a Single System Image abstraction supported by a Partially Global Address Space to transparently spawn threads across a cluster of machines. It monitors progress with different levels-of-detail and accounts and restricts resource consumption. The overall goal is to redistribute resources among different JVM instances, increasing the unitary outcome of the progress vs. resource usage ratio over time.

Memory management plays a vital role in modern virtual machines. Both system- and language-level VMs manage memory to give the illusion of a unbounded allocation space although the underlying physical resources are limited. One of the main challenges for memory management is the range of dynamic characteristics of the workloads. Researchers have developed a large body of work using different mechanisms and dynamic decision making to specialize the memory management system to specific workloads. This design can be considered as a control loop where sensors are monitored, decisions are made and actions are performed by actuators. Nevertheless as is common in systems research, improvement in one property is accomplished at the expense of some other property. In this work we survey different techniques for adaptive memory management expressed as a control loop. We propose to analyse memory management in virtual machines using three seemingly orthogonal characteristics: responsiveness (R), comprehensiveness (C) and intricateness (I). We then present the details of an extensible classification framework which emphasizes the tradeoffs of different approaches. Using this framework, some representative state of the art systems are evaluated showing inherent tensions between R, C and I.

Current clouds SLAs include compensation for customers (i.e. resource renters) with credits when average availability drops below a certain point. However, this credit scheme is too inflexible because consumers lose a non measurable quantity of performance and are only compensated later (i.e. in the next charging cycle). We propose to schedule cloud isolation and execution units, i.e. virtual machines (VMs), driven by the partial utility of applying a certain amount of resources (CPU, memory or bandwidth) to a given VM. This partial utility metric, specified by the customer, allows the provider to transfer resources between VMs. This is particularly relevant for private clouds where resources are not so abundant. We have defined a cost model that incorporates the partial utility the client gives to a certain level of depreciation when VMs are allocated in an over commit environment. CloudSim, a state of the art cloud simulator, was extended to support our partial utility-driven scheduling model. Using simulation scenarios with synthetic and real workloads, we show that our proposed scheduling strategy brings benefits to providers (i.e. revenue, resource utilization) and clients (i.e. workloads' execution time) by incorporating a SLA-based depreciation of computational power, allowing for more VMs to be allocated.

Community networks offer a shared communication infrastructure where communities of citizens build and own open networks. While the IP connectivity of the networking devices is successfully achieved, the number of services and applications available from within the community network is typically small and the usage of the community network is often limited to providing Internet access to remote areas through wireless links. In this paper we propose to apply the principle of resource sharing of community networks, currently limited to the network bandwidth, to other computing resources, which leads to cloud computing in community networks. Towards this vision, we review some characteristics of community networks and identify potential scenarios for community clouds. We simulate a cloud computing infrastructure service and discuss different aspects of its performance in comparison to a commercial centralized cloud system. We note that in community clouds the computing resources are heterogeneous and less powerful, which affects the time needed to assign resources. Response time of the infrastructure service is high in community clouds even for a small number of resources since resources are distributed, but tends to get closer to that of a centralized cloud when the number of resources requested increases. Our initial results suggest that the performance of the community clouds highly depends on the community network conditions, but has some potential for improvement with network-aware cloud services. The main strength compared to commercial cloud services, however, is that community cloud services hosted on community-owned resources will follow the principles of community network and will be neutral and open.

Resource management in Cloud Computing has been dominated by system-level virtual machines to enable the management of resources using a coarse grained approach, largely in a manner independent from the applications running on these infrastructures. However, in such environments, although different types of applications can be running, the resources are delivered equally to each one, missing the opportunity to manage the available resources in a more efficient and application driven way. So, as more applications target managed runtimes, high level virtualization is a relevant abstraction layer that has not been properly explored to enhance resource usage, control, and effectiveness. We propose a VM economics model to manage cloud infrastructures, governed by a quality-of-execution (QoE) metric and implemented by an extended virtual machine. The Adaptive and Resource-Aware Java Virtual Machine (ARA-JVM) is a cluster-enabled virtual execution environment with the ability to monitor base mechanisms (e.g. thread cheduling, garbage collection, memory or network consumptions) to assess application's performance and reconfigure these mechanisms in runtime according to previously defined resource allocation policies. Reconfiguration is driven by incremental gains in quality-of-execution (QoE), used by the VM economics model to balance relative resource savings and perceived performance degradation. Our work in progress, aims to allow cloud providers to exchange resource slices among virtual machines, continually addressing where those resources are required, while being able to determine where the reduction will be more economically effective, i.e., will contribute in lesser extent to performance degradation.

SUMMARY Object‐oriented programming languages presently are the dominant paradigm of application development (e.g., Java, .NET). Lately, increasingly more Java applications have long (or very long) execution times and manipulate large amounts of data/information, gaining relevance in fields related with e‐Science (with Grid and Cloud computing). Significant examples include Chemistry, Computational Biology and Bio‐informatics, with many available Java‐based APIs (e.g., Neobio). Often, when the execution of such an application is terminated abruptly because of a failure (regardless of the cause being a hardware of software fault, lack of available resources, etc.), all of its work already performed is simply lost, and when the application is later re‐initiated, it has to restart all its work from scratch, wasting resources and time, while also being prone to another failure and may delay its completion with no deadline guarantees. Our proposed solution to address these issues is through incorporating mechanisms for checkpointing and migration in a JVM. These make applications more robust and flexible by being able to move to other nodes, without any intervention from the programmer. This article provides a solution to Java applications with long execution times, by extending a JVM (Jikes research virtual machine) with such mechanisms. Copyright © 2011 John Wiley & Sons, Ltd.

The Internet has witnessed a steady and widespread increase in available idle computing cycles and computing resources in general. Such available cycles simultaneously allow and foster the increase in development of existing and new computationally demanding applications, driven by algorithm complexity, intensive data processing, or both. Available cycles may be harvested from several scenarios, ranging from college or office LANs, cluster, grid and utility or cloud computing infrastructures, to peer-to-peer overlay networks. Existing resource discovery protocols have a number of shortcomings for the existing variety of cycle sharing scenarios. They either (i) were designed to return only a binary answer stating whether a remote computer fulfills the requirements, (ii) rely on centralized schedulers (or coherently replicated) that are impractical in certain environments such as peer-to-peer computing, (iii) they are not extensible as it is impossible to define new resources to be discovered and evaluated or new ways to evaluate them. In this paper we present a novel, extensible, expressive, and flexible requirement specification algebra and resource discovery middleware. Besides standard resources (CPU, memory, network bandwidth,...), application developers may define new resource requirements and new ways to evaluate them. Application programmers can write complex requirements (that evaluate several resources) using fuzzy logic operators. Each resource evaluation (either standard or specially coded) returns a value between 0.0 and 1.0 stating the capacity to (partially) fulfill the requirement, considering client-specific utility depreciation (i.e., partial-utility, a downgraded measure of how the user assesses the available resources) and policies for combined utility evaluation. By comparing the values obtained from the various hosts, it is possible to precisely know which ones best fulfill each client's needs, regarding a set of required resources.

There have been a few proposals aiming at bridging the gap between institutional grid infrastructures (e.g., Globus-based), popular cycle-sharing applications (e.g., SETIQhome), and massively used decentralized P2P file-sharing applications. Nonetheless, no such infrastructure was ever successful in allowing, in a large-scale, home users to run popular desktop applications faster, by using spare cycles in other users' machines and, in return, donate their spare cycles to run other users' applications. We present a novel application and programming model that was designed to overcome some of the barriers to the deployment of a generic peer-to-peer grid infrastructure. In particular, we want to enable a trivial deployment in such infrastructures of existing applications that are in widespread use but do not currently exploit parallelism for improved performance. The model presented in this paper revolves around the concept of a Gridlet, a semantics-aware unit of workload division and computation off-load. A gridlet is a chunk of data associated with the operations to be performed on the data, and in many cases these operations consist of unmodified application binaries. Moreover, the concept of gridlet is also employed for resource management, and accounting of peer contribution. We believe this new concept, absent in other proposals, will significantly lower the barriers for exploiting parallel execution in popular applications, thus improving the chances of the gridlet model being widely adopted.

Programming distributed applications supporting data sharing is very hard. In most middleware platforms, programmers must deal with system-level issues for which they do not have the adequate knowledge, e.g., object replication, abusive resource consumption by mobile agents, and distributed garbage collection. As a result, programmers are diverted from their main task: the application logic. In addition, given that such system-level issues are extremely error-prone, programmers spend inumerous hours debugging. We designed, implemented, and evaluated a middleware platform called OBIWAN that releases the programmer from the above mentioned system-level issues. OBIWAN has the following distinctive characteristics: 1) allows the programmer to develop applications using either remote object invocation, object replication, or mobile agents, according to the specific needs of applications, 2) supports automatic object replication (e.g., incremental on-demand replication, transparent object faulting and serving, etc.), 3) supports distributed garbage collection of useless replicas, and 4) supports the specification and enforcement of history-based security policies well adapted to mobile agents needs (e.g., preventing abusive resource consumption).

The need for sharing is well known in a large number of distributed collaborative applications. These applications are difficult to develop for wide area (possibly mobile) networks because of slow and unreliable connections. For this purpose, we developed a platform called OBIWAN that: i) allows the application to decide, in run-time, the mechanism by which objects should be invoked, remote method invocation or invocation on a local replica, ii) allows incremental replication of large object graphs, iii) allows the creation of dynamic clusters of data, and iv) provides hooks for the application programmer to implement a set of application specific properties such as relaxed transactional support or updates dissemination. These mechanisms allow an application to deal with situations that frequently occur in a (mobile) wide-area network, such as disconnections and slow links: i) as long as objects needed by an application (or by an agent) are colocated, there is no need to be connected to the network, and ii) it is possible to replace, in run-time, remote by local invocations on replicas, thus improving the performance and adaptability of applications. The prototype is developed in Java, is very small and simple to use, the performance results are very encouraging, and existing applications can be easily modified to take advantage of OBIWAN.