Traditional media is delivered using segmented video, with variable bitrates, over protocols such as MPEG-DASH. This works well for media experiences with a single, or very few, pre-produced variants. When the number of possible variants increases, however, it results in an explosion of pre-produced whole-experience videos in a one-per-variant relationship; this in turn causes high storage costs and poor re-use of otherwise separable media assets. The paradigm of object-based media (OBM) offers a solution by keeping media entities distinct after production, allowing them to be combined flexibly at the point of consumption. We examine the delivery and playback of OBM using a novel WebAssembly-based media player running in the browser. This approach allows the selective render offload of parts of an experience into the edge/cloud, by migrating associated code from the browser. Using three diverse exemplars of OBM we present a common meta-data format to capture flexible experiences, and measure the performance of our delivery pipeline in a range of on-device and offloaded scenarios. As far as we are aware this is the first such study of generalised OBM media delivery.

Genetic Improvement (GI) for software has been used in automated bug fixing and in automated performance improvement. Automated improvement has been targeted at multi-context problems, where one implementation variant might be best at one context, and another might be best at a different context. However, this application of GI generally requires a fresh improvement process for each new context, which can be computationally expensive. We propose a novel application of GI for multi-context problems, in which we aim for a diverse set of individuals in an initial training run for one context. We use a phenotypic speciation metric as a diversity indicator, allowing us to plot a diversity geometry through program search space. When a different context is introduced, as a new optimisation target for GI, we are able to select from one of these diverse individuals as a close starting point for fine-tuning. With a hash table implementation as an example to genetically improve, we show that we can exercise a high degree of control over population diversity, and that this diversity can be a useful starting point for finding individuals in successive alternative contexts.

This paper introduces Dynamic Bayesian Optimisation for Multi-Arm Bandits (DBO-MAB), an algorithm that dynamically adapts hyperparameters of multi-arm bandit algorithms using incremental Bayesian optimisation. DBO-MAB addresses the challenge of tuning hyperparameters in uncertain and dynamic environments, particularly for applications like web server optimisation. It uses a dynamic range adjustment approach based on the interquartile mean (IQM) of observed rewards to focus the search space on promising regions. Evaluated across diverse static and dynamic environments, DBO-MAB outperforms state-of-the-art algorithms such as Bootstrapped UCB and f-Discounted-Sliding-Window Thompson Sampling, reducing average response time by ≈55%.

Applications such as autonomous vehicles, virtual reality, augmented reality, and heavy machine learning-based applications are becoming popular and demanding more flexible deployment environments. The computing continuum, a hierarchical hybrid infrastructure comprehending user devices (smartphones, sensors, laptops, etc.), edge data centers, and cloud platforms, offers a wide range of deployment possibilities with a full range of varying computing resources. To take full advantage of such infrastructure, application development is faced with many challenges, the most important being the implementation of a transparent and generalized mechanism for code offloading and mobility throughout the continuum. To tackle such issues, this paper presents the Self-Distributing Systems (SDS) framework, a self-distribution framework that supports generalized code-offloading capabilities at the application level with a machine learning agent for deciding where to place components and a component-based model to enable seamless distribution of an application's components at runtime. We describe the framework, show its applicability in different application scenarios, and report our preliminary results. We conclude the paper with a list of challenges and invite the systems community to join the effort to further investigate them.

Genetic code improvement systems (GI) start from an existing piece of program code and search for alternative versions with better performance according to a metric of interest. The search space of source code is a large, rough fitness landscape which can be extremely difficult to navigate. Most approaches to enhancing search capability in this domain involve either novelty search, where low-fitness areas are remembered and avoided, or formal analysis which attempts to find high-utility parameterizations for the GI process. In this paper we propose the use of phylogenetic analysis over genetic history to understand how different mutations and crossovers affect the fitness of a population over time for a particular problem; we use the results of that analysis to tune a GI process during its operation to enhance its ability to locate better program candidates. Using phylogenetic analysis on 600 runs of a genetic improver targeting a hash function, we demonstrate how the results of this analysis yield tuned mutation types over the course of a GI process (dynamically and continually set according to individual's ancestors' ranks within the population) to give hash functions with over 20% improved fitness compared to a baseline GI process.

Digital agriculture, hailed as the fourth great agricultural revolution, employs software-driven autonomous agents for in-field crop management. Edge computing resources deployed near crop fields support autonomous agents with substantial computational needs for tasks such as AI inference. In large fields, using multiple autonomous agents, called swarms, can speed up crop management tasks if sufficient edge resources are provisioned. However, to use swarms today, farmers and software developers craft their own standalone solutions that are either simple and ineffective or complicated and hard-to-reproduce. We present MARbLE, a platform for developing and managing swarms. MARbLE provides an easy-to-use programming paradigm that helps users build swarm workloads using multi-agent reinforcement learning. Developers supply just two functions Map() and Eval(). The platform automatically compiles and deploys swarms and continuously updates the reinforcement learning models that govern their actions. Developers can experiment with multiple swarm and edge resource configurations both in simulation and with actual in-field runs. We studied real UAV swarms conducting digital agriculture missions. We observe that swarms demanded edge computing resources in bursts; the ratio of average to peak demand was 2.9X. MARbLE uses energy-saving load balancing policies to duty cycle machines during workload demand troughs, leveraging workload patterns to save edge energy. Using MARbLE, we found that four-agent swarms with load balancing techniques sped up missions by 2.1X and reduced edge energy usage by up to 2X compared to state of the art autonomous swarms.

Contemporary deployment environments are volatile, with conditions that are often hard to predict in advance, demanding solutions that are able to learn how best to design a system at runtime from a set of available alternatives. While the self-adaptive systems community has devoted significant attention to online learning, there is less research specifically directed towards learning for open-ended architectural adaptation - where individual components represent alternatives that can be added and removed dynamically. In this paper we present the Emergent Web Server (EWS), an architecture-based adaptive web server with 42 unique compositions of alternative components that present different utility when subjected to different workload patterns. This artefact allows the exploration of online learning techniques that are specifically able to consider the composition of logic that comprises a given system, and how each piece of logic contributes to overall utility. It also allows the user to add new components at runtime (and so produce new composition options), and to remove existing components; both are likely to occur in systems where developers (or automated code generators) deploy new code on a continuous basis and identify code which has never performed well. Our exemplar bundles together a fully-functional web server, a number of pre-packaged online learning approaches, and utilities to integrate, evaluate, and compare new online learning approaches.

Emergent software systems are assembled from a collection of small code blocks, where some of those blocks have alternative implementation variants; they optimise at run-time by learning which compositions of alternative blocks best suit each deployment environment encountered. In this paper we study the automated synthesis of new implementation variants for a running system using genetic improvement (GI) . Typical GI approaches, however, rely on large amounts of data for accurate training and large code bases from which to source genetic material. In emergent systems we have neither asset, with sparsely sampled runtime data and small code volumes in each building block. We therefore examine two approaches to more effective GI under these constraints: the synthesis of data from sparse samples to construct statistically representative larger training corpora; and the synthesis of code to counter the relative lack of genetic material in our starting population members. Our results demonstrate that a mixture of synthesised and existing code is a viable optimisation strategy, and that phases of increased synthesis can make GI more robust to deleterious mutations. On synthesised data, we find that we can produce equivalent optimisation compared to GI methods using larger data sets, and that this optimisation can produce both useful specialists and generalists.

Genetic programming (GP), for the synthesis of brand new programs, continues to demonstrate increasingly capable results towards increasingly complex problems. A key challenge in GP is how to learn from the past so that the successful synthesis of simple programs can feed into more challenging unsolved problems. Transfer Learning (TL) in the literature has yet to demonstrate an automated mechanism to identify existing donor programs with high-utility genetic material for new problems, instead relying on human guidance. In this article we present a transfer learning mechanism for GP which fills this gap: we use a Turing-complete language for synthesis, and demonstrate how a neural network (NN) can be used to guide automated code fragment extraction from previously solved problems for injection into future problems. Using a framework which synthesises code from just 10 input-output examples, we first study NN ability to recognise the presence of code fragments in a larger program, then present an end-to-end system which takes only input-output examples and generates code fragments as it solves easier problems, then deploys selected high-utility fragments to solve harder ones. The use of NN-guided genetic material selection shows significant performance increases, on average doubling the percentage of programs that can be successfully synthesised when tested on two different problem corpora, compared with a non-transfer-learning GP baseline.

The energy demands of modern mobile devices have driven a trend towards heterogeneous multi-core systems which include various types of core tuned for performance or energy efficiency, offering a rich optimization space for software. On such systems, data coherency between cores is automatically ensured by an interconnect between processors. On some chip designs the performance of this interconnect, and by extension of the entire CPU cluster, is highly dependent on the software's memory access characteristics and on the set of frequencies of each CPU core. Existing frequency scaling mechanisms in operating systems use a simple load-based heuristic to tune CPU frequencies, and so fail to achieve a holistically good configuration across such diverse clusters. We propose a new adaptive governor to solve this problem, which uses a simple trained hardware model of cache interconnect characteristics, along with real-time hardware monitors, to continually adjust core frequencies to maximize system performance. We evaluate our governor on the Exynos5422 SoC, as used in the Samsung Galaxy S5, across a range of standard benchmarks. This shows that our approach achieves a speedup of up to 40%, and a 70% energy saving, including a 30% speedup in common mobile applications such as video decoding and web browsing.

Energy usage in data centres continues to be a major and growing concern as an increasing number of everyday services depend on these facilities. Research in this area has examined topics including power smoothing using batteries and deep learning to control cooling systems, in addition to optimisation techniques for the software running inside data centres. We present a novel real-time power-cycling architecture, supported by a media distribution approach and online prediction model, to automatically determine when servers are needed based on demand. We demonstrate with experimental evaluation that this approach can save up to 31% of server energy in a cluster. Our evaluation is conducted on typical rack mount servers in a data centre testbed and uses a recent real-world workload trace from the BBC iPlayer, an extremely popular video on demand service in the UK.

Data analytic applications built upon big data processing frameworks such as Apache Spark are an important class of applications. Many of these applications are not latency-sensitive and thus can run as batch jobs in data centers. By running multiple applications on a computing host, task co-location can significantly improve the server utilization and system throughput. However, effective task co-location is a non-trivial task, as it requires an understanding of the computing resource requirement of the co-running applications, in order to determine what tasks, and how many of them, can be co-located. State-of-the-art co-location schemes either require the user to supply the resource demands which are often far beyond what is needed; or use a one-size-fits-all function to estimate the requirement, which, unfortunately, is unlikely to capture the diverse behaviors of applications.

Architectural self-organisation, in which different configurations of software modules are dynamically assembled based on the current context, has been shown to be an effective way for software to self-optimise over time. Current approaches to this rely heavily on human-led definitions: models, policies, and processes to control how self-organisation works. We present the case for a paradigm shift to fully emergent computer software that places the burden of understanding entirely into the hands of software itself. These systems are autonomously assembled at runtime from discovered constituent parts and their internal health and external deployment environment continually monitored. An online, unsupervised learning system then uses runtime adaptation to continuously explore alternative system assemblies and locate optimal solutions. Based on our experience over the past 3 years, we define the problem space of emergent software and present a working case study of an emergent web server as a concrete example of the paradigm. Our results demonstrate two main aspects of the problem space for this case study: that different assemblies of behaviour are optimal in different deployment environment conditions and that these assemblies can be autonomously learned from generalised perception data while the system is online.

Wireless Sensor Networks (WSN) are evolving beyond research prototypes towards real world deployments in various application domains. While prior research has resulted in a range of operating systems and associated programming languages, a comprehensive empirical analysis of WSN operating systems is missing from the literature. We address this problem through an empirical study of all actively maintained WSN operating systems for the popular Tmote Sky / TelosB platform: TinyOS, Contiki and Lorien. Our analysis considers overhead at each stage of the software life cycle. During the development phase, we measure developer effort in terms of lines of application code. During the execution phase we measure energy consumption, flash footprint and RAM usage. During the reconfiguration phase we measure artefact size and developer effort in terms of number of configuration commands. Our results indicate distinct trade-offs in terms of development effort, application performance and reconfiguration performance. We find that TinyOS performs best for static applications with tight RAM constraints, while Contiki offers the lowest development effort and Lorien performs best in dynamic applications which require reconfiguration.

Wireless sensor and actuator networks (WSANs) will increasingly require support for managed software evolution: that is, systematic, ongoing, efficient and nondisruptive means of updating the software running on the nodes of a WSAN. While aspects of this requirement have been examined in the literature, the big picture remains largely untouched, resulting in the generally static WSAN deployments we see today. In this article, we propose a comprehensive approach to managed software evolution. Our approach has the following key features: (i) it supports divergent evolution of the WSAN's software, such that different nodes can evolve along different lines (e.g., to meet the needs of different stakeholders, or to address localized adaptations) and (ii) it supports both instructed and autonomous evolution such that nodes can be instructed to change their software configuration or can evolve their own configuration (e.g., to manage rapidly-changing environmental conditions where remote micromanagement would be infeasible due to the high latency of the WSAN environment). We present the four intra-WSAN protocols that comprise our solution, along with an accompanying server-side infrastructure, and evaluate our approach at scale.

In this demo we show how the Lorien operating system [5] supports lightweight, efficient and safe online channges to any aspect of the software running on sensor nodes - and how this promotes reuse of deployed sensor networks through run-time software evolution.

In order to provide an increasing number of functionalities and benefit from sophisticated and application-tailored services from the network, distributed applications are led to integrate an ever-widening range of networking technologies. As these applications become more complex, this requirement for 'network heterogeneity' is becoming a crucial issue in their development. Although progress has been made in the networking community in addressing such needs through the development of network overlays, we claim in this paper that the middleware community has been slow to integrate these advances into middleware architectures, and, hence, to provide the foundational bedrock for heterogeneous distributed applications. In response, we propose our 'open overlays' framework. This framework, which is part of a wider middleware architecture, accommodates 'overlay plug-ins', allows physical nodes to support multiple overlays, supports the stacking of overlays to create composite protocols, and adopts a declarative approach to configurable deployment and dynamic reconfigurability. The framework has been in development for a number of years and supports an extensive range of overlay plug-ins including popular protocols such as Chord and Pastry. We report on our experiences with the open overlays framework, evaluate it in detail, and illustrate its application in a detailed case study of network heterogeneity.

Current approaches to flood monitoring (e.g. in river valleys) involve statically deploying depth and ultrasoundbased flow sensors across flood-prone areas, and feeding the collected data off-site (e.g. using GSM) to grid-based

We present and evaluate a generic approach to the repair of overlay networks which identifies general principles of overlay repair and embodies these as a reusable service. At the heart of our approach is an algorithm that discovers the extent of a failed section of any type of overlay, and assigns responsibility to carry out the repair. The repair strategy itself is 'pluggable' and can be tailored to the requirements of a specific overlay type or instance. Our approach is efficient in terms of the number of repair-related message exchanges it incurs; scalable in that it involves only nodes in the locality of the failed section of the overlay; and resilient in that it correctly handles cases in which multiple adjacent nodes fail simultaneously, and it tolerates new failures that occur while a repair is underway. The benefits of our approach are that: (i) it extracts and encapsulates best practice in repair for overlays; (ii) it simplifies the design and implementation of new overlays (because repair issues can be treated orthogonally to basic functionality); and (iii) it supports tailorable levels of dependability for overlays, including pluggable repair strategies

Abstract Significant progress has been made in the design and development of Grid middleware which, in its present form, is founded on Web services technologies. However, we argue that present‐day Grid middleware is severely limited in supporting projected next‐generation applications which will involve pervasive and heterogeneous networked infrastructures, and advanced services such as collaborative distributed visualization. In this paper we discuss a new Grid middleware framework that features (i) support for advanced network services based on the novel concept of pluggable overlay networks, (ii) an architectural framework for constructing bespoke Grid middleware platforms in terms of ‘middleware domains’ such as extensible interaction types and resource discovery. We believe that such features will become increasingly essential with the emergence of next‐generation e‐Science applications. Copyright © 2005 John Wiley & Sons, Ltd.