The task of infectious disease contact tracing is crucial yet challenging, especially when meeting strict privacy requirements. Previous attempts in this area have had limitations in terms of applicable scenarios and efficiency. Our paper proposes a highly scalable, practical contact tracing system called PREVENT that can work with a variety of location collection methods to gain a comprehensive overview of a person's trajectory while ensuring the privacy of individuals being tracked, without revealing their plain text locations to any party, including servers. Our system is very efficient and can provide real-time query services for large-scale datasets with millions of locations. This is made possible by a newly designed secret-sharing based architecture that is tightly integrated into unique private space partitioning trees. Notably, our experimental results on both real and synthetic datasets demonstrate that our system introduces negligible performance overhead compared to traditional contact tracing methods. PREVENT could be a game-changer in the fight against infectious diseases and set a new standard for privacy-preserving location tracking.

Federated learning (FL) is a promising approach for edge/IoT-based distributed machine learning, where both privacy and bandwidth efficiency are essential. However, as time progresses, edge/IoT-based FL faces challenges such as unpredictable concept drift, leading to model performance degradation and the need for frequent retraining. To address these challenges, we propose a federated learning framework designed for heterogeneous IoT devices, capable of handling continuous data distribution changes while accounting for limited storage resources. Our framework introduces a server-side drift detection method to minimize bandwidth usage and optimize retraining times, conserving IoT device resources. We also present an efficient storage management strategy to mitigate catastrophic forgetting by selectively managing incoming data streams within device constraints. Additionally, we develop an exemplar-based online continual learning algorithm that leverages class prototypes in the deep feature space to further combat catastrophic forgetting. We evaluate our framework on image classification tasks using ImageNet and CIFAR-100 datasets across four model architectures, demonstrating significant improvements in adaptation to concept drift and long-term performance stability compared to baseline FL approaches.

The rapid evolution of digital technologies has given rise to the concept of Digital Twin, a dynamic, virtual representation of physical systems, processes, and environments. This special issue delves into the transformative potential of Digital Twins in the realm of future networks and emerging Internet of Things (IoT) applications. By integrating advanced simulation, real-time data analytics, and machine learning, Digital Twins offer unprecedented opportunities for optimizing network performance, enhancing predictive maintenance, and enabling smarter IoT solutions. The articles in this issue explore a variety of topics, including the development and implementation of Digital Twins for next-generation communication networks, the role of artificial intelligence in enhancing the fidelity and utility of Digital Twins, and the application of these technologies in diverse IoT domains such as smart cities, healthcare, industrial automation, and environmental monitoring. Emphasis is placed on innovative methodologies, case studies, and experimental results that highlight the practical benefits and challenges associated with deploying Digital Twins in real-world scenarios. Through this special issue, we aim to provide a comprehensive overview of the current state of research and development in Digital Twins, underscore the technological advancements driving their adoption, and discuss future directions and open research questions. This collection of works serves as a valuable resource for researchers, practitioners, and policymakers interested in harnessing the power of Digital Twins to revolutionize network infrastructures and IoT ecosystems.

The current extensive deployment of IoT devices, crucial for enhancing smart computing applications in diverse domains, necessitates the utilization of essential 5G features, notably network slicing, to ensure the provision of distinct and reliable services. However, the voluminous, dynamic, and varied nature of IoT traffic introduces complexities in network flow classification, traffic analysis, and the accurate determination of network requirements. These complexities pose a significant challenge in effectively provisioning 5G network slices across various applications. To address this, we propose an innovative approach for network traffic classification, comprising a pipeline that integrates Principal Component Analysis (PCA) with KMeans clustering and the Hellinger distance measure. The application of PCA as the initial step effectively reduces the dimensionality of the data while retaining most of the original information, which significantly lowers the computational demands for the subsequent KMeans clustering phase. KMeans, an unsupervised learning method, eliminates the labor-intensive and error-prone process of data labeling. Following this, a Hellinger distance-based recursive KMeans algorithm is employed to merge similar clusters, aiding in the determination of the optimal number of clusters. This results in final clustering outcomes that are both compact and intuitively interpretable, overcoming the inherent limitations of the traditional KMeans algorithm, such as its sensitivity to initial conditions and the requirement for manually specifying the number of clusters. An evaluation of our method using a real-world IoT dataset has shown that our pipeline can efficiently represent the dataset in three distinct clusters. The characteristics of these clusters can be readily understood and directly correlated with various types of network slices in the 5G network, demonstrating the efficacy of our approach in managing the complexities of IoT traffic for 5G network slice provisioning.

As Exascale computing becomes a reality, the energy needs of compute nodes in cloud data centers will continue to grow. A common approach to reducing this energy demand is to limit the power consumption of hardware components when workloads are experiencing bottlenecks elsewhere in the system. However, designing a resource controller capable of detecting and limiting power consumption on-the-fly is a complex issue and can also adversely impact application performance. In this paper, we explore the use of Reinforcement Learning (RL) to design a power capping policy on cloud compute nodes using observations on current power consumption and instantaneous application performance (heartbeats). By leveraging the Argo Node Resource Management (NRM) software stack in conjunction with the Intel Running Average Power Limit (RAPL) hardware control mechanism, we design an agent to control the maximum supplied power to processors without compromising on application performance. Employing a Proximal Policy Optimization (PPO) agent to learn an optimal policy on a mathematical model of the compute nodes, we demonstrate and evaluate using the STREAM benchmark how a trained agent running on actual hardware can take actions by balancing power consumption and application performance.

This paper introduces the Hyper-5G research project, which aims at developing and evaluating an experimental proof of concept of a cross-Atlantic Network Digital Twin for the future wireless mobile 5G and beyond (B5G). Hyper-5G project brings innovative capabilities to allow distributed twins to replicate the 5G IoT network infrastructure digitally. Hyper-5G project interconnects two geographically distributed edge-cloud infrastructures, i.e., Grid5000 in Europe and Chameleon cloud in the US, to assess the feasibility of deploying new 5G IoT services using the twin. Hyper-5G offers an open European platform to experiment with different IoT scenarios, ranging from smart agriculture to healthcare, connected cars, etc. In the USA, Hyper-5G deploys the DT Hub inside the Chameleon cloud, connected to CHI-Edge IoT testbed, to enable emulating real-world IoT scenarios such as connected robots, smart cities, and smart grids, etc.

The primary challenge facing cloud-based deep learning systems is the need for efficient orchestration of large-scale datasets with diverse data formats and provisioning of high-performance data loading capabilities. To that end, we present DLCache, a cloud-native dataset management and runtime-aware data-loading solution for deep learning training jobs. DLCache supports the low-latency and high-throughput I/O requirements of DL training jobs using cloud buckets as persistent data storage and a dedicated computation cluster for training. DLCache comprises four layers: a control plane, a metadata plane, an operator plane, and a multi-tier storage plane, which are seamlessly integrated with the Kubernetes ecosystem thereby providing ease of deployment, scalability, and self-healing. For efficient memory utilization, DLCache is designed with an on-the-fly and best-effort caching mechanism that can auto-scale the cache according to runtime configurations, resource constraints, and training speeds. DLCache considers both frequency and freshness of data access as well as data preparation costs in making effective cache eviction decisions that result in reduced completion time for deep learning workloads. Results of evaluating DLCache on the Imagenet-ILSVRC and LibriSpeech datasets under various runtime configurations and simulated GPU computation time experiments showed up to a 147.49% and 156.67% improvement in data loading throughput, respectively, compared to the popular PyTorch framework.

Industry 4.0 is leading factories to undergo a significant transformation, where automation is achieved through the use of modern smart technologies, such as 5G & beyond $(5 \mathrm{G}+)$ network and digital twins. Yet, many Industrial Internet of Things (IIoT) applications, including smart factories and robotic repair, present challenges in delivering dedicated and real-time network services between the physical world entities and their digital twins due to the different network requirements of each sub tasks of the applications. Although 5G+ networks can provide high-speed, low-latency, and reliable network services, managing and optimizing the network resources in real-time remains complex and time-consuming. To address these challenges, this paper proposes solutions to manage and optimize $5 \mathrm{G}+$ network resources in real-time, and deliver dynamic and real time network requirements of multi-task digital twin applications.

Many traditional high-performance computing applications including those that follow the Bulk Synchronous Parallel (BSP) communication paradigm are increasingly being deployed in cloud-native virtualized and multi-tenant container clusters. However, such a shared, virtualized platform limits the degree of control that BSP applications can have in effectively allocating resources. This can adversely impact their performance, particularly when stragglers manifest in individual BSP supersteps. Existing BSP resource management solutions assume the same execution time for individual tasks at every superstep, which is not always the case. To address these limitations, we present a dynamic resource management middleware for cloud-native BSP applications comprising a heuristics algorithm that determines effective resource configurations across multiple supersteps while considering dynamic workloads per superstep, and trading off performance improvements with reconfiguration costs. Moreover, we design dynamic programming and reinforcement learning approaches that can be used as pluggable strategies to determine whether and when to enforce a reconfiguration. Empirical evaluations of our solution show between 10% and 25% improvement in performance over a baseline static approach even in the presence of reconfiguration penalty.

Existing massive deployments of IoT devices in support of smart computing applications across a range of domains must leverage critical features of 5G, such as network slicing, to receive differentiated and reliable services. However, the voluminous, dynamic, and heterogeneous nature of IoT traffic imposes complexities on the problems of network flow classification, network traffic analysis, and accurate quantification of the network requirements, thereby making the provisioning of 5G network slices across the application mix a challenging problem. To address these needs, we propose a novel network traffic classification approach that consists of a pipeline that combines Principal Component Analysis (PCA), with KMeans clustering and Hellinger distance. PCA is applied as the first step to efficiently reduce the dimensionality of features while preserving as much of the original information as possible. This significantly reduces the runtime of KMeans, which is applied as the second step. KMeans, being an unsupervised approach, eliminates the need to label data which can be cumbersome, error-prone, and time-consuming. In the third step, a Hellinger distance-based recursive KMeans algorithm is applied to merge similar clusters toward identifying the optimal number of clusters. This makes the final clustering results compact and intuitively interpretable within the context of the problem, while addressing the limitations of traditional KMeans algorithm, such as sensitivity to initialization and the requirement of manual specification of the number of clusters. Evaluation of our approach on a real-world IoT dataset demonstrates that the pipeline can compactly represent the dataset as three clusters. The service properties of these clusters can be easily inferred and directly mapped to different types of slices in the 5G network.

Although machine learning (ML)-based models are increasingly being used by cloud-based data-driven services, two key problems exist when used at the edge. First, the size and complexity of these models hampers their deployment at the edge, where heterogeneity of resource types and constraints on resources is the norm. Second, ML models are known to be vulnerable to adversarial perturbations. To address the edge deployment issue, model compression techniques, especially model quantization, have shown significant promise. However, the adversarial robustness of such quantized models remains mostly an open problem. To address this challenge, this paper investigates whether quantized models with different precision levels can be vulnerable to the same universal adversarial perturbation (UAP). Based on these insights, the paper then presents a cloud-native service that generates and distributes adversarially robust compressed models deployable at the edge using a novel, defensive post-training quantization approach. Experimental evaluations reveal that although quantized models are vulnerable to UAPs, post-training quantization on the synthesized, adversarially-trained models are effective against such UAPs. Furthermore, deployments on heterogeneous edge devices with flexible quantization settings are efficient thereby paving the way in realizing adversarially robust data-driven cloud/edge services.

This paper addresses the challenges of delivering fine-grained Quality of Service (QoS) and communication determinism over 5G wireless networks for real-time and autonomous needs of Industrial Internet of Things (IIoT) applications while effectively sharing network resources. Specifically, this work presents DANSM, a software-defined, dynamic and autonomous network slice management middleware for 5G-based IIoT use cases, such as adaptive robotic repair. The novelty of our approach lies in (1) the use of multiple M/M/1 queues to formulate a 5G network resource scheduling optimization problem comprising service-level and system-level objectives; (2) the design of a heuristics-based solution to overcome the NP-hard properties of this optimization problem, and (3) the implementation of a software-defined solution that incorporates the heuristics to dynamically and autonomously provision and manage 5G network slices that deliver predictable communications to IIoT use cases. Empirical studies evaluating DANSM on our testbed comprising a Free5GC-based core and UERANSIM-based simulations reveal that the software-defined DANSM solution can efficiently balance the traffic load in the data plane thereby reducing the end-to-end response time and improve the service performance by completing 34% more subtasks than a Modified Greedy Algorithm (MGA), 64% more subtasks than First Fit Descending (FFD) and 22% more subtasks than Best Fit Descending (BFD) approaches all while minimizing operational costs.

Ever since the commercial offerings of the Cloud started appearing in 2006, the landscape of cloud computing has been undergoing remarkable changes with the emergence of many different types of service offerings, developer productivity enhancement tools, and new application classes as well as the manifestation of cloud functionality closer to the user at the edge. The notion of utility computing, however, has remained constant throughout its evolution, which means that cloud users always seek to save costs of leasing cloud resources while maximizing their use. On the other hand, cloud providers try to maximize their profits while assuring service-level objectives of the cloud-hosted applications and keeping operational costs low. All these outcomes require systematic and sound cloud engineering principles. The aim of this paper is to highlight the importance of cloud engineering, survey the landscape of best practices in cloud engineering and its evolution, discuss many of the existing cloud engineering advances, and identify both the inherent technical challenges and research opportunities for the future of cloud computing in general and cloud engineering in particular.

The growing number of data- and latency-sensitive Internet of Things (IoT) applications is posing significant challenges for the edge and cloud deployment of publish/subscribe services, which are required by these applications. Two independently developed technologies show promise in addressing these challenges. First, Kubernetes (K8s) provides a de-facto standard for container orchestration that can manage and scale distributed applications in the cloud. Second, OMG's Data Distribution Service (DDS), a standardized real-time, data-centric and peer-to-peer publish/subscribe middleware, is being used in thousands of critical systems around the world. However, the feasibility of running DDS applications within K8s for latency-sensitive edge computing, and specifically the performance overhead of K8s' network virtualization on DDS applications is not yet well-understood. To address this, in this paper we evaluate the performance overhead of several container network interface (CNI) plugins including Flannel, WeaveNet and Kube-Router installed on a hybrid (ARM+AMD) edge/cloud K8s cluster. The paper reports results from a comprehensive set of experiments conducted to measure and analyze the performance (throughput, latency, and CPU/memory usage) of containerized DDS applications from the perspectives of virtualization overhead, reliability (DDS Reliable and BestEffort QoS), transport mechanisms (UDP unicast and multicast), and security. The insights derived from this study provide concrete guidance to developers of DDS-based applications in choosing the right virtual network plugin and configurations when hosting their real-time IoT applications in real-world containerized environments.

The supervisory control and data acquisition (SCADA) network in a smart grid requires to be reliable and efficient to transmit real-time data to the controller, especially when the system is under contingencies or cyberattacks. Introducing the features of software-defined networks (SDN) into a SCADA network helps in better management of communication and deployment of novel grid control operations. Unfortunately, it is impossible to transform the overall smart grid network to have only SDN-enabled devices overnight because of budget and logistics constraints, which raises the requirement of a systematic deployment methodology. In this article, we present a framework, named SDNSynth, that can design a hybrid network consisting of both legacy forwarding devices and programmable SDN-enabled switches. The design satisfies the resiliency requirements of the SCADA network, which are determined with respect to a set of pre-identified threat vectors. The resiliency-aware SDN deployment plan primarily includes the best placements of the SDN-enabled switches (replacing the legacy switches). The plan may include one or more links to be installed newly to provide flexible or alternate routing paths. We design and implement the SDNSynth framework that includes the modeling of the SCADA topology, SDN-based resiliency measures, resiliency threats, mitigation requirements, the deployment budget, and other constraints. It uses satisfiability modulo theories (SMT) for encoding the synthesis model and solving it. We demonstrate SDNSynth on a case study of an example small-scale network. We also evaluate SDNSynth on different synthetic SCADA systems and analyze how different parameters impact each other. We simulate the SDNSynth suggested networks in a Mininet environment, which demonstrate the effectiveness of the deployment strategy over traditional networks and randomly deployed SDN switches in terms of packet loss and recovery time during network congestions.

Deep Learning (DL) model-based AI services are increasingly offered in a variety of predictive analytics services such as computer vision, natural language processing, speech recognition. However, the quality of the DL models can degrade over time due to changes in the input data distribution, thereby requiring periodic model updates. Although cloud data-centers can meet the computational requirements of the resource-intensive and time-consuming model update task, transferring data from the edge devices to the cloud incurs a significant cost in terms of network bandwidth and are prone to data privacy issues. With the advent of GPU-enabled edge devices, the DL model update can be performed at the edge in a distributed manner using multiple connected edge devices. However, efficiently utilizing the edge resources for the model update is a hard problem due to the heterogeneity among the edge devices and the resource interference caused by the colocation of the DL model update task with latency-critical tasks running in the background. To overcome these challenges, we present Deep-Edge, a load- and interference-aware, fault-tolerant resource management framework for performing model update at the edge that uses distributed training. This paper makes the following contributions. First, it provides a unified framework for monitoring, profiling, and deploying the DL model update tasks on heterogeneous edge devices. Second, it presents a scheduler that reduces the total re-training time by appropriately selecting the edge devices and distributing data among them such that no latency-critical applications experience deadline violations. Finally, we present empirical results to validate the efficacy of the framework using a real-world DL model update case-study based on the Caltech dataset and an edge AI cluster testbed.

A co-simulation may comprise several heterogeneous federates with diverse spatial and temporal execution characteristics. In an iterative time-stepped simulation, a federation exhibits the Bulk Synchronous Parallel (BSP) computation paradigm in which all federates perform local operations and synchronize with their peers before proceeding to the next round of computation. In this context, the lowest performing (i.e., slowest) federate dictates the progression of the federation logical time. One challenge in co-simulation is performance profiling for individual federates and entire federations. The computational resource assignment to the federates can have a large impact on federation performance. Furthermore, a federation may comprise federates located on different physical machines as is the case for cloud and edge computing environments. As such, distributed profiling and resource assignment to the federation is a major challenge for operationalizing the co-simulation execution at scale. This paper presents the Execution Performance Profiling and Optimization (EXPPO) methodology, which addresses these challenges by using execution performance profiling at each simulation execution step and for every federate in a federation. EXPPO uses profiling to learn performance models for each federate, and uses these models in its federation resource recommendation tool to solve an optimization problem that improves the execution performance of the co-simulation. Using an experimental testbed, the efficacy of EXPPO is validated to show the benefits of performance profiling and resource assignment in improving the execution runtimes of co-simulations while also minimizing the execution cost.

Complex simulation systems often comprise multiple distributed simulators that need to interoperate and synchronize states and events. In many cases, the simulation logics which are developed by different teams with specific expertise, need to be integrated to build a complete simulation system. Thus, supporting composability and reusability of simulation functionalities with minimal integration and performance overhead is a challenging but required capability. Middleware for game engines are promising to realize both the modular and reusable development criteria as well as the high performance requirements, while data-centric publish/subscribe middleware can support seamless integration and synchronization of the distributed artifacts. However, differences in the level of abstraction at which these middleware operate and the semantic differences in their underlying ontologies make it hard and challenging for simulation application developers and system integrators to realize a complete, operational system. To that end this paper presents a model-driven approach to blending the two middleware, wherein the modeling capabilities provide intuitive and higher-level abstractions for developers to reason about the composition and validation of the complete system, and the generative capabilities address the inherent and accidental complexities incurred in reconciling the semantic differences between the gaming and pub/sub middleware. We present a concrete implementation of our approach and illustrate its use and performance results using simple use cases.

Smart Internet of Things (IoT) applications require real-time and robust predictive analytics, which are based on Machine Learning (ML) models. Building ML models from Big Data is not only time-consuming, but developers often lack the needed expertise for feature engineering, parameter tuning, and model selection. The proliferation of ML libraries and frameworks, data ingestion tools, stream and batch processing engines, visualization techniques, and the range of available hardware platforms further exacerbates the system design, rapid development, and deployment problems. Finally, resource constraints of IoT require that the execution of the analytics engine be distributed across the cloud-edge spectrum. To overcome these daunting challenges, we present Stratum, which is an event-driven Big Data-as-a-Service offering for IoT analytics lifecycle management. Stratum provides users with an intuitive, declarative mechanism based on the principles of model-driven engineering to specify the application and infrastructure requirements. It automates the deployment via generative programming principles. This paper highlights the problems that Stratum resolves, demonstrating its capabilities using real-world case studies.

The supervisory control and data acquisition (SCADA) network in a smart grid requires to be reliable and efficient to transmit real-time data to the controller. Introducing SDN into a SCADA network helps in deploying novel grid control operations, as well as, their management. As the overall network cannot be transformed to have only SDN-enabled devices overnight because of budget constraints, a systematic deployment methodology is needed. In this work, we present a framework, named SDNSynth, that can design a hybrid network consisting of both legacy forwarding devices and programmable SDN-enabled switches. The design satisfies the resiliency requirements of the SCADA network, which are specified with respect to a set of identified threat vectors. The deployment plan primarily includes the best placements of the SDN-enabled switches. The plan may include one or more links to be installed newly. We model and implement the SDNSynth framework that includes the satisfaction of several requirements and constraints involved in resilient operation of the SCADA. It uses satisfiability modulo theories (SMT) for encoding the synthesis model and solving it. We demonstrate SDNSynth on a case study and evaluate its performance on different synthetic SCADA systems.

Services hosted in multi-tenant cloud platforms often encounter performance interference due to contention for non-partitionable resources, which in turn causes unpredictable behavior and degradation in application performance. To grapple with these problems and to define effective resource management solutions for their services, providers often must expend significant efforts and incur prohibitive costs in developing performance models of their services under a variety of interference scenarios on different hardware. This is a hard problem due to the wide range of possible co-located services and their workloads, and the growing heterogeneity in the runtime platforms including the use of fog and edge-based resources, not to mention the accidental complexities in performing application profiling under a variety of scenarios. To address these challenges, we present FECBench (Fog/Edge/Cloud Benchmarking), an open source framework comprising a set of 106 applications covering a wide range of application classes to guide providers in building performance interference prediction models for their services without incurring undue costs and efforts. Through the design of FECBench, we make the following contributions. First, we develop a technique to build resource stressors that can stress multiple system resources all at once in a controlled manner, which helps to gain insights into the impact of interference on an application's performance. Second, to overcome the need for exhaustive application profiling, FECBench intelligently uses the design of experiments (DoE) approach to enable users to build surrogate performance models of their services. Third, FECBench maintains an extensible knowledge base of application combinations that create resource stresses across the multi-dimensional resource design space. Empirical results using real-world scenarios to validate the efficacy of FECBench show that the predicted application performance has a median error of only 7.6% across all test cases, with 5.4% in the best case and 13.5% in the worst case.

Pre-trained deep learning models are increasingly being used to offer a variety of compute-intensive predictive analytics services such as fitness tracking, speech, and image recognition. The stateless and highly parallelizable nature of deep learning models makes them well-suited for serverless computing paradigm. However, making effective resource management decisions for these services is a hard problem due to the dynamic workloads and diverse set of available resource configurations that have different deployment and management costs. To address these challenges, we present a distributed and scalable deep-learning prediction serving system called Barista and make the following contributions. First, we present a fast and effective methodology for forecasting workloads by identifying various trends. Second, we formulate an optimization problem to minimize the total cost incurred while ensuring bounded prediction latency with reasonable accuracy. Third, we propose an efficient heuristic to identify suitable compute resource configurations. Fourth, we propose an intelligent agent to allocate and manage the compute resources by horizontal and vertical scaling to maintain the required prediction latency. Finally, using representative real-world workloads for an urban transportation service, we demonstrate and validate the capabilities of Barista.

Fog/'Edge computing is increasingly used to support a wide range of latency-sensitive Internet of Things (IoT) applications due to its elastic computing capabilities that are offered closer to the users. Despite this promise, IoT applications with user mobility face many challenges since offloading the application functionality from the edge to the fog may not always be feasible due to the intermittent connectivity to the fog, and could require application migration among fog nodes due to user mobility. Likewise, executing the applications exclusively on the edge may not be feasible due to resource constraints and battery drain. To address these challenges, this paper describes URMILA, a resource management middleware that makes effective tradeoffs between using fog and edge resources while ensuring that the latency requirements of the IoT applications are met. We evaluate URMILA in the context of a real-world use case on an emulated but realistic IoT testbed.

Elastic auto-scaling in cloud platforms has primarily used horizontal scaling by assigning application instances to distributed resources. Owing to rapid advances in hardware, cloud providers are now seeking vertical elasticity before attempting horizontal scaling to provide elastic auto-scaling for applications. Vertical elasticity solutions must, however, be cognizant of performance interference that stems from multi-tenant collocated applications since interference significantly impacts application quality-of-service (QoS) properties, such as latency. The problem becomes more pronounced for latency-sensitive applications that demand strict QoS properties. Further exacerbating the problem are variations in workloads, which make it hard to determine the right kinds of timely resource adaptations for latency-sensitive applications. To address these challenges and overcome limitations in existing offline approaches, we present an online, data-driven approach which utilizes Gaussian Processes-based machine learning techniques to build runtime predictive models of the performance of the system under different levels of interference. The predictive online models are then used in dynamically adapting to the workload variability by vertically auto-scaling co-located applications such that performance interference is minimized and QoS properties of latency-sensitive applications are met.

Big data medical image processing applications involving multi-stage analysis often exhibit significant variability in processing times ranging from a few seconds to several days. Moreover, due to the sequential nature of executing the analysis stages enforced by traditional software technologies and platforms, any errors in the pipeline are only detected at the later stages despite the sources of errors predominantly being the highly compute-intensive first stage. This wastes precious computing resources and incurs prohibitively higher costs for re-executing the application. The medical image processing community to date remains largely unaware of these issues and continues to use traditional high-performance computing clusters, which incur a high operating cost due to the use of dedicated resources and expensive centralized file systems. To overcome these challenges, this paper proposes an alternative approach for multi-stage analysis in medical image processing by using the Apache Hadoop ecosystem and offering it as a service in the cloud. We make the following contributions. First, we propose a concurrent pipeline execution framework and an associated semi-automatic, real-time monitoring and checkpointing framework that can detect outliers and achieve quality assurance without having to completely execute the expensive first stage of processing thereby expediting the entire multi-stage analysis. Second, we present a simulator to rapidly estimate the execution time for a given multi-stage analysis, which can aid the users in deciding the appropriate approach for their use cases. We conduct empirical evaluation of our framework and show that it requires 76.75% lesser wall time and 29.22% lesser resource time compared to the traditional approach that lacks such a quality assurance mechanism.

Effective management and provisioning of communication resources is as important in meeting the real-time requirements of smart city cyber physical systems (CPS) as managing computation resources is. The communication infrastructure in Smart cities often involves wireless mesh networks (WMNs). However, enforcing distributed and consistent control in WMNs is challenging since individual routers of a WMN maintain only local knowledge about each of its neighbors, which reflects only a partial visibility of the overall network and hence results in suboptimal resource management decisions. When WMNs must utilize emerging technologies, such as time-sensitive networking (TSN) for the most critical communication needs, e.g., controlling traffic and pedestrian lights, these challenges are further complicated. An attractive solution is to adopt Software Defined Networking (SDN), which offers a centralized, up-to-date view of the entire network by refactoring the wireless protocols into control and forwarding decisions. This paper presents ongoing work to overcome the key challenges and support the end-to-end real-time requirements of smart city CPS applications.

An emerging trend in Internet of Things (IoT) applications is to move the computation (cyber) closer to the source of the data (physical). This paradigm is often referred to as edge computing . If edge resources are pooled together, they can be used as decentralized shared resources for IoT applications, providing increased capacity to scale up computations and minimize end-to-end latency. Managing applications on these edge resources is hard, however, due to their remote, distributed, and (possibly) dynamic nature, which necessitates autonomous management mechanisms that facilitate application deployment, failure avoidance, failure management, and incremental updates. To address these needs, we present CHARIOT, which is orchestration middleware capable of autonomously managing IoT systems consisting of edge resources and applications. CHARIOT implements a three-layer architecture. The topmost layer comprises a system description language, the middle layer comprises a persistent data storage layer and the corresponding schema to store system information, and the bottom layer comprises a management engine that uses information stored persistently to formulate constraints that encode system properties and requirements, thereby enabling the use of satisfiability modulo theory solvers to compute optimal system (re)configurations dynamically at runtime. This article describes the structure and functionality of CHARIOT and evaluates its efficacy as the basis for a smart parking system case study that uses sensors to manage parking spaces.

Despite the widespread use of server virtualization technologies in cloud data centers, system administrators experience multiple challenges in configuring the hypervisor's scheduler parameters to optimize its performance. Manually tuning the scheduler's parameters is a common practice, however, this approach is not effective particularly when dealing with dynamically changing workload and resource utilizations on the host machines. This problem becomes even harder if cloud resources are overbooked while hosting both latency-sensitive and batched applications. To address these issues, this paper presents iTune, which is a framework for engineering the performance of a hypervisor intelligently via autonomous scheduler configurations. Concretely, iTune optimizes the Xen hypervisor's scheduler configuration parameters autonomously through a three phase process comprising: (1) Discoverer, which monitors and saves the resource usage history of the host machines and groups set of related host machine workloads, (2) Optimizer, where optimum Xen scheduler configuration parameters for each workload cluster are explored by employing a simulated annealing machine learning algorithm, and (3) Observer, where iTune monitors the resource usage of host machines online, classifies them into one of the categories found in the Discoverer phase, and loads the optimum scheduler parameters determined in the Optimizer phase. Experimental results validate our claims.

Fog computing has recently emerged as a new cyber foraging technique to offload resource-intensive tasks from mobile devices to mobile cloudlets in close proximity to endusers. Since the one-hop communication in the network edge is predominantly wireless, Wireless Mesh Networks (WMNs) are being considered to build wireless fog networks. However, WMNs use distributed hop-by-hop routing protocols to reflect a partial visibility of the network, which limits their ability to perform global network management and monitoring needed by fog networks. Software Defined Networking (SDN) provides a centralized control and management of the entire network, which makes it a good candidate to support fog communication. Unfortunately, the SDN OpenFlow protocol does not support any functionalities for wireless fog networks as it is primarily targeted to wired networks. To address these issues, this paper presents a SDN-enabled wireless fog architecture that combines both OpenFlow and distributed wireless protocols. The proposed solution provides lower latency and efficient load balancing to offload the network load by enabling programmable fog routers.

A large number of modern applications and systems are cloud-hosted, however, limitations in performance assurances from the cloud, and the longer and often unpredictable endto-end network latencies between the end user and the cloud can be detrimental to the response time requirements of the applications, specifically those that have stringent Quality of Service (QoS) requirements. Although edge resources, such as cloudlets, may alleviate some of the latency concerns, there is a general lack of mechanisms that can dynamically manage resources across the cloud-edge spectrum. To address these gaps, this research proposes Dynamic Data Driven Cloud and Edge Systems (D3CES). It uses measurement data collected from adaptively instrumenting the cloud and edge resources to learn and enhance models of the distributed resource pool. In turn, the framework uses the learned models in a feedback loop to make effective resource management decisions to host applications and deliver their QoS properties. D3CES is being evaluated in the context of a variety of cyber physical systems, such as smart city, online games, and augmented reality applications.

Large-scale medical imaging studies to date have predominantly leveraged in-house, laboratory-based or traditional grid computing resources for their computing needs, where the applications often use hierarchical data structures (e.g., NFS file stores) or databases (e.g., COINS, XNAT) for storage and retrieval. The resulting performance for laboratory-base approaches reveal that performance is impeded by standard network switches since they can saturate network bandwidth during transfer from storage to processing nodes for even moderate-sized studies. On the other hand, the grid may be costly to use due to the dedicated resources used to execute the tasks and lack of elasticity. With increasing availability of cloud-based Big Data frameworks, such as Apache Hadoop, cloud-based services for executing medical imaging studies have shown promise. Despite this promise, our preliminary studies have revealed that existing Big Data frameworks illustrate different performance limitations for medical imaging applications, which calls for new algorithms that optimize their performance and suitability for medical imaging. For instance, Apache HBase's load distribution strategy of region split and merge is detrimental to the hierarchical organization of imaging data (e.g., project, subject, session, scan, slice). To address these challenges, this doctoral research is developing a range of performance optimization algorithms. This paper describes preliminary research we have conducted in this realm and presents a list of research tasks that will be undertaken as part of this doctoral research.

Traditional in-house, laboratory-based medical imaging studies use hierarchical data structures (e.g., NFS file stores) or databases (e.g., COINS, XNAT) for storage and retrieval. The resulting performance from these approaches is, however, impeded by standard network switches since they can saturate network bandwidth during transfer from storage to processing nodes for even moderate-sized studies. To that end, a cloud-based "medical image processing-as-a-service" offers promise in utilizing the ecosystem of Apache Hadoop, which is a flexible framework providing distributed, scalable, fault tolerant storage and parallel computational modules, and HBase, which is a NoSQL database built atop Hadoop's distributed file system. Despite this promise, HBase's load distribution strategy of region split and merge is detrimental to the hierarchical organization of imaging data (e.g., project, subject, session, scan, slice). This paper makes two contributions to address these concerns by describing key cloud engineering principles and technology enhancements we made to the Apache Hadoop ecosystem for medical imaging applications. First, we propose a row-key design for HBase, which is a necessary step that is driven by the hierarchical organization of imaging data. Second, we propose a novel data allocation policy within HBase to strongly enforce collocation of hierarchically related imaging data. The proposed enhancements accelerate data processing by minimizing network usage and localizing processing to machines where the data already exist. Moreover, our approach is amenable to the traditional scan, subject, and project-level analysis procedures, and is compatible with standard command line/scriptable image processing software. Experimental results for an illustrative sample of imaging data reveals that our new HBase policy results in a three-fold time improvement in conversion of classic DICOM to NiFTI file formats when compared with the default HBase region split policy, and nearly a six-fold improvement over a commonly available network file system (NFS) approach even for relatively small file sets. Moreover, file access latency is lower than network attached storage.

Despite the known benefits of hosting cloud-based services, the longer and often unpredictable end-to-end network latencies between the end user and the cloud can be detrimental to the response time requirements of the interactive cloud-hosted applications. Existing efforts that exploit edge/fog technology to migrate services closer to clients in order to improve response times do not fully resolve this problem as they do not focus on performance and interference issues at the migrated locations. This paper proposes INDICES framework that addresses these limitations by providing a novel solution that determines when and to which MDC a service should be migrated to and thus provides the desired performance. Empirical results validating our claims are presented using a setup comprising a centralized cloud and MDCs composed of heterogeneous hardware.

Emerging smart services, such as indoor smart parking or patient monitoring and tracking in hospitals, incur a significant technical roadblock stemming primarily from a lack of cost-effective and easily deployable localization framework that impedes their widespread deployment. To address this concern, in this paper we present a low-cost, indoor localization and navigation system, which performs continuous and real-time processing of Bluetooth Low Energy (BLE) and IEEE 802.15.4a compliant Ultra-wideband (UWB) sensor data to localize and navigate the concerned entity to its desired location. Our approach depends upon fusing the two feature sets, using the UWB to calibrate the BLE localization mechanism.

With developing an affordable, easily accessible and scalable online CPS laboratory to promote CPS education system, we are faced with and focused on a number of cyber-physical challenges including the model design and simulation strategies. The authors provide a complete process to simulate a behavior of a user-design CPS conveyor system. The user-design model is sent to the background, treated offline, and extracted the simulation result and finally feedback to user as an animation. The solution approach has two main parts, as the aspect of the modeling work, complex domain-specific conveyor design are defined in the Generic Modeling Environment (GME), it can be mapped and transformed to the global grid, another domain-specific model, which contains only one kind of node with huge dimension so that all different species of components in complex model are mapped to the typical nodes in grid, and it is easy to operate and simulate the nodes in global grid to fit for the need when multiple experiments being mapped to the grid. In this work, we only concerned the scenario of one experiment. The transformation and mapping process is implemented through Graph Rewriting and Transformation. As a background simulation, the Robocodes code is automatically generated by GME interpreter from global grid and is applied to generate the path logic to transmit the package, according to the package type in each input ports. After acquiring the transmit speed and path, Robocode simulation outputs the coordinate and time information to generate the Java animation. The final Java animation will be feedback to the user side to see the result of package transmission flow.

As distributed systems become more complex, understanding the underlying algorithms that make these systems work becomes even harder. Traditional learning modalities based on didactic teaching and theoretical proofs alone are no longer sufficient for a holistic understanding of these algorithms. Instead, an environment that promotes an immersive, hands-on learning of distributed system algorithms is needed to complement existing teaching modalities. Such an environment must be flexible to support learning of a variety of algorithms. Moreover, since many of these algorithms share several common traits with each other while differing only in some aspects, the environment should support extensibility and reuse. Finally, it must also allow students to experiment with large-scale deployments in a variety of operating environments. To address these concerns, we use the principles of software product lines (SPLs) and model-driven engineering and adopt the cloud platform to design an immersive learning environment called the Playground of Algorithms for Distributed Systems (PADS). The research contributions in PADS include the underlying feature model, the design of a domainspecific modeling language that supports the feature model, and the generative capabilities that maximally automate the synthesis of experiments on cloud platforms. A prototype implementation of PADS is described to showcase a distributed systems algorithm illustrating a peer to peer file transfer algorithm based on BitTorrent, which shows the benefits of rapid deployment of the distributed systems algorithm.

Computation offloading or cyber foraging is a key capability required to achieve effective resource utilization in mobile cloud computing. It enables the dynamic offloading of computations to either neighboring mobile nodes or remote cloud based servers, retrieve results from the offloaded computations, and thereafter continue execution of the mobile business logic. A number of computational mobility solutions have emerged recently for mobile cloud computing involving smartphones and tablets. However, these solutions incur limitations in the context of Internet of Things (IoT) due to the significant heterogeneity illustrated by the range of objects involved in IoT and the fact that existing solutions tend to be tightly coupled to their underlying frameworks, which makes it hard to seamlessly adapt these solutions to the IoT scenarios. To address these concerns, this paper makes three contributions. First, it presents a novel modular and highly configurable framework for providing seamless computational mobility in the IoT realm. Second, it provides implementation details for key capabilities of this framework. Third, it provides qualitative evaluation of the framework's capabilities.

Wireless Sensor Networks (WSNs) are becoming a key enabling technology for Internet of Things (IoT) by virtue of providing a highly unstructured cloud of wireless devices. Despite these advances, the current Internet architecture is not able to cater to the high volume of new traffic patterns delivered by these smart sensing devices. In this context, Software Defined Networking (SDN) has emerged as an intelligent solution to deliver dramatic improvements in network programmability, agility and flexibility. However, SDN was originally targeted to wired networks deployed in cloud data centers, and does not lend itself well to WSNs due primarily to its higher footprint and lack of WSN programmable interfaces. To address these challenges, this paper describes an approach to realize software-defined wireless sensor networks by introducing a novel SDN-enabled architecture for WSNs that can be used for diverse IoT systems. Specifically, we propose new control plane services for supporting automatic topology discovery, sensor virtualization as well as managing network policies. Additionally, we introduce new customized SDN-enabled flow tables to meet the requirements of sensor network packets. Finally, we introduce a programmable MAC layer to support fine-grained flow processing.

Wireless Mesh Networks (WMNs) serve as a key enabling technology for various smart initiatives, such as Smart Power Grids, by virtue of providing a self-organized wireless communication superhighway that is capable of monitoring the health and performance of system assets as well as enabling efficient trouble shooting notifications. Despite this promise, the current routing protocols in WMNs are fairly limited, particularly in the context of smart initiatives. Additionally, managing and upgrading these protocols is a difficult and error-prone task since the configuration must be enforced individually at each router. Software-Defined Networking (SDN) shows promise in this regard since it enables creating a customizable and programmable network data plane. However, SDN research to date has focused predominantly on wired networks, e.g., in cloud computing, but seldom on wireless communications and specifically WMNs. This paper addresses the limitations in SDN for WMNs by allowing the refactoring of the wireless protocol stack so as to provide modular and flexible routing decisions as well as fine-grained flow control. To that end, we describe an intelligent network architecture comprising a three-stage routing approach suitable for WMNs in uses cases, such as Smart Grids, that provides an efficient and affordable coverage as well as scalable high bandwidth capacity. Experimental results evaluating our approach for various QoS metrics like latency and bandwidth utilization show that our solution is suitable for the requirements of mission-critical WMNs.

Defining provisioning requirements for software IT systems is still tedious and error-prone despite utilizing the latest declarative system provisioning tools because they require that a user should define not only the desired state of a system but also the complementary imperative process needed to provision the tasks in the proper order. To address these challenges, we propose Configuration-Oriented Planning scheme which enables the user to provision a system by defining the desired configuration of the system in a fully declarative manner. The configuration includes only a combination of pre-defined components and property settings of the components. Operational definitions including dependencies are not required because such definitions are encapsulated by the components in an abstract form and extracted according to the concrete configuration of the components. Our scheme generates a provisioning process from the dependency definitions using an artificial intelligence (AI) planning technique. This paper presents an outline of the configuration-oriented planning technique and details of the system configuration model. A result of an experiment evaluating the efficiency and effectiveness of our scheme on a case study is presented.

To improve reliability and performance of Software Defined Networking (SDN) architectures, a number of recent efforts have proposed a logically centralized but physically distributed controller design that overcomes the bottleneck introduced by a single physical controller. Despite these advances, two key problems still persist. First, the task of controlling the host network and the task of controlling the control-plane network remain tightly intertwined, which incurs unwanted complexity in the controller design. Second, the task of deploying the distributed controllers continues to be performed in a manual and static way. To address these two problems, this paper presents a novel approach called InitSDN to bootstrapping the distributed software defined network architecture and deploying the distributed controllers. InitSDN makes the SDN control plane design less complex, makes coordination among controllers flexible, provides additional reliability to the distributed control plane.

Wider adoption, availability and ubiquity of wireless networking technologies, integrated sensors, actuators, and edge computing devices is facilitating a paradigm shift by allowing us to transition from traditional statically configured vertical silos of Cyber-Physical Systems (CPS) to next generation CPS that are more open, dynamic and extensible. Fractionated spacecraft, smart cities computing architectures, Unmanned Aerial Vehicle (UAV) clusters are all examples of extensible CPS wherein extensibility is implied by the dynamic aggregation of physical resources, affect of physical dynamics on availability of computing resources, and various multi-domain applications hosted on these systems. However, realization of extensible CPS requires resolving design-time and runtime challenges emanating from properties specific to these systems. In this paper, we first describe different properties of extensible CPS - dynamism, extensibility, remote deployment, security, heterogeneity and resilience. Then we identify different design-time challenges stemming from heterogeneity and resilience requirements. We particularly focus on software heterogeneity arising from availability of various communication middleware. We then present appropriate solutions in the context of a novel domain specific language and describe how this language and its features have evolved from our past work.

Cloud service providers (CSPs) often overbook their resources with user applications despite having to maintain service-level agreements with their customers. Overbooking is attractive to CSPs because it helps to reduce power consumption in the data center by packing more user jobs in less number of resources while improving their profits. Overbooking becomes feasible because user applications tend to overestimate their resource requirements utilizing only a fraction of the allocated resources. Arbitrary resource overbooking ratios, however, may be detrimental to soft real-time applications, such as airline reservations or Netflix video streaming, which are increasingly hosted in the cloud. The changing dynamics of the cloud preclude an offline determination of overbooking ratios. To address these concerns, this paper presents iOverbook, which uses a machine learning approach to make systematic and online determination of overbooking ratios such that the quality of service needs of soft real-time systems can be met while still benefiting from overbooking. Specifically, iOverbook utilizes historic data of tasks and host machines in the cloud to extract their resource usage patterns and predict future resource usage along with the expected mean performance of host machines. To evaluate our approach, we have used a large usage trace made available by Google of one of its production data centers. In the context of the traces, our experiments show that iOverbook can help CSPs improve their resource utilization by an average of 12.5% and save 32% power in the data center.

A change process in already deployed system requires its components to step through a few temporary states before they reach their desired states, however, most prevalent IT resource management tools seldom assume such temporary states. Therefore, the tools are not applicable to the change management of already deployed systems, particularly those that consist of hardware components. This paper addresses the above concerns and describes a model-based management scheme for changing IT systems including the hardware resources. Our approach automatically generates the required tasks to apply changes from a desired state model with staterelated dependencies between the resources. The contributions of the paper include: (1) a simple base methodology of task planning for system changes with our desired state model, (2) a component-based system model to define desired states in largescale systems, and (3) enhancement of task planning scalability for a number of managed resources. We present specifications to define a system change efficiently with two versions of state models: current state and desired state. We evaluate the effectiveness of our system change definition scheme through case studies and validate the scalability of our approach by measuring the processing time of task planning.

Power and performance tradeoffs are critical and challenging issues faced by cloud service providers (CSPs) while managing their data centers. On the one hand, CSPs strive to reduce power consumption of their data centers to not only decrease their energy costs but to also reduce adverse impact on the environment. On the other hand, CSPs must deliver performance expected by the applications hosted in their cloud in accordance with predefined Service Level Agreements (SLAs). Not doing so will lead to loss of customers and thereby major revenue losses for the CSPs. Addressing these dual set of challenges is hard for the CSPs because power management and performance assurance are conflicting objectives, particularly in the context of multi-tenant cloud systems where multiple virtual machines (VMs) may be hosted on a single physical server. The problem becomes even harder when real-time applications are hosted in these VMs. To address these challenges and make appropriate tradeoffs, we present iPlace, which is an intelligent and tunable power- and performance-aware VM placement middleware. The placement strategy is based on a two-level artificial neural network which predicts (1) CPU usage at the first level, and (2) power consumption and performance of a host machine at the second level that uses the predicted CPU usage. The efficacy of iPlace is evaluated in the context of a VM consolidation algorithm that is applied to running virtual machines and host machines in a private cloud.

The Object Management Group's (OMG) Data Distribution Service (DDS) provides many configurable policies which determine end-to-end quality of service (QoS) of applications. It is challenging to predict the system's performance in terms of latencies, throughput, and resource usage because diverse combinations of QoS configurations influence QoS of applications in different ways. To overcome this problem, design-time formal methods have been applied with mixed success, but lack of sufficient accuracy in prediction, tool support, and understanding of formalism has prevented wider adoption of the formal techniques. A promising approach to address this challenge is to emulate system behavior and gather data on the QoS parameters of interest by experimentation. To realize this approach, which is preferred over formal methods due to their limitations in accurately predicting QoS, we have developed a model-based automatic performance testing framework with generative capabilities to reduce manual efforts in generating a large number of relevant QoS configurations that can be deployed and tested on a cloud platform. This paper describes our initial efforts in developing and using this technology.

One of the most widely used frameworks for programming MapReduce-based applications is Apache Hadoop. Despite its popularity, however, application developers face numerous challenges in using the Hadoop framework, which stem from them having to effectively manage the resources of a MapReduce cluster, and configuring the framework in a way that will optimize the performance and reliability of MapReduce applications running on it. This paper addresses these problems by presenting the Profiling and Performance Analysis-based System (PPABS) framework, which automates the tuning of Hadoop configuration settings based on deduced application performance requirements. The PPABS framework comprises two distinct phases called the Analyzer, which trains PPABS to form a set of equivalence classes of MapReduce applications for which the most appropriate Hadoop config- uration parameters that maximally improve performance for that class are determined, and the Recognizer, which classifies an incoming unknown job to one of these equivalence classes so that its Hadoop configuration parameters can be self-tuned. The key research contributions in the Analyzer phase includes modifications to the well-known k - means + + clustering and Simulated Annealing algorithms, which were required to adapt them to the MapReduce paradigm. The key contributions in the Recognizer phase includes an approach to classify an unknown, incoming job to one of the equivalence classes and a control strategy to self-tune the Hadoop cluster configuration parameters for that job. Experimental results comparing the performance improvements for three different classes of applications running on Hadoop clusters deployed on Amazon EC2 show promising results.

Component-based programming models are well-suited to the design of large-scale, distributed applications because of the ease with which distributed functionality can be developed, deployed, and validated using the models' compositional properties. Existing component models supported by standardized technologies, such as the OMG's CORBA Component Model (CCM), however, incur a number of limitations in the context of cyber physical systems (CPS) that operate in highly dynamic, resource-constrained, and uncertain environments, such as space environments, yet require multiple quality of service (QoS) assurances, such as timeliness, reliability, and security. To overcome these limitations, this paper presents the design of a novel component model called F6COM that is developed for applications operating in the context of a cluster of fractionated spacecraft. Although F6COM leverages the compositional capabilities and port abstractions of existing component models, it provides several new features. Specifically, F6COM abstracts the component operations as tasks, which are scheduled sequentially based on a specified scheduling policy. The infrastructure ensures that at any time at most one task of a component can be active - eliminating race conditions and deadlocks without requiring complicated and error-prone synchronization logic to be written by the component developer. These tasks can be initiated due to (a) interactions with other components, (b) expiration of timers, both sporadic and periodic, and (c) interactions with input/output devices. Interactions with other components are facilitated by ports. To ensure secure information flows, every port of an F6COM component is associated with a security label such that all interactions are executed within a security context. Thus, all component interactions can be subjected to Mandatory Access Control checks by a Trusted Computing Base that facilitates the interactions. Finally, F6COM provides capabilities to monitor task execution deadlines and to configure component-specific fault mitigation actions.

There is a growing trend towards migrating applications and services to the cloud. This trend has led to the emergence of different cloud service providers (CSPs), in turn leading to different cost models offered by these CSPs to lease their resources, variabilities in the granularity and specification of resources provided, and heterogeneous APIs offered by the CSPs to the users to program resource requests and deployment for their cloud-hosted services. These challenges make it hard for customers of the cloud to seamlessly transition their services to the cloud or migrate between different CSPs. To address these challenges, this paper presents a solution based on model-driven engineering (MDE). Specifically, we describe the design of the domain-specific modeling languages in our MDE framework and the associated generative mechanisms that address the challenges related to estimating performance and cost to host the services in the cloud, automated deployment and resource management.

Vehicular Ad-hoc Networks (VANETs) are increasingly used to support critical services that improve traffic safety and alleviate traffic congestion. Developing VANET-based services and applications, however, is hindered due primarily to limited and often fluctuating communication capacity of VANETs that stem from the wireless and mobile nature of vehicle-tovehicle (V2V) communications. To address this limitation, Road- Side Units (RSU) have been proposed to complement V2V communication by providing event and data brokering capability in the form of Vehicle-to-Infrastructure (V2I) communications. This paper proposes a novel Voronoi network-based algorithm for the effective placement of RSU's which when deployed forms Voronoi networks in terms of the amount of delay incurred by data packets sent over the RSUs.

Distributed real-time and embedded (DRE) systems are a class of real-time systems formed through a composition of predominantly legacy, closed and statically scheduled real-time subsystems, which comprise over-provisioned resources to deal with worst-case failure scenarios. The formation of the system-of-systems leads to a new range of faults that manifest at different granularities for which no statically defined fault tolerance scheme applies. Thus, dynamic and adaptive fault tolerance mechanisms are needed which must execute within the available resources without compromising the safety and timeliness of existing real-time tasks in the individual subsystems. To address these requirements, this paper describes a middleware solution called Safe Middleware Adaptation for Real-Time Fault Tolerance (SafeMAT), which opportunistically leverages the available slack in the over-provisioned resources of individual subsystems. SafeMAT comprises three primary artifacts: (1) a flexible and configurable distributed, runtime resource monitoring framework that can pinpoint in real-time the available slack in the system that is used in making dynamic and adaptive fault tolerance decisions, (2) a safe and resource aware dynamic failure adaptation algorithm that enables efficient recovery from different granularities of failures within the available slack in the execution schedule while ensuring real-time constraints are not violated and resources are not overloaded, and (3) a framework that empirically validates the correctness of the dynamic mechanisms and the safety of the DRE system. Experimental results evaluating SafeMAT on an avionics application indicates that SafeMAT incurs only 9-15% runtime fail over and 2-6% processor utilization overheads thereby providing safe and predictable failure adaptability in real-time.

Distributed applications are increasingly developed by composing many participants, such as services, components, and objects. When deploying distributed applications into a mobile ad hoc cloud, the locality of application participants that communicate with each other can affect latency, power/\-battery usage, throughput, and whether or not a cloud provider can meet service-level agreements (SLA). Optimization of important communication links within a distributed application is particularly important when dealing with mission-critical applications deployed in a distributed real-time and embedded (DRE) scenario, where violation of SLAs may result in loss of property, cyber infrastructure, or lives. To complicate the optimization process, the underlying cloud environment can change during operation and an optimal deployment of the distributed application may degrade over time due to hardware failures, overloaded hosts, and other issues that are beyond the control of distributed application developers. To optimize performance of distributed applications in dynamic environments, therefore, the deployment of participants may need adapting and revising according to the requirements of application developers and the resources available in the underlying cloud environment. This paper present two contributions to the study of dynamic optimizations of user-provided deployments within a cloud. First, we present a dataflow description language that allows developers to designate key communication paths between participants within their distributed applications. Second, we describe heuristics that use this dataflow representation to identify optimal configurations for initial deployments and/or subsequent redeployments within a cloud. An experiment is presented to validate the heuristic approaches.

Vehicular Ad-hoc Networks (VANETs) form the basis for critical services that improve traffic safety and alleviate traffic congestion. The reliability of VANET-based services and applications that are based solely on vehicle-to-vehicle (V2V) communications, however, is hindered due primarily to limited and often fluctuating V2V communications. To address this limitation, Road-Side Units (RSU) have been proposed to complement V2V communications by providing stable event and data brokering capability. Effective placement of the RSUs is a key requirement in improving reliability of VANET services. This poster describes a novel Voronoi network-based algorithm for the effective placement of RSUs. The reliability metric considered in placing the RSUs involves bounding both the delay incurred by communication packets and packet loss, which in turn ensure timeliness and correct operation of the VANET services.

Large-scale component-based enterprise applications that leverage Cloud resources expect Quality of Service(QoS) guarantees in accordance with service level agreements between the customer and service providers. In the context of Cloud computing, auto scaling mechanisms hold the promise of assuring QoS properties to the applications while simultaneously making efficient use of resources and keeping operational costs low for the service providers. Despite the perceived advantages of auto scaling, realizing the full potential of auto scaling is hard due to multiple challenges stemming from the need to precisely estimate resource usage in the face of significant variability in client workload patterns. This paper makes three contributions to overcome the general lack of effective techniques for workload forecasting and optimal resource allocation. First, it discusses the challenges involved in auto scaling in the cloud. Second, it develops a model-predictive algorithm for workload forecasting that is used for resource auto scaling. Finally, empirical results are provided that demonstrate that resources can be allocated and deal located by our algorithm in a way that satisfies both the application QoS while keeping operational costs low.

Enterprise distributed real-time and embedded (DRE) systems are increasingly being developed with the use of component-based software techniques. Unfortunately, commonly used component middleware platforms provide limited support for event-based publish/subscribe (pub/sub) mechanisms that meet both quality-of-service (QoS) and configurability requirements of DRE systems. On the other hand, although pub/sub technologies, such as OMG Data Distribution Service (DDS), support a wide range of QoS settings, the level of abstraction they provide make it hard to configure them due to the significant source-level configuration that must be hard-coded at compile time or tailored at run-time using proprietary, ad hoc configuration logic. Moreover, developers of applications using native pub/sub technologies must write large amounts of boilerplate "glue" code to support run-time configuration of QoS properties, which is tedious and error-prone. This paper describes a novel, generative approach that combines the strengths of QoS-enabled pub/sub middleware with component-based middleware technologies. In particular, this paper describes the design and implementation of DDS4CIAO which addresses a number of inherent and accidental complexities in the DDS4CCM standard. DDS4CIAO simplifies the development, deployment, and configuration of component-based DRE systems that leverage DDS's powerful QoS capabilities by provisioning DDS QoS policy settings and simplifying the development of DDS applications.

General-purpose middleware must often be specialized for resource-constrained, real-time and embedded systems to improve their response-times, reliability, memory footprint, and even power consumption. Software engineering techniques, such as aspect-oriented programming (AOP), feature-oriented programming (FOP), and reflection make the specialization task simpler, albeit still requiring the system developer to manually identify the system invariants, and sources of performance and memory footprint bottlenecks that determine the required specializations. Specialization reuse is also hampered due to a lack of common taxonomy to document the recurring specializations. This paper presents the GeMS (Generative Middleware Specialization) framework to address these challenges. We present results of applying GeMS to a Distributed Real-time and Embedded (DRE) system case study that depict a 21-35% reduction in footprint, and a 3̃6% improvement in performance while simultaneously alleviating 9̃7% of the developer efforts in specializing middleware.

Smart phones are starting to find use in mission critical applications, such as search-and-rescue operations, wherein the mission capabilities are realized by deploying a collaborating set of services across a group of smart phones involved in the mission. Since these missions are deployed in environments where replenishing resources, such as smart phone batteries, is hard, it is necessary to maximize the lifespan of the mission while also maintaining its real-time quality of service (QoS) requirements. To address these requirements, this paper presents a deployment framework called Smart Deploy, which integrates bin packing heuristics with evolutionary algorithms to produce near-optimal deployment solutions that are computationally inexpensive to compute for maximizing the lifespan of smart phone-based mission critical applications. The paper evaluates the merits of deployments produced by Smart Deploy for a search-and-rescue mission comprising a heterogeneous mix of smart phones by integrating a worst-fit bin packing heuristic with particle swarm optimization and genetic algorithm. Results of our experiments indicate that the missions deployed using Smart Deploy have a lifespan that is 20% to 162% greater than those deployed using just the bin packing heuristic or evolutionary algorithms. Although Smart Deploy is slightly slower than the other algorithms, the slower speed is acceptable for offline computations of deployment.

For service providers of multi-tiered component-based applications, such as web portals, assuring high performance and availability to their customers without impacting revenue requires effective and careful capacity planning that aims at minimizing the number of resources, and utilizing them efficiently while simultaneously supporting a large customer base and meeting their service level agreements. This paper presents a novel, hybrid capacity planning process that results from a systematic blending of 1) analytical modeling, where traditional modeling techniques are enhanced to overcome their limitations in providing accurate performance estimates; 2) profile-based techniques, which determine performance profiles of individual software components for use in resource allocation and balancing resource usage; and 3) allocation heuristics that determine minimum number of resources to allocate software components. Our results illustrate that using our technique, performance (i.e., bounded response time) can be assured while reducing operating costs by using 25% less resources and increasing revenues by handling 20% more clients compared to traditional approaches.

Service providers hosting multi-tiered applications require accurate analytical models of the applications they will host for different system management activities, such as capacity planning, configuration management, cost analysis and feedback control. Due to the complexity of real world scenarios, developing accurate analytical models is hard. This paper presents the commonly faced challenges in developing these analytical models that stem from real-world issues, such as excessive system activity, presence of multiple cores or processors, and concurrency management. Presence of multi-tiered applications further compounds the challenges faced. We sketch preliminary ideas based on application-specific and/or domain-specific modeling techniques to overcome these limitations.

Developing large-scale distributed real-time and embedded (DRE) systems is hard in part due to complex deployment and configuration issues involved in satisfying multiple quality for service (QoS) properties, such as real-timeliness and fault tolerance. This paper makes three contributions to the study of deployment and configuration middleware for DRE systems that satisfy multiple QoS properties. First, it describes a novel task allocation algorithm for passively replicated DRE systems to meet their real-time and fault-tolerance QoS properties while consuming significantly less resources. Second, it presents the design of a strategizable allocation engine that enables application developers to evaluate different allocation algorithms. Third, it presents the design of a middleware agnostic configuration framework that uses allocation decisions to deploy application components/replicas and configure the underlying middleware automatically on the chosen nodes. These contributions are realized in the DeCoRAM (Deployment and Configuration Reasoning and Analysis via Modeling) middleware. Empirical results on a distributed testbed demonstrate DeCoRAM’s ability to handle multiple failures and provide efficient and predictable real-time performance.

General-purpose middleware, by definition, cannot readily support domain-specific semantics without significant manual efforts in specializing the middleware. This paper presents GRAFT (GeneRative Aspects for Fault Tolerance), which is a model-driven, automated, and aspects-based approach for specializing general-purpose middleware with failure handling and recovery semantics imposed by a domain.Model-driven techniques are used to specify the special fault tolerance requirements, which are then transformed into middleware-level code artifacts using generative programming. Since the resulting fault tolerance semantics often crosscut the middleware architecture, GRAFT uses aspect-oriented programming to weave them into the original fabric of the general-purpose middleware. We evaluate the capabilities of GRAFT using a representative case study.

Supporting uninterrupted services for distributed soft real-time applications is hard in resource-constrained and dynamic environments, where processor or process failures and system workload changes are common. Fault-tolerant middleware for these applications must achieve high service availability and satisfactory response times for client applications. Although passive replication is a promising fault tolerance strategy for resource-constrained systems, conventional client failover approaches are non-adaptive and load-agnostic, which can cause system overloads and significantly increase response times after failure recovery.This paper presents four contributions to the study of passive replication for distributed soft real-time applications. First, it describes how our Fault-tolerant Load-aware and Adaptive middlewaRe (FLARe) dynamically adjusts failover targets at runtime in response to system load fluctuations and resource availability. Second, it describes how FLARe's overload management strategy proactively enforces desired CPU utilization bounds by redirecting clients from overloaded processors. Third, it presents the design and implementation of FLARe's lightweight middleware architecture that manages failures and overloads transparently to clients. Finally, it presents experimental results on a distributed Linux testbed that demonstrate how FLARe adaptively maintains soft real-time performance for clients operating in the presence of failures and overloads with negligible runtime overhead.

Although component middleware is increasingly used to develop distributed, real-time and embedded (DRE) systems, it poses new fault tolerance challenges, such as the need for efficient synchronization of internal component state, failure correlation across groups of components, and configuration of fault-tolerance properties at the component granularity level. This paper makes two contributions to R&D on component-based fault-tolerance. First, we present the structure and functionality of our component replication based on failover units (CORFU) middleware, which provides fail-stop behavior and fault correlation across groups of components in DRE systems. Second, we empirically evaluate CORFU and compare/contrast it with existing object-oriented fault-tolerance methods. Our results show that component middleware (1) has acceptable fault-tolerance performance for DRE systems and (2) eases the burden of application development by providing middleware support for fault-tolerance at the component level.

In modern enterprises, workflows are essential to automating business processes. During their execution, workflows need to interact with users using a mechanism called dialogs to deliver information and collect input that is required for further decision-making in the workflows. Information delivery and input collection by enterprise workflows is often a time-sensitive matter. Thus, dialogs have to be communicated to users in a timely fashion, which necessitates sending dialogs to user communication endpoints that permit the recipients to quickly, effectively, and conveniently view the information and provide the requested feedback. The proliferation of communication devices and clients among enterprise users implies that the content and rendering of dialogs has to be tailored to a large number of endpoints and preferably by middleware. This customization poses several challenges to developing and maintaining a manageable, extensible, and flexible middleware mechanism for synthesizing dialogs from specific decision points in enterprise workflows. In this paper, we first describe the challenges associated with context-sensitive dialog synthesis. We discuss how we applied templatized model transformation techniques to automatically synthesize dialogs in enterprise workflows. We show how our templatized transformation approach supports the evolution of communication endpoints and system requirements with a minimum of downtime and invasive design changes. We demonstrate our approach in the context of a representative enterprise case study.

The adage "the whole is not equal to the sum of its parts" is very appropriate in the context of verifying a range of systemic properties, such as deadlocks, correctness, and conformance to quality of service (QoS) requirements, for component-based distributed real-time and embedded (DRE) systems. For example, end-to-end worst case response time (WCRT) in component-based DRE systems is not as simple as accumulating WCRT for each individual component in the system because of inherent complexities introduced by the large solution space of possible deployment and configurations. This paper describes a novel process and tool-based artifacts that simplify the formal specification of component-based DRE systems for verification of systemic QoS properties. Our approach is based on the mathematical formalism of Timed Input/Output Automata and uses generative programming techniques for automating the verification of systemic QoS properties for component-based DRE systems.

Predictable deployment and configuration (D&C) of components in response to dynamic environmental changes or system mode changes is essential for ensuring open distributed real-time and embedded (DRE) system real-time QoS. This paper provides three contributions to research on the predictability of D&C for component-based open DRE systems. First, we describe how the dependency relationships among different components and their criticality levels can cause deployment order inversion of tasks, which impedes deployment predictability. Second, we describe how to minimize D&C latency of mission-critical tasks with a multi-graph dependency tracing and graph recomposition algorithm called CaDAnCE. Third, we empirically evaluate the effectiveness of CaDAnCE on a representative open DRE system case study based on NASA Earth Science Enterprise's Magnetospheric Multi-Scale (MMS) mission system. Our results show that CaDAnCE avoids deployment order inversion while incurring negligible (<1%) performance overhead, thereby significantly improving D&C predictability.

Recent advances in software processes and artifacts for automating middleware configurations in distributed realtime and embedded (DRE) systems are starting to address the complexities faced by system developers in dealing with the flexibility and configurability provided by contemporary middleware. Despite the benefits of these new processes, there remain significant challenges in verifying their correctness, and validating their effectiveness in meeting the end-to-end quality of service (QoS) requirements of DRE systems. This paper addresses this problem by describing how model-checking and structural correspondence can be used to verify the correctness of a middleware QoS configuration process that uses model-based graph transformations at its core. Next, it provides empirical proof to validate the effectiveness of our technique to meet the end-to-end QoS requirements in the context of a representative DRE system.

This paper provides two contributions to the study of quality of service (QoS)-enabled middleware that supports the network QoS requirements of distributed real-time and embedded (DRE) systems. First, we describe the design and implementation of NetQoPE, which is a model-driven component middleware framework that shields applications from the details of network QoS mechanisms by (1) specifying per-flow network QoS requirements, (2) performing resource allocation and validation decisions (such as admission control), and (3) enforcing per-flow network QoS at runtime. Second, we evaluate the effort required and flexibility of using NetQoPE to provide network QoS assurance to end-to-end application flows. Our results demonstrate that NetQoPE can provide network-level differentiated performance to each application flow without modifying its programming model or source code, thereby providing greater flexibility in leveraging network-layer mechanisms.

Quite often the modeling tools used in the development lifecycle of distributed real-time and embedded (DRE) systems are middleware-specific, where they elevate middleware artifacts, such as configuration options, to first class modeling entities. Unfortunately, this level of abstraction does not resolve the complex issues in middleware configuration process for QoS assurance. This paper describes GT-QMAP (graph transformation for QoS mapping) model-driven engineering toolchain that combines (1) domain-specific modeling, to simplify specifying the QoS requirements of DRE systems intuitively, and (2) model transformations, to automate the mapping of domain-specific QoS requirements to middleware-specific QoS configuration options. The paper evaluates the automation capabilities of GT-QMAP in the context of three DRE system case studies. The results indicate that on an average the modeling effort is reduced by over 75%. Further, the results also indicate that GT-QMAP provides significant benefits in terms of scalability and automation as DRE system QoS requirements evolve during its entire development lifecycle.

Abstract In model‐driven engineering, it is often desirable to evaluate different design alternatives as they relate to scalability issues of the modeled system. A typical approach to address scalability is model replication, which starts by creating base models that capture the key entities as model elements and their relationships as model connections. A collection of base models can be adorned with necessary information to characterize a specific scalability concern as it relates to how the base modeling elements are replicated and connected together. In current modeling practice, such a model replication is usually accomplished by scaling the base model manually. This is a time‐consuming process that represents a source of error, especially when there are deep interactions between model components. As an alternative to the manual process, this paper presents the idea of automated model replication through a model transformation process that expands the number of elements from the base model and makes the correct connections among the generated modeling elements. The paper motivates the need for model replication through case studies taken from models supporting different domains. Copyright © 2008 John Wiley & Sons, Ltd.

A key enabler of the recently popularized, assembly-centric development approach for distributed real-time software systems is QoS-enabled middleware, which provides reusable building blocks in the form of design patterns that codify solutions to commonly recurring problems. These patterns can be customized by choosing an appropriate set of configuration parameters. The configuration options of the patterns exert a strong influence on system performance, which is of paramount importance in many distributed software systems. Despite this considerable influence, currently there is a lack of significant research to analyze performance of middleware at design time, where performance issues can be resolved at a much earlier stage of the application life cycle and with substantially less costs. The present project seeks to develop a performance analysis methodology for design-time performance analysis for distributed software systems implemented using middleware patterns and their compositions. The methodology is illustrated on a producer/consumer system implemented using the active object (AO) pattern in middleware. Finally, broader impacts of the methodology for middleware specialization are also described.

As quality of service (QoS)-enabled component middleware technologies gain widespread acceptance to build distributed real-time and embedded (DRE) systems, it becomes necessary for these technologies to support real-time publish/subscribe services, which is a key requirement of a large class of DRE systems. To date there have been very limited systematic studies evaluating different approaches to integrating real-time publish/subscribe services in QoS-enabled component middleware. This paper makes two contributions in addressing these key research questions. First, we evaluate the pros and cons of three different design alternatives for integrating publish/subscribe services within QoS-enabled component middleware. Second, we empirically evaluate the performance of our container-based design and compare it with mature object-oriented real-time publish/subscribe implementations. Our studies reveal that both the performance and scalability of our design and implementation are comparable to its object-oriented counterpart, which provides a key guidance to the suitability of component technologies for DRE systems.

This paper provides three contributions to the study of quality of service (QoS) configuration in component-based DRE systems. First, we describe the challenges associated with mapping the platform-independent QoS policies of an application into platform-dependent values of QoS parameters used to configure the behavior of QoS-enabled component middleware. Second, we describe a novel approach that uses model-transformation to map these QoS policies onto component middleware QoS configuration parameters. Third, we demonstrate the use of model-checking to verify the properties of the transformation and automate the synthesis of configuration parameters required to tune the QoS-enabled component middleware. Our results indicate that model-transformation and model-checking provide significant benefits with respect to automation, reusability, verifiability, and scalability of the QoS mapping process compared with conventional middleware configuration techniques

Developers of highly configurable performance-intensive software systems often use in-house performance-oriented "regression testing" to ensure that their modifications do not adversely affect their software's performance across its large configuration space. Unfortunately, time and resource constraints can limit in-house testing to a relatively small number of possible configurations, followed by unreliable extrapolation from these results to the entire configuration space. As a result, many performance bottlenecks escape detection until systems are fielded. In our earlier work, we improved the situation outlined above by developing an initial quality assurance process called "main effects screening". This process 1) executes formally designed experiments to identify an appropriate subset of configurations on which to base the performance-oriented regression testing, 2) executes benchmarks on this subset whenever the software changes, and 3) provides tool support for executing these actions on in-the-field and in-house computing resources. Our initial process had several limitations, however, since it was manually configured (which was tedious and error-prone) and relied on strong and untested assumptions for its accuracy (which made its use unacceptably risky in practice). This paper presents a new quality assurance process called "reliable effects screening" that provides three significant improvements to our earlier work. First, it allows developers to economically verify key assumptions during process execution. Second, it integrates several model-driven engineering tools to make process configuration and execution much easier and less error prone. Third, we evaluate this process via several feasibility studies of three large, widely used performance-intensive software frameworks. Our results indicate that reliable effects screening can detect performance degradation in large-scale systems more reliably and with significantly less resources than conventional techniques

Concurrency can be implemented in a Web server using synchronous and asynchronous mechanisms offered by the underlying operating system. Compared to the synchronous mechanisms, the asynchronous mechanisms are attractive because they provide the benefit of concurrency while alleviating much of the overhead and complexity of multithreading. The proactor pattern in middleware, which effectively encapsulates the asynchronous mechanisms supported by the operating system, can be used to implement a high performance Web server. In this paper, we present a queuing model of an asynchronous Web server implemented using the proactor pattern. We then describe a decomposition strategy to enable the application of the model in practical scenarios. We demonstrate the use of the model to guide configuration and provisioning decisions with several examples

Product-line architectures (PLAs) are an emerging paradigm for developing software families for distributed real-time and embedded (DRE) systems by customizing reusable artifacts, rather than hand-crafting software from scratch. To reduce the effort of developing software PLAs and product variants for DRE systems, developers are applying general-purpose -- ideally standard -- middleware platforms whose reusable services and mechanisms support a range of application quality of service (QoS) requirements, such as low latency and jitter. The generality and flexibility of standard middleware, however, often results in excessive time/space overhead for DRE systems, due to lack of optimizations tailored to meet the specific QoS requirements of different product variants in a PLA.This paper provides the following contributions to the study of middleware specialization techniques for PLA-based DRE systems. First, we identify key dimensions of generality in standard middleware stemming from framework implementations, deployment platforms, and middleware standards. Second, we illustrate how context-specific specialization techniques can be automated and used to tailor standard middleware to better meet the QoS needs of different PLA product variants. Third, we quantify the benefits of applying automated tools to specialize a standard Realtime CORBA middleware implementation. When applied together, these middleware specializations improved our application product variant throughput by ~65%, average- and worst-case end-to-end latency measures by ~43% and ~45%, respectively, and predictability by a factor of two over an already optimized middleware implementation, with little or no effect on portability, standard middleware APIs, or application software implementations, and interoperability.

Model-driven development (MDD) is gaining importance as an approach to resolving lifecycle challenges of large-scale distributed real-time and embedded (DRE) systems (e.g., avionics mission computing). DRE systems are characterized by their stringent requirements for quality of service (QoS), such as predictable end-to-end latencies, timeliness and scalability. Delivering the QoS needs of DRE systems entails the need to configure correctly, fine tune and provision the infrastructure used to host the DRE systems, which crosscuts different layers of middleware, operating systems and networks. Addressing these tangled deployment and configuration concerns of DRE systems requires integrating the principles of Aspect-Oriented Software Development (AOSD) with MDD. This demo showcases a set of software tools that resolve both the inherently and accidental complexities arising due to the configuration and deployment crosscutting concerns of component middleware-based DRE systems.

The growing reliance on services provided by software applications places a high premium on the reliable and efficient operation of these applications. A number of these applications follow the event-driven software architecture style since this style fosters evolvability by separating event handling from event demultiplexing and dispatching functionality. The event demultiplexing capability, which appears repeatedly across a class of event-driven applications, can be codified into a reusable pattern, such as the reactor pattern. In order to enable performance analysis of event-driven applications at design time, a model is needed that represents the event demultiplexing and handling functionality that lies at the heart of these applications. In this paper, we present a model of the reactor pattern based on the well-established stochastic reward net (SRN) modeling paradigm. We discuss how the model can be used to obtain several performance measures such as the throughput, loss probability and upper and lower bounds on the response time. We illustrate how the model can be used to obtain the performance metrics of a virtual private network (VPN) service provided by a virtual router (VR). We validate the estimates of the performance measures obtained from the SRN model using simulation

The ever increasing societal demand for the timely availability of newer and feature-rich but highly dependable network-centric applications imposes the need for these applications to be constructed by the composition, assembly and deployment of off-the-shelf infrastructure and domain-specific services building blocks. Service oriented architecture (SOA) is an emerging paradigm to build applications in this manner by defining a choreography of loosely coupled building blocks. However, current research in SOA does not yet address the per for mobility (i.e., performance and dependability) challenges of these modern applications. Our research is developing novel mechanisms to address these challenges. We initially focus on the composition and configuration of the infrastructure hosting the individual services. We illustrate the use of domain-specific modeling languages and model weavers to model infrastructure composition using middleware building blocks, and to enhance these models with the desired performability attributes. We also demonstrate the use of generative tools that synthesize metadata from these models for performability validation using analytical, simulation and empirical benchmarking tools.

Developing real-time software for large-scale distributed real-time and embedded (DRE) systems is hard due to variabilities that arise from (I) integration with various subsystems based on different programming languages and hardware, OS, middleware platforms, (2) fine tuning the system to satisfy a range of customer requirements, such as various quality-of-service (QoS) properties, and (3) changing functional and QoS properties of the system based on available system resources. This paper describes our experience applying model-driven development (MDD) tools and QoS-enabled component middleware technologies to address domain- and middleware-specific variability challenges in an inventory tracking system, which manages the storage and flow of items in warehouses. Our results show that (I) coherent integration of MDD tools and component middleware can provide a productive software process for developing DRE systems by modularizing and composing variability concerns and (2) significant challenges remain that must be overcome to apply these technologies to a broader range of DRE systems.

Domain-specific models increase the level of abstraction used to develop large-scale component-based systems. Model-driven development (MDD) approaches (e.g., Model-Integrated Computing and Model-Driven Architecture) emphasize the use of models at all stages of system development. Decomposing problems using MDD approaches may result in a separation of the artifacts in a way that impedes comprehension. For example, a single concern (such as deployment of a distributed system) may crosscut different orthogonal activities (such as component specification, interaction, packaging and planning). To keep track of all entities associated with a component, and to ensure that the constraints for the system as a whole are not violated, a purely model-driven approach imposes extra effort, thereby negating some of the benefits of MDD. This paper provides three contributions to the study of applying aspect-oriented techniques to address the crosscutting challenges of model-driven component-based distributed systems development. First, we identify the sources of crosscutting concerns that typically arise in model-driven development of component-based systems. Second, we describe how aspect-oriented model weaving helps modularize these crosscutting concerns using model transformations. Third, we describe how we have applied model weaving using a tool called the Constraint-Specification Aspect Weaver (C-SAW) in the context of the Platform-Independent Component Modeling Language (PICML), which is a domain-specific modeling language for developing component-based systems. A case study of a joint-emergency response system is presented to express the challenges in modeling a typical distributed system. Our experience shows that model weaving is an effective and scalable technique for dealing with crosscutting aspects of component-based systems development.

Society is becoming increasingly reliant on the services provided by distributed, performance sensitive software systems. These systems demand multiple simultaneous quality of service (QoS) properties. A key enabler in recent successes in the development of such systems has been middleware, which comprises reusable building blocks. Typically, a large number of configuration options are available for each building block when composing a system end-to-end. The choice of the building blocks and their configuration options have an impact on the performance of the services provided by the systems. Currently, the effect of these choices can be determined only very late in the lifecycle, which can be detrimental to system development costs and schedules. In order to enable the right design choices, a systematic methodology to analyze the performance of these systems at design time is necessary. Such a methodology may consist of models to analyze the performance of individual building blocks comprising the middleware and the composition of these building blocks. As a first step towards building this methodology, this paper introduces a model of the reactor pattern, which provides important synchronous demultiplexing and dispatching capabilities to network services and applications. The model is based on the stochastic reward net (SRN) modeling paradigm. We illustrate how the model could be used to obtain the response time of a virtual private network (VPN) service provided by a virtual router (VR)

The ever increasing complexity of networks dramatically increases the challenges faced by service providers to analyze network behavior and (re)provision resources to support multiple complex distributed applications. Accurate and scalable simulation tools are pivotal to this cause. The recently proposed hybrid systems model for data communication networks shows promise in achieving performance characteristics comparable to fluid models while retaining the accuracy of discrete models. Using the hybrid systems paradigm, this paper provides contributions to the modeling of TCP behavior and the analysis/simulation of data communication networks based on these models. An important distinguishing feature of our simulation framework is a faithful accounting of link propagation delays which has been ignored in previous work for the sake of simplicity. Other salient aspects of the work include a new finite state machine model for a drop-tail queue, a new model for fast recovery/fast retransmit mode, a revised sending rate model, and an embedded time-out mode transition mechanism all of which employ a time-stepped solution method to solve the hybrid system network models. Our simulation results are consistent with well-known packet based simulators such as ns-2, thus demonstrating the accuracy of our hybrid model. Our future efforts will be directed towards studying and improving the computational performance of hybrid model based simulations.

Developers of highly configurable performance-intensive software systems often use a type of in-house performance-oriented "regression testing" to ensure that their modifications have not adversely affected their software's performance across its large configuration space. Unfortunately, time and resource constraints often limit developers to in-house testing of a small number of configurations and unreliable extrapolation from these results to the entire configuration space, which allows many performance bottlenecks and sources of QoS degradation to escape detection until systems are fielded. To improve performance assessment of evolving systems across large configuration spaces, we have developed a distributed continuous quality assurance (DCQA) process called main effects screening that uses in-the-field resources to execute formally designed experiments to help reduce the configuration space, thereby allowing developers to perform more targeted in-house QA. We have evaluated this process via several feasibility studies on several large, widely-used performance-intensive software systems. Our results indicate that main effects screening can detect key sources of performance degradation in large-scale systems with significantly less effort than conventional techniques.

This paper provides two contributions to the study of developing and applying domain-specific modeling languages (DSMLS) to distributed real-time and embedded (DRE) systems - particularly those systems using standards-based QoS-enabled component middleware. First, it describes the platform-independent component modeling language (PICML), which is a DSML that enables developers to define component interfaces, QoS parameters and software building rules, and also generates descriptor files that facilitate system deployment. Second, it applies PICML to an unmanned air vehicle (UAV) application portion of an emergency response system to show how PICML resolves key component-based DRE system development challenges. Our results show that the capabilities provided by PICML - combined with its design and deployment-time validation capabilities - eliminates many common errors associated with conventional techniques, thereby increasing the effectiveness of applying QoS-enabled component middleware technologies to the DRE system domain.

This paper provides two contributions to R&D on model-driven development (MDD) techniques that help codify the impact of middleware configurations on end-to-end distributed real-time and embedded (DRE) system quality of service (QoS). First, we describe how MDD techniques can help select middleware configuration parameters that satisfy key functional and QoS requirements of DRE systems. Second, we apply our MDD techniques to empirically evaluate the end-to-end QoS of representative DRE systems in the avionics and industrial manufacturing domains. Our results show how MDD techniques significantly enhance conventional ad hoc processes used by developers to configure middleware that meets the QoS needs of DRE systems.

Embedded software and systems are at the intersection of electrical engineering, computer engineering, and computer science, with, increasing importance, in mechanical engineering. Despite the clear need for knowledge of systems modeling and analysis (covered in electrical and other engineering disciplines) and analysis of computational processes (covered in computer science), few academic programs have integrated the two disciplines into a cohesive program of study. This paper describes the efforts conducted at Vanderbilt University to establish a curriculum that addresses the needs of embedded software and systems. Given the compartmentalized nature of traditional engineering schools, where each discipline has an independent program of study, we have had to devise innovative ways to bring together the two disciplines. The paper also describes our current efforts in using learning technology to construct, manage, and deliver sophisticated computer-aided learning modules that can supplement the traditional course structure in the individual disciplines through out-of-class and in-class use.

Commercial off-the-shelf (COTS) middleware is now widely used to develop distributed real-time and embedded (DRE) systems. DRE systems are themselves increasingly combined to form "systems of systems" that have diverse quality of service (QoS) requirements. Earlier generations of COTS middleware, such as Object Request Brokers (ORBs) based on the CORBA 2.x standard, do not facilitate the separation of QoS policies from application functionality, which makes it hard to configure and validate complex DRE applications. The new generation of component middleware, such as the CORBA component model (CCM) based on the CORBA 3.0 standard, addresses the limitations of earlier generation middleware by establishing standards for implementing, packaging, assembling, and deploying component implementations. There has been little systematic empirical study of the performance characteristics of component middleware implementations in the context of DRE systems. This paper therefore provides three contributions to the study of CCM for DRE systems. First, we describe the challenges involved in benchmarking different CORBA component model (CCM) implementations. Second, we describe key criteria for comparing different CCM implementations using key black-box and white-box metrics. Third, we describe the design of our CCMPerf benchmarking suite to illustrate test categories that evaluate aspects of CCM implementation to determine their suitability for the DRE domain. We demonstrate CCMPerf by using it to collect metrics from a CCM implementation designed for DRE applications.

The distributed embedded systems industry is poised to leverage emerging real-time operating systems, such as Inferno Windows CE, EPOC, and Palm OS to support mobile communication applications, such as electronic mail, Internet browsing, and network management. Ideally, these applications can be developed using standard middleware components like CORBA to improve their quality and reduce their cost and cycle time. However, stringent constraints on memory available in embedded systems imposes a severe limit on the footprint of CORBA middleware. This paper provides three contributions to the study and design of small footprint, embedded CORBA middleware. First, we describe the optimizations used to develop the protocol engine and CORBA IDL compiler provided by TAO, which is our real-time CORBA implementation. TAO's IDL compiler produces stubs that can use either compiled and/or interpretive marshalling. Second, we compare the performance and footprint of TAO IDL compiler-generated stubs and skeletons that use compiled and/or interpretive marshalling for a wide range of IDL data types. Third, we illustrate the benefits of the small footprint and efficiency of TAO IDL compiler-generated stubs and skeletons for CORBA object services implemented using TAO. The results comparing the performance of the compiled and interpretive stubs and skeletons indicate that the interpretive stubs and skeletons perform between 75-100% of the compiled stubs and skeletons for a wide range of data types. However the code size for the interpreted stubs and skeletons was between 26-45% and 50-80% of the compiled stubs and skeletons, respectively. These results indicate a positive step towards implementing high performance, small footprint middleware for distributed embedded systems.

To support the quality-of-service (QoS) requirements of embedded multimedia applications off-the-shelf middleware like common object request broker architecture (CORBA) must be flexible, efficient, and predictable. Moreover, stringent memory constraints imposed by embedded system hardware necessitates a minimal footprint for middleware that supports multimedia applications. This paper provides three contributions toward developing efficient object request broker's (ORBs) middleware to support embedded multimedia applications. First, we describe optimization principle patterns used to develop a time and space-efficient CORBA inter-ORB protocol (IIOP) interpreter for the adaptive communication environment (ACE)-ORB (TAO), which is our high-performance, real-time ORB. Second, we describe the optimizations applied to TAO's interface definition language (IDL) compiler to generate efficient and small stubs/skeletons used in TAO's IIOP protocol engine. Third, we empirically compare the performance and memory footprint of interpretive (de)marshaling versus compiled (de)marshaling for a wide range of IDL data types. Applying our optimization principle patterns to TAO's IIOP protocol engine improved its interpretive (de)marshaling performance to the point where it is now comparable to the performance of compiled (de)marshaling. Moreover, our IDL compiler optimizations generate interpreted stubs/skeletons whose footprint is substantially smaller than compiled stubs/skeletons. Our results illustrate that careful application of optimization principle patterns can yield both time and space-efficient standards-based middleware.

There is increasing demand to extend object-oriented middleware, such as OMG CORBA, to support applications with stringent quality of service (QoS) requirements. However, conventional CORBA Object Request Broker (ORE) implementations incur high latency and low scalability when used for performance-sensitive applications. These inefficiencies discourage developers from using CORBA for mission/life-critical applications such as real-time avionics, telecom call processing, and medical imaging. This paper provides two contributions to the research on CORBA performance. First, we systematically analyze the latency and scalability of two widely used CORBA ORBs, VisiBroker and Orbix. These results reveal key sources of overhead in conventional ORBs. Second, we describe techniques used to improve latency and scalability in TAO, which is a high-performance, real-time implementation of CORBA. Although conventional ORBs do not yet provide adequate QoS guarantees to applications, our research results indicate it is possible to implement ORBs that can support high-performance, real-time applications.

We present two contributions to the study of CORBA performance over high-speed networks. First, we measure the latency of various types and sizes of two-way client requests using a pair of widely used implementations of CORBA-Orbix 2.1 and VisiBroker for C++ 2.0. Second, we use Orbix and VisiBroker to measure the scalability of CORBA servers in terms of the number of objects they can support efficiently. These experiments extend our previous work on CORBA performance for bandwidth-sensitive applications (such as satellite surveillance, medical imaging, and teleconferencing). Our results show that the latency for CORBA implementations is relatively high and server scalability is relatively low. Our latency experiments show that non-optimized internal buffering in CORBA implementations can cause substantial delay variance, which is unacceptable in many real-time or constrained-latency applications. Likewise our scalability experiments reveal that neither Orbix nor VisiBroker can handle a large number of objects in a single server process.

Conventional implementations of communication middleware (such as CORBA and traditional RPC toolkits) incur considerable over-head when used for performance-sensitive applications over high-speed networks. As gigabit networks become pervasive, inefficient middleware will force programmers to use lower-level mechanisms to achieve the necessary transfer rates. This is a serious problem for mission/life-critical applications (such as satellite surveillance and medical imaging).This paper compares the performance of several widely used communication middleware mechanisms on a high-speed ATM network. The middleware ranged from lower-level mechanisms (such as socket-based C interfaces and C++ wrappers for sockets) to higher-level mechanisms (such as RPC, hand-optimized RPC and two implementations of CORBA - Orbix and ORBeline). These measurements reveal that the lower-level C and C++ implementations outperform the CORBA implementations significantly (the best CORBA throughput for remote transfer was roughly 75 to 80 percent of the best C/C++ throughput for sending scalar data types and only around 33 percent for sending structs containing binary fields), and the hand-optimized RPC code performs slightly better than the CORBA implementations. Our goal in precisely pinpointing the sources of overhead for communication middleware is to develop scalable and flexible CORBA implementations that can deliver gigabit data rates to applications.